/*

 * Check: a unit test framework for C

 * Copyright (C) 2001, 2002 Arien Malec

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,

 * MA 02110-1301, USA.

 */

#include "../lib/libcompat.h"

#include <sys/types.h>

#include <stdlib.h>

#include <signal.h>

#include <check.h>

#include "check_check.h"

START_TEST(test_lno)

{

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  ck_abort_msg("Failure expected");

}

END_TEST

#if defined(HAVE_FORK) && HAVE_FORK==1

START_TEST(test_mark_lno)

{

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  mark_point();

  exit(EXIT_FAILURE); /* should fail with mark_point above as line */

}

END_TEST

#endif /* HAVE_FORK */

START_TEST(test_pass)

{

  record_test_name(tcase_name());

  ck_assert_msg(1 == 1, "This test should pass");

  ck_assert_msg(9999, "This test should pass");

}

END_TEST

START_TEST(test_fail_unless)

{

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  fail_unless(1 == 2, "This test should fail");

}

END_TEST

START_TEST(test_fail_if_pass)

{

  record_test_name(tcase_name());

  fail_if(1 == 2, "This test should pass");

  fail_if(0, "This test should pass");

}

END_TEST

START_TEST(test_fail_if_fail)

{

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  fail_if(1 == 1, "This test should fail");

}

END_TEST

START_TEST(test_fail_null_msg)

{

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  fail_unless(2 == 3, NULL);

}

END_TEST

#if defined(__GNUC__)

START_TEST(test_fail_no_msg)

{

  record_test_name(tcase_name());

  /* taking out the NULL provokes an ISO C99 warning in GCC */

  record_failure_line_num(__LINE__);

  fail_unless(4 == 5, NULL);

}

END_TEST

#endif /* __GNUC__ */

START_TEST(test_fail_if_null_msg)

{

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  fail_if(2 != 3, NULL);

}

END_TEST

#if defined(__GNUC__)

START_TEST(test_fail_if_no_msg)

{

  record_test_name(tcase_name());

  /* taking out the NULL provokes an ISO C99 warning in GCC */

  record_failure_line_num(__LINE__);

  fail_if(4 != 5, NULL);

}

END_TEST

#endif /* __GNUC__ */

START_TEST(test_fail_vararg_msg_1)

{

  int x = 3;

  int y = 4;

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  fail_unless(x == y, "%d != %d", x, y);

}

END_TEST

START_TEST(test_fail_vararg_msg_2)

{

  int x = 5;

  int y = 6;

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  fail_if(x != y, "%d != %d", x, y);

}

END_TEST

START_TEST(test_fail_vararg_msg_3)

{

  int x = 7;

  int y = 7;

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  fail("%d == %d", x, y);

}

END_TEST

#if defined(__GNUC__)

START_TEST(test_fail_empty)

{

  record_test_name(tcase_name());

  /* plain fail() doesn't compile with xlc in C mode because of `, ## __VA_ARGS__' problem */

  /* on the other hand, taking out the NULL provokes an ISO C99 warning in GCC */

  record_failure_line_num(__LINE__);

  fail(NULL);

}

END_TEST

#endif /* __GNUC__ */

START_TEST(test_ck_abort)

{

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  ck_abort();

}

END_TEST

START_TEST(test_ck_abort_msg)

{

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  ck_abort_msg("Failure expected");

}

END_TEST

/* FIXME: perhaps passing NULL to ck_abort_msg should be an error. */

START_TEST(test_ck_abort_msg_null)

{

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  ck_abort_msg(NULL);

}

END_TEST

/* These ck_assert tests are all designed to fail on the last

   assertion. */

START_TEST(test_ck_assert)

{

  int x = 3;

  int y = 3;

  record_test_name(tcase_name());

  ck_assert(1);

  ck_assert(x == y);

  y++;

  ck_assert(x != y);

  record_failure_line_num(__LINE__);

  ck_assert(x == y);

}

END_TEST

START_TEST(test_ck_assert_null)

{

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  ck_assert(0);

}

END_TEST

START_TEST(test_ck_assert_with_mod)

{

  int f = 1;

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  ck_assert(1%f == 1);

}

END_TEST

START_TEST(test_ck_assert_int_eq)

{

  int x = 3;

  int y = 3;

  record_test_name(tcase_name());

  ck_assert_int_eq(x, y);

  y++;

  record_failure_line_num(__LINE__);

  ck_assert_int_eq(x, y);

}

END_TEST

START_TEST(test_ck_assert_int_eq_with_mod)

{

  int d = 2;

  int f = 1;

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  ck_assert_int_eq(3%d, 2%f);

}

END_TEST

START_TEST(test_ck_assert_int_ne)

{

  int x = 3;

  int y = 2;

  record_test_name(tcase_name());

  ck_assert_int_ne(x, y);

  y++;

  record_failure_line_num(__LINE__);

  ck_assert_int_ne(x, y);

}

END_TEST

START_TEST(test_ck_assert_int_ne_with_mod)

{

  int d = 2;

  int f = 2;

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  ck_assert_int_ne(3%d, 3%f);

}

END_TEST

START_TEST(test_ck_assert_int_lt)

{

  int x = 2;

  int y = 3;

  record_test_name(tcase_name());

  ck_assert_int_lt(x, y);

  record_failure_line_num(__LINE__);

  ck_assert_int_lt(x, x);

}

END_TEST

START_TEST(test_ck_assert_int_lt_with_mod)

{

  int d = 2;

  int f = 1;

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  ck_assert_int_lt(3%d, 3%f);

}

END_TEST

START_TEST(test_ck_assert_int_le)

{

  int x = 2;

  int y = 3;

  record_test_name(tcase_name());

  ck_assert_int_le(x, y);

  ck_assert_int_le(x, x);

  record_failure_line_num(__LINE__);

  ck_assert_int_le(y, x);

}

END_TEST

START_TEST(test_ck_assert_int_le_with_mod)

{

  int d = 2;

  int f = 1;

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  ck_assert_int_le(3%d, 2%f);

}

END_TEST

START_TEST(test_ck_assert_int_gt)

{

  int x = 2;

  int y = 3;

  record_test_name(tcase_name());

  ck_assert_int_gt(y, x);

  record_failure_line_num(__LINE__);

  ck_assert_int_gt(y, y);

}

END_TEST

START_TEST(test_ck_assert_int_gt_with_mod)

{

  int d = 1;

  int f = 2;

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  ck_assert_int_gt(3%d, 3%f);

}

END_TEST

START_TEST(test_ck_assert_int_ge)

{

  int x = 2;

  int y = 3;

  record_test_name(tcase_name());

  ck_assert_int_ge(y, x);

  ck_assert_int_ge(y, x);

  record_failure_line_num(__LINE__);

  ck_assert_int_ge(x, y);

}

END_TEST

START_TEST(test_ck_assert_int_ge_with_mod)

{

  int d = 1;

  int f = 3;

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  ck_assert_int_ge(3%d, 4%f);

}

END_TEST

START_TEST(test_ck_assert_int_expr)

{

  int x = 1;

  int y = 0;

  record_test_name(tcase_name());

  ck_assert_int_eq(x, ++y);

  ck_assert_int_eq(x, y);

} END_TEST

START_TEST(test_ck_assert_uint_eq)

{

  unsigned int x = 3;

  unsigned int y = 3;

  record_test_name(tcase_name());

  ck_assert_uint_eq(x, y);

  y++;

  record_failure_line_num(__LINE__);

  ck_assert_uint_eq(x, y);

}

END_TEST

START_TEST(test_ck_assert_uint_eq_with_mod)

{

  int d = 2;

  int f = 1;

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  ck_assert_uint_eq(3%d, 1%f);

}

END_TEST

START_TEST(test_ck_assert_uint_ne)

{

  unsigned int x = 3;

  unsigned int y = 2;

  record_test_name(tcase_name());

  ck_assert_uint_ne(x, y);

  y++;

  record_failure_line_num(__LINE__);

  ck_assert_uint_ne(x, y);

}

END_TEST

START_TEST(test_ck_assert_uint_ne_with_mod)

{

  int d = 1;

  int f = 1;

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  ck_assert_uint_ne(1%d, 1%f);

}

END_TEST

START_TEST(test_ck_assert_uint_lt)

{

  unsigned int x = 2;

  unsigned int y = 3;

  record_test_name(tcase_name());

  ck_assert_uint_lt(x, y);

  record_failure_line_num(__LINE__);

  ck_assert_uint_lt(x, x);

}

END_TEST

START_TEST(test_ck_assert_uint_lt_with_mod)

{

  int d = 2;

  int f = 1;

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  ck_assert_uint_lt(3%d, 1%f);

}

END_TEST

START_TEST(test_ck_assert_uint_le)

{

  unsigned int x = 2;

  unsigned int y = 3;

  record_test_name(tcase_name());

  ck_assert_uint_le(x, y);

  ck_assert_uint_le(x, x);

  record_failure_line_num(__LINE__);

  ck_assert_uint_le(y, x);

}

END_TEST

START_TEST(test_ck_assert_uint_le_with_mod)

{

  int d = 2;

  int f = 1;

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  ck_assert_uint_le(3%d, 1%f);

}

END_TEST

START_TEST(test_ck_assert_uint_gt)

{

  unsigned int x = 2;

  unsigned int y = 3;

  record_test_name(tcase_name());

  ck_assert_uint_gt(y, x);

  record_failure_line_num(__LINE__);

  ck_assert_uint_gt(y, y);

}

END_TEST

START_TEST(test_ck_assert_uint_gt_with_mod)

{

  int d = 1;

  int f = 2;

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  ck_assert_uint_gt(1%d, 3%f);

}

END_TEST

START_TEST(test_ck_assert_uint_ge)

{

  unsigned int x = 2;

  unsigned int y = 3;

  record_test_name(tcase_name());

  ck_assert_uint_ge(y, x);

  ck_assert_uint_ge(y, x);

  record_failure_line_num(__LINE__);

  ck_assert_uint_ge(x, y);

}

END_TEST

START_TEST(test_ck_assert_uint_ge_with_mod)

{

  int d = 1;

  int f = 2;

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  ck_assert_uint_ge(1%d, 3%f);

}

END_TEST

START_TEST(test_ck_assert_uint_expr)

{

  unsigned int x = 1;

  unsigned int y = 0;

  record_test_name(tcase_name());

  ck_assert_uint_eq(x, ++y);

  ck_assert_uint_eq(x, y);

} END_TEST

START_TEST(test_ck_assert_float_eq)

{

  float x = 1.1f;

  float y = 1.1f;

  record_test_name(tcase_name());

  ck_assert_float_eq(x, y);

  y+=0.1f;

  record_failure_line_num(__LINE__);

  ck_assert_float_eq(x, y);

}

END_TEST

START_TEST(test_ck_assert_float_eq_with_mod)

{

  int d = 2;

  int f = 2;

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  ck_assert_float_eq(3%d, 2%f);

}

END_TEST

START_TEST(test_ck_assert_float_ne)

{

  float x = 1.1f;

  float y = 1.2f;

  record_test_name(tcase_name());

  ck_assert_float_ne(x, y);

  y = x;

  record_failure_line_num(__LINE__);

  ck_assert_float_ne(x, y);

}

END_TEST

START_TEST(test_ck_assert_float_ne_with_mod)

{

  int d = 2;

  int f = 2;

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  ck_assert_float_ne(1%d, 1%f);

}

END_TEST

START_TEST(test_ck_assert_float_lt)

{

  float x = 2.0f;

  float y = 2.5f;

  record_test_name(tcase_name());

  ck_assert_float_lt(x, y);

  y-=1.0f;

  record_failure_line_num(__LINE__);

  ck_assert_float_lt(x, y);

}

END_TEST

START_TEST(test_ck_assert_float_lt_with_mod)

{

  int d = 2;

  int f = 2;

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  ck_assert_float_lt(3%d, 2%f);

}

END_TEST

START_TEST(test_ck_assert_float_le)

{

  float x = 2.0f;

  float y = 2.5f;

  record_test_name(tcase_name());

  ck_assert_float_le(x, y);

  ck_assert_float_le(x, x);

  y-=1.0f;

  record_failure_line_num(__LINE__);

  ck_assert_float_le(x, y);

}

END_TEST

START_TEST(test_ck_assert_float_le_with_mod)

{

  int d = 2;

  int f = 2;

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  ck_assert_float_le(3%d, 2%f);

}

END_TEST

START_TEST(test_ck_assert_float_gt)

{

  float x = 2.5f;

  float y = 2.0f;

  record_test_name(tcase_name());

  ck_assert_float_gt(x, y);

  y+=1.0f;

  record_failure_line_num(__LINE__);

  ck_assert_float_gt(x, y);

}

END_TEST

START_TEST(test_ck_assert_float_gt_with_mod)

{

  int d = 2;

  int f = 2;

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  ck_assert_float_gt(2%d, 3%f);

}

END_TEST

START_TEST(test_ck_assert_float_ge)

{

  float x = 2.5f;

  float y = 2.0f;

  record_test_name(tcase_name());

  ck_assert_float_ge(x, y);

  ck_assert_float_ge(x, x);

  y+=1.0f;

  record_failure_line_num(__LINE__);

  ck_assert_float_ge(x, y);

}

END_TEST

START_TEST(test_ck_assert_float_ge_with_mod)

{

  int d = 2;

  int f = 2;

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  ck_assert_float_ge(2%d, 3%f);

}

END_TEST

START_TEST(test_ck_assert_float_with_expr)

{

  float x[] = {NAN, 1.1f, 1.1f, 1.2f, 1.2f, NAN};

  float y = 1.1f;

  int i;

  record_test_name(tcase_name());

  i = 1;

  ck_assert_float_eq(x[i++], y);

  ck_assert_float_eq(x[i++], y);

  i = 4;

  ck_assert_float_ne(x[i--], y);

  ck_assert_float_ne(x[i--], y);

  y = 1.15f;

  i = 1;

  ck_assert_float_le(x[i++], y);

  ck_assert_float_le(x[i++], y);

  i = 1;

  ck_assert_float_lt(x[i++], y);

  ck_assert_float_lt(x[i++], y);

  i = 4;

  ck_assert_float_gt(x[i--], y);

  ck_assert_float_gt(x[i--], y);

  i = 4;

  ck_assert_float_ge(x[i--], y);

  ck_assert_float_ge(x[i--], y);

}

END_TEST

START_TEST(test_ck_assert_float_eq_tol)

{

  float x = 0.0001f;

  float y = 0.0003f;

  float t = 0.001f;

  record_test_name(tcase_name());

  ck_assert_float_eq_tol(x, y, t);

  ck_assert_float_eq_tol(x, x, t);

  x*=10.0f;

  y*=10.0f;

  t*=10.0f;

  ck_assert_float_eq_tol(x, y, t);

  t/=10.0f;

  record_failure_line_num(__LINE__);

  ck_assert_float_eq_tol(x, y, t);

}

END_TEST

START_TEST(test_ck_assert_float_eq_tol_with_mod)

{

  int d = 2;

  int f = 2;

  int p = 2;

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  ck_assert_float_eq_tol(3%d, 2%f, 2%p);

}

END_TEST

START_TEST(test_ck_assert_float_ne_tol)

{

  float x = 0.0001f;

  float y = 0.0002f;

  float t = 0.0001f;

  record_test_name(tcase_name());

  ck_assert_float_ne_tol(x, y, t);

  x*=10.0f;

  y*=10.0f;

  t*=10.0f;

  ck_assert_float_ne_tol(x, y, t);

  t*=10.0f;

  record_failure_line_num(__LINE__);

  ck_assert_float_ne_tol(x, y, t);

}

END_TEST

START_TEST(test_ck_assert_float_ne_tol_with_mod)

{

  int d = 2;

  int f = 2;

  int p = 2;

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  ck_assert_float_ne_tol(3%d, 3%f, 3%p);

}

END_TEST

START_TEST(test_ck_assert_float_ge_tol)

{

  float x = 0.001f;

  float y = 0.003f;

  float t = 0.001f;

  record_test_name(tcase_name());

  ck_assert_float_ge_tol(y, x, t);

  ck_assert_float_ge_tol(x, x, t);

  ck_assert_float_ge_tol(y, y, t);

  x*=10.0f;

  y*=10.0f;

  t*=10.0f;

  ck_assert_float_ge_tol(y, x, t);

  ck_assert_float_ge_tol(x, x, t);

  ck_assert_float_ge_tol(y, y, t);

  record_failure_line_num(__LINE__);

  ck_assert_float_ge_tol(x, y, t);

}

END_TEST

START_TEST(test_ck_assert_float_ge_tol_with_mod)

{

  int d = 2;

  int f = 2;

  int p = 2;

  record_test_name(tcase_name());

  record_failure_line_num(__LINE__);

  ck_assert_float_ge_tol(2%d, 3%f, 3%p);

}

END_TEST

START_TEST(test_ck_assert_float_le_tol)

{

  float x = 0.001f;

  float y = 0.003f;

  float t = 0.001f;

  record_test_name(tcase_name());

  ck_assert_float_le_tol(x, y, t);

  ck_assert_float_le_tol(x, x, t);

  ck_assert_float_le_tol(y, y, t);

  x*=10.0f;

  y*=10.0f;

  t*=10.0f;