From feb27f903104c1261fc2b824bfca4ae6acc6359c Mon Sep 17 00:00:00 2001 From: Sebastian Huber Date: Wed, 27 Mar 2019 08:16:31 +0100 Subject: ttest01: Add more test cases Update #3199. --- testsuites/libtests/Makefile.am | 15 + testsuites/libtests/ttest01/init.c | 54 +- testsuites/libtests/ttest01/test-assert.c | 95 + testsuites/libtests/ttest01/test-checks.c | 2919 +++++++++++++++++++++++++ testsuites/libtests/ttest01/test-destructor.c | 54 + testsuites/libtests/ttest01/test-eno.c | 60 + testsuites/libtests/ttest01/test-fixture.c | 96 + testsuites/libtests/ttest01/test-leak.c | 170 ++ testsuites/libtests/ttest01/test-log.c | 46 + testsuites/libtests/ttest01/test-malloc.c | 93 + testsuites/libtests/ttest01/test-plan.c | 73 + testsuites/libtests/ttest01/test-psx.c | 75 + testsuites/libtests/ttest01/test-rtems.c | 109 + testsuites/libtests/ttest01/test-simple.c | 53 + testsuites/libtests/ttest01/test-step.c | 45 + testsuites/libtests/ttest01/test-time.c | 228 ++ testsuites/libtests/ttest01/test-verbosity.c | 55 + 17 files changed, 4237 insertions(+), 3 deletions(-) create mode 100644 testsuites/libtests/ttest01/test-assert.c create mode 100644 testsuites/libtests/ttest01/test-checks.c create mode 100644 testsuites/libtests/ttest01/test-destructor.c create mode 100644 testsuites/libtests/ttest01/test-eno.c create mode 100644 testsuites/libtests/ttest01/test-fixture.c create mode 100644 testsuites/libtests/ttest01/test-leak.c create mode 100644 testsuites/libtests/ttest01/test-log.c create mode 100644 testsuites/libtests/ttest01/test-malloc.c create mode 100644 testsuites/libtests/ttest01/test-plan.c create mode 100644 testsuites/libtests/ttest01/test-psx.c create mode 100644 testsuites/libtests/ttest01/test-rtems.c create mode 100644 testsuites/libtests/ttest01/test-simple.c create mode 100644 testsuites/libtests/ttest01/test-step.c create mode 100644 testsuites/libtests/ttest01/test-time.c create mode 100644 testsuites/libtests/ttest01/test-verbosity.c diff --git a/testsuites/libtests/Makefile.am b/testsuites/libtests/Makefile.am index 20a5a6fc5e..1300a5f669 100644 --- a/testsuites/libtests/Makefile.am +++ b/testsuites/libtests/Makefile.am @@ -1525,7 +1525,22 @@ lib_tests += ttest01 lib_screens += ttest01/ttest01.scn lib_docs += ttest01/ttest01.doc ttest01_SOURCES = ttest01/init.c +ttest01_SOURCES += ttest01/test-assert.c +ttest01_SOURCES += ttest01/test-checks.c +ttest01_SOURCES += ttest01/test-destructor.c +ttest01_SOURCES += ttest01/test-eno.c ttest01_SOURCES += ttest01/test-example.c +ttest01_SOURCES += ttest01/test-fixture.c +ttest01_SOURCES += ttest01/test-leak.c +ttest01_SOURCES += ttest01/test-log.c +ttest01_SOURCES += ttest01/test-malloc.c +ttest01_SOURCES += ttest01/test-plan.c +ttest01_SOURCES += ttest01/test-psx.c +ttest01_SOURCES += ttest01/test-rtems.c +ttest01_SOURCES += ttest01/test-simple.c +ttest01_SOURCES += ttest01/test-step.c +ttest01_SOURCES += ttest01/test-time.c +ttest01_SOURCES += ttest01/test-verbosity.c ttest01_CPPFLAGS = $(AM_CPPFLAGS) $(TEST_FLAGS_ttest01) \ $(support_includes) endif diff --git a/testsuites/libtests/ttest01/init.c b/testsuites/libtests/ttest01/init.c index 135dc2b25e..cb4ad95829 100644 --- a/testsuites/libtests/ttest01/init.c +++ b/testsuites/libtests/ttest01/init.c @@ -32,6 +32,8 @@ #include #include +#include +#include #include "t-self-test.h" @@ -47,6 +49,7 @@ typedef struct { const char *c; size_t case_begin_count; size_t case_end_count; + struct timecounter tc; } test_context; static test_context test_instance; @@ -138,11 +141,44 @@ now(void) return t * SBT_1MS; } +static uint32_t +get_timecount(struct timecounter *tc) +{ + return 0; +} + +static void +install_timecounter(void) +{ + test_context *ctx; + + ctx = &test_instance; + ctx->tc.tc_get_timecount = get_timecount; + ctx->tc.tc_counter_mask = 0xffffffff; + ctx->tc.tc_frequency = 1000000000; + ctx->tc.tc_quality = RTEMS_TIMECOUNTER_QUALITY_CLOCK_DRIVER + 1; + rtems_timecounter_install(&ctx->tc); +} + +RTEMS_SYSINIT_ITEM(install_timecounter, RTEMS_SYSINIT_DEVICE_DRIVERS, + RTEMS_SYSINIT_ORDER_FIRST); + static char buffer[512]; static const T_action actions[] = { T_report_hash_sha256, - test_action + test_action, + T_check_file_descriptors, + T_check_rtems_barriers, + T_check_rtems_extensions, + T_check_rtems_message_queues, + T_check_rtems_partitions, + T_check_rtems_periods, + T_check_rtems_regions, + T_check_rtems_semaphores, + T_check_rtems_tasks, + T_check_rtems_timers, + T_check_posix_keys }; static const T_config config = { @@ -180,9 +216,21 @@ Init(rtems_task_argument arg) rtems_test_exit(0); } -#define CONFIGURE_APPLICATION_DOES_NOT_NEED_CLOCK_DRIVER +#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER + +#define CONFIGURE_LIBIO_MAXIMUM_FILE_DESCRIPTORS 4 + +#define CONFIGURE_MAXIMUM_BARRIERS 1 +#define CONFIGURE_MAXIMUM_MESSAGE_QUEUES 1 +#define CONFIGURE_MAXIMUM_PARTITIONS 1 +#define CONFIGURE_MAXIMUM_PERIODS 1 +#define CONFIGURE_MAXIMUM_REGIONS 1 +#define CONFIGURE_MAXIMUM_SEMAPHORES 1 +#define CONFIGURE_MAXIMUM_TASKS 2 +#define CONFIGURE_MAXIMUM_TIMERS 1 +#define CONFIGURE_MAXIMUM_USER_EXTENSIONS 1 -#define CONFIGURE_MAXIMUM_TASKS 1 +#define CONFIGURE_MAXIMUM_POSIX_KEYS 1 #define CONFIGURE_RTEMS_INIT_TASKS_TABLE diff --git a/testsuites/libtests/ttest01/test-assert.c b/testsuites/libtests/ttest01/test-assert.c new file mode 100644 index 0000000000..a819b41716 --- /dev/null +++ b/testsuites/libtests/ttest01/test-assert.c @@ -0,0 +1,95 @@ +#include + +T_TEST_CASE(assert) +{ + T_assert_true(true, "nix"); + T_assert_true(false, "test fails and we stop the test case"); + T_log(T_QUIET, "not reached"); +} + +static int counter; + +static void +setup(void *ctx) +{ + int *c; + + T_log(T_QUIET, "setup"); + T_eq_ptr(ctx, &counter); + c = ctx; + *c = 0; +} + +static void +stop(void *ctx) +{ + int *c; + + T_log(T_QUIET, "stop"); + T_eq_ptr(ctx, &counter); + c = ctx; + ++(*c); +} + +static void +teardown(void *ctx) +{ + int *c; + + T_log(T_QUIET, "teardown"); + T_eq_ptr(ctx, &counter); + c = ctx; + T_eq_int(*c, 1); +} + +static const T_fixture fixture = { + .setup = setup, + .stop = stop, + .teardown = teardown, + .initial_context = &counter +}; + +T_TEST_CASE_FIXTURE(assert2, &fixture) +{ + T_assert_true(true, "nix"); + T_assert_true(false, "test fails and we stop the test case"); + T_log(T_QUIET, "not reached"); +} + +/* + * The license is at the end of the file to be able to use the test code and + * output in examples in the documentation. This is also the reason for the + * dual licensing. The license for RTEMS documentation is CC-BY-SA-4.0. + */ + +/* + * SPDX-License-Identifier: BSD-2-Clause OR CC-BY-SA-4.0 + * + * Copyright (C) 2018, 2019 embedded brains GmbH + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * ALTERNATIVELY, this software may be distributed under the terms of the + * Creative Commons Attribution-ShareAlike 4.0 International Public License as + * published by Creative Commons, PO Box 1866, Mountain View, CA 94042 + * (https://creativecommons.org/licenses/by-sa/4.0/legalcode). + */ diff --git a/testsuites/libtests/ttest01/test-checks.c b/testsuites/libtests/ttest01/test-checks.c new file mode 100644 index 0000000000..f905860dc7 --- /dev/null +++ b/testsuites/libtests/ttest01/test-checks.c @@ -0,0 +1,2919 @@ +#include + +#include + +T_TEST_CASE(step_assert_true) +{ + T_plan(2); + T_step_assert_true(0, true, "nix"); + T_step_assert_true(1, false, "a"); +} + +T_TEST_CASE(check_true) +{ + T_true(true, "nix"); + T_true(false, "a"); + T_quiet_true(true, "nix"); + T_quiet_true(false, "ab %i", 0); + T_step_true(2, true, "nix"); + T_step_true(3, false, "abc %i", 0, 1); + T_assert_true(true, "nix"); + T_assert_true(false, "abcd %i %i %i", 0, 1, 2); +} + +T_TEST_CASE(step_assert_false) +{ + T_plan(2); + T_step_assert_false(0, false, "nix"); + T_step_assert_false(1, true, "a"); +} + +T_TEST_CASE(check_false) +{ + T_false(false, "nix"); + T_false(true, "a"); + T_quiet_false(false, "nix"); + T_quiet_false(true, "ab %i", 0); + T_step_false(2, false, "nix"); + T_step_false(3, true, "abc %i", 0, 1); + T_assert_false(false, "nix"); + T_assert_false(true, "abcd %i %i %i", 0, 1, 2); +} + +T_TEST_CASE(step_assert_eq) +{ + T_plan(2); + T_step_assert_eq(0, 0, 0, "nix"); + T_step_assert_eq(1, 1, 2, "1 == 2"); +} + +T_TEST_CASE(check_eq) +{ + T_eq(0, 0, "nix"); + T_eq(1, 2, "1 == 2"); + T_quiet_eq(3, 3, "nix"); + T_quiet_eq(4, 5, "4 == 5"); + T_step_eq(2, 6, 6, "nix"); + T_step_eq(3, 7, 8, "7 == 8"); + T_assert_eq(9, 9, "nix"); + T_assert_eq(10, 11, "10 == 11"); +} + +T_TEST_CASE(step_assert_ne) +{ + T_plan(2); + T_step_assert_ne(0, 0, 1, "nix"); + T_step_assert_ne(1, 2, 2, "2 != 2"); +} + +T_TEST_CASE(check_ne) +{ + T_ne(0, 1, "nix"); + T_ne(2, 2, "2 != 2"); + T_quiet_ne(3, 4, "nix"); + T_quiet_ne(5, 5, "5 != 5"); + T_step_ne(2, 6, 7, "nix"); + T_step_ne(3, 8, 8, "5 != 5"); + T_assert_ne(9, 10, "nix"); + T_assert_ne(11, 11, "11 != 11"); +} + +T_TEST_CASE(step_assert_eq_ptr) +{ + int a; + int b; + + T_plan(2); + T_step_eq_ptr(0, &a, &a); + T_step_eq_ptr(1, &a, &b); +} + +T_TEST_CASE(check_eq_ptr) +{ + int a; + int b; + + T_eq_ptr(&a, &a); + T_eq_ptr(&a, &b); + T_quiet_eq_ptr(&a, &a); + T_quiet_eq_ptr(&a, &b); + T_step_eq_ptr(2, &a, &a); + T_step_eq_ptr(3, &a, &b); + T_assert_eq_ptr(&a, &a); + T_assert_eq_ptr(&a, &b); +} + +T_TEST_CASE(step_assert_ne_ptr) +{ + int a; + int b; + + T_plan(2); + T_step_assert_ne_ptr(0, &a, &b); + T_step_assert_ne_ptr(1, &a, &a); +} + +T_TEST_CASE(check_ne_ptr) +{ + int a; + int b; + + T_ne_ptr(&a, &b); + T_ne_ptr(&a, &a); + T_quiet_ne_ptr(&a, &b); + T_quiet_ne_ptr(&a, &a); + T_step_ne_ptr(2, &a, &b); + T_step_ne_ptr(3, &a, &a); + T_assert_ne_ptr(&a, &b); + T_assert_ne_ptr(&a, &a); +} + +T_TEST_CASE(step_assert_null) +{ + int a; + + T_plan(2); + T_step_assert_null(0, NULL); + T_step_assert_null(1, &a); +} + +T_TEST_CASE(check_null) +{ + int a; + + T_null(NULL); + T_null(&a); + T_quiet_null(NULL); + T_quiet_null(&a); + T_step_null(2, NULL); + T_step_null(3, &a); + T_assert_null(NULL); + T_assert_null(&a); +} + +T_TEST_CASE(step_assert_not_null) +{ + int a; + + T_plan(2); + T_step_assert_not_null(0, &a); + T_step_assert_not_null(1, NULL); +} + +T_TEST_CASE(check_not_null) +{ + int a; + + T_not_null(&a); + T_not_null(NULL); + T_quiet_not_null(&a); + T_quiet_not_null(NULL); + T_step_not_null(2, &a); + T_step_not_null(3, NULL); + T_assert_not_null(&a); + T_assert_not_null(NULL); +} + +T_TEST_CASE(step_assert_eq_mem) +{ + static const int a = 0; + static const int b = 1; + + T_plan(2); + T_step_assert_eq_mem(0, &a, &a, sizeof(a)); + T_step_assert_eq_mem(1, &a, &b, sizeof(a)); +} + +T_TEST_CASE(check_eq_mem) +{ + static const int a = 0; + static const int b = 1; + + T_eq_mem(&a, &a, sizeof(a)); + T_eq_mem(&a, &b, sizeof(a)); + T_quiet_eq_mem(&a, &a, sizeof(a)); + T_quiet_eq_mem(&a, &b, sizeof(a)); + T_step_eq_mem(2, &a, &a, sizeof(a)); + T_step_eq_mem(3, &a, &b, sizeof(a)); + T_assert_eq_mem(&a, &a, sizeof(a)); + T_assert_eq_mem(&a, &b, sizeof(a)); +} + +T_TEST_CASE(step_assert_ne_mem) +{ + static const int a = 0; + static const int b = 1; + + T_plan(2); + T_step_assert_ne_mem(0, &a, &b, sizeof(a)); + T_step_assert_ne_mem(1, &a, &a, sizeof(a)); +} + +T_TEST_CASE(check_ne_mem) +{ + static const int a = 0; + static const int b = 1; + + T_ne_mem(&a, &b, sizeof(a)); + T_ne_mem(&a, &a, sizeof(a)); + T_quiet_ne_mem(&a, &b, sizeof(a)); + T_quiet_ne_mem(&a, &a, sizeof(a)); + T_step_ne_mem(2, &a, &b, sizeof(a)); + T_step_ne_mem(3, &a, &a, sizeof(a)); + T_assert_ne_mem(&a, &b, sizeof(a)); + T_assert_ne_mem(&a, &a, sizeof(a)); +} + +T_TEST_CASE(step_assert_eq_str) +{ + static const char a[] = "a"; + static const char b[] = "b"; + + T_plan(2); + T_step_assert_eq_str(0, a, a); + T_step_assert_eq_str(1, a, b); +} + +T_TEST_CASE(check_eq_str) +{ + static const char a[] = "a"; + static const char b[] = "b"; + + T_eq_str(a, a); + T_eq_str(a, b); + T_quiet_eq_str(a, a); + T_quiet_eq_str(a, b); + T_step_eq_str(2, a, a); + T_step_eq_str(3, a, b); + T_assert_eq_str(a, a); + T_assert_eq_str(a, b); +} + +T_TEST_CASE(step_assert_ne_str) +{ + static const char a[] = "a"; + static const char b[] = "b"; + + T_plan(2); + T_step_assert_ne_str(0, a, b); + T_step_assert_ne_str(1, a, a); +} + +T_TEST_CASE(check_ne_str) +{ + static const char a[] = "a"; + static const char b[] = "b"; + + T_ne_str(a, b); + T_ne_str(a, a); + T_quiet_ne_str(a, b); + T_quiet_ne_str(a, a); + T_step_ne_str(2, a, b); + T_step_ne_str(3, a, a); + T_assert_ne_str(a, b); + T_assert_ne_str(a, a); +} + +T_TEST_CASE(step_assert_eq_nstr) +{ + static const char a[] = "aaa"; + static const char b[] = "aaab"; + + T_plan(3); + T_step_assert_eq_nstr(0, a, a, 3); + T_step_assert_eq_nstr(1, a, b, 3); + T_step_assert_eq_nstr(2, a, b, 4); +} + +T_TEST_CASE(check_eq_nstr) +{ + static const char a[] = "aaa"; + static const char b[] = "aaab"; + + T_eq_nstr(a, a, 3); + T_eq_nstr(a, b, 3); + T_eq_nstr(a, b, 4); + T_quiet_eq_nstr(a, a, 3); + T_quiet_eq_nstr(a, b, 3); + T_quiet_eq_nstr(a, b, 4); + T_step_eq_nstr(3, a, a, 3); + T_step_eq_nstr(4, a, b, 3); + T_step_eq_nstr(5, a, b, 4); + T_assert_eq_nstr(a, a, 3); + T_assert_eq_nstr(a, b, 3); + T_assert_eq_nstr(a, b, 4); +} + +T_TEST_CASE(step_assert_ne_nstr) +{ + static const char a[] = "aaa"; + static const char b[] = "aaab"; + + T_plan(3); + T_step_assert_ne_nstr(0, a, b, 4); + T_step_assert_ne_nstr(1, a, a, 3); + T_step_assert_ne_nstr(2, a, b, 3); +} + +T_TEST_CASE(check_ne_nstr) +{ + static const char a[] = "aaa"; + static const char b[] = "aaab"; + + T_ne_nstr(a, b, 4); + T_ne_nstr(a, a, 3); + T_ne_nstr(a, b, 3); + T_quiet_ne_nstr(a, b, 4); + T_quiet_ne_nstr(a, a, 3); + T_quiet_ne_nstr(a, b, 3); + T_step_ne_nstr(3, a, b, 4); + T_step_ne_nstr(4, a, a, 3); + T_step_ne_nstr(5, a, b, 3); + T_assert_ne_nstr(a, b, 4); + T_assert_ne_nstr(a, a, 3); + T_assert_ne_nstr(a, b, 3); +} + +T_TEST_CASE(step_assert_eq_char) +{ + T_plan(2); + T_step_assert_eq_char(0, '1', '1'); + T_step_assert_eq_char(1, '2', '3'); +} + +T_TEST_CASE(check_eq_char) +{ + T_eq_char('1', '1'); + T_eq_char('2', '3'); + T_quiet_eq_char('4', '4'); + T_quiet_eq_char('5', '6'); + T_step_eq_char(2, '7', '7'); + T_step_eq_char(3, '8', '9'); + T_assert_eq_char('A', 'A'); + T_assert_eq_char('B', 'C'); +} + +T_TEST_CASE(step_assert_ne_char) +{ + T_plan(2); + T_step_assert_ne_char(0, '2', '3'); + T_step_assert_ne_char(1, '1', '1'); +} + +T_TEST_CASE(check_ne_char) +{ + T_ne_char('2', '3'); + T_ne_char('1', '1'); + T_quiet_ne_char('5', '6'); + T_quiet_ne_char('4', '4'); + T_step_ne_char(2, '8', '9'); + T_step_ne_char(3, '7', '7'); + T_assert_ne_char('B', 'C'); + T_assert_ne_char('A', 'A'); +} + +T_TEST_CASE(step_assert_eq_schar) +{ + T_plan(2); + T_step_assert_eq_schar(0, (signed char)1, (signed char)1); + T_step_assert_eq_schar(1, (signed char)2, (signed char)3); +} + +T_TEST_CASE(check_eq_schar) +{ + T_eq_schar((signed char)1, (signed char)1); + T_eq_schar((signed char)2, (signed char)3); + T_quiet_eq_schar((signed char)4, (signed char)4); + T_quiet_eq_schar((signed char)5, (signed char)6); + T_step_eq_schar(2, (signed char)7, (signed char)7); + T_step_eq_schar(3, (signed char)8, (signed char)9); + T_assert_eq_schar((signed char)10, (signed char)10); + T_assert_eq_schar((signed char)11, (signed char)12); +} + +T_TEST_CASE(step_assert_ne_schar) +{ + T_plan(2); + T_step_assert_ne_schar(0, (signed char)2, (signed char)3); + T_step_assert_ne_schar(1, (signed char)1, (signed char)1); +} + +T_TEST_CASE(check_ne_schar) +{ + T_ne_schar((signed char)2, (signed char)3); + T_ne_schar((signed char)1, (signed char)1); + T_quiet_ne_schar((signed char)5, (signed char)6); + T_quiet_ne_schar((signed char)4, (signed char)4); + T_step_ne_schar(2, (signed char)8, (signed char)9); + T_step_ne_schar(3, (signed char)7, (signed char)7); + T_assert_ne_schar((signed char)11, (signed char)12); + T_assert_ne_schar((signed char)10, (signed char)10); +} + +T_TEST_CASE(step_assert_ge_schar) +{ + T_plan(2); + T_step_assert_ge_schar(0, (signed char)1, (signed char)1); + T_step_assert_ge_schar(1, (signed char)2, (signed char)3); +} + +T_TEST_CASE(check_ge_schar) +{ + T_ge_schar((signed char)1, (signed char)1); + T_ge_schar((signed char)2, (signed char)3); + T_quiet_ge_schar((signed char)4, (signed char)4); + T_quiet_ge_schar((signed char)5, (signed char)6); + T_step_ge_schar(2, (signed char)7, (signed char)7); + T_step_ge_schar(3, (signed char)8, (signed char)9); + T_assert_ge_schar((signed char)10, (signed char)10); + T_assert_ge_schar((signed char)11, (signed char)12); +} + +T_TEST_CASE(step_assert_gt_schar) +{ + T_plan(2); + T_step_assert_gt_schar(0, (signed char)2, (signed char)1); + T_step_assert_gt_schar(1, (signed char)3, (signed char)3); +} + +T_TEST_CASE(check_gt_schar) +{ + T_gt_schar((signed char)2, (signed char)1); + T_gt_schar((signed char)3, (signed char)3); + T_quiet_gt_schar((signed char)5, (signed char)4); + T_quiet_gt_schar((signed char)6, (signed char)6); + T_step_gt_schar(2, (signed char)8, (signed char)7); + T_step_gt_schar(3, (signed char)9, (signed char)9); + T_assert_gt_schar((signed char)10, (signed char)11); + T_assert_gt_schar((signed char)12, (signed char)12); +} + +T_TEST_CASE(step_assert_le_schar) +{ + T_plan(2); + T_step_assert_le_schar(0, (signed char)1, (signed char)1); + T_step_assert_le_schar(1, (signed char)3, (signed char)2); +} + +T_TEST_CASE(check_le_schar) +{ + T_le_schar((signed char)1, (signed char)1); + T_le_schar((signed char)3, (signed char)2); + T_quiet_le_schar((signed char)4, (signed char)4); + T_quiet_le_schar((signed char)6, (signed char)5); + T_step_le_schar(2, (signed char)7, (signed char)7); + T_step_le_schar(3, (signed char)9, (signed char)8); + T_assert_le_schar((signed char)10, (signed char)10); + T_assert_le_schar((signed char)12, (signed char)11); +} + +T_TEST_CASE(step_assert_lt_schar) +{ + T_plan(2); + T_step_assert_lt_schar(0, (signed char)1, (signed char)2); + T_step_assert_lt_schar(1, (signed char)3, (signed char)3); +} + +T_TEST_CASE(check_lt_schar) +{ + T_lt_schar((signed char)1, (signed char)2); + T_lt_schar((signed char)3, (signed char)3); + T_quiet_lt_schar((signed char)4, (signed char)5); + T_quiet_lt_schar((signed char)6, (signed char)6); + T_step_lt_schar(2, (signed char)7, (signed char)8); + T_step_lt_schar(3, (signed char)9, (signed char)9); + T_assert_lt_schar((signed char)10, (signed char)11); + T_assert_lt_schar((signed char)12, (signed char)12); +} + +T_TEST_CASE(step_assert_eq_uchar) +{ + T_plan(2); + T_step_assert_eq_uchar(0, (unsigned char)1, (unsigned char)1); + T_step_assert_eq_uchar(1, (unsigned char)2, (unsigned char)3); +} + +T_TEST_CASE(check_eq_uchar) +{ + T_eq_uchar((unsigned char)1, (unsigned char)1); + T_eq_uchar((unsigned char)2, (unsigned char)3); + T_quiet_eq_uchar((unsigned char)4, (unsigned char)4); + T_quiet_eq_uchar((unsigned char)5, (unsigned char)6); + T_step_eq_uchar(2, (unsigned char)7, (unsigned char)7); + T_step_eq_uchar(3, (unsigned char)8, (unsigned char)9); + T_assert_eq_uchar((unsigned char)10, (unsigned char)10); + T_assert_eq_uchar((unsigned char)11, (unsigned char)12); +} + +T_TEST_CASE(step_assert_ne_uchar) +{ + T_plan(2); + T_step_assert_ne_uchar(0, (unsigned char)2, (unsigned char)3); + T_step_assert_ne_uchar(1, (unsigned char)1, (unsigned char)1); +} + +T_TEST_CASE(check_ne_uchar) +{ + T_ne_uchar((unsigned char)2, (unsigned char)3); + T_ne_uchar((unsigned char)1, (unsigned char)1); + T_quiet_ne_uchar((unsigned char)5, (unsigned char)6); + T_quiet_ne_uchar((unsigned char)4, (unsigned char)4); + T_step_ne_uchar(2, (unsigned char)8, (unsigned char)9); + T_step_ne_uchar(3, (unsigned char)7, (unsigned char)7); + T_assert_ne_uchar((unsigned char)11, (unsigned char)12); + T_assert_ne_uchar((unsigned char)10, (unsigned char)10); +} + +T_TEST_CASE(step_assert_ge_uchar) +{ + T_plan(2); + T_step_assert_ge_uchar(0, (unsigned char)1, (unsigned char)1); + T_step_assert_ge_uchar(1, (unsigned char)2, (unsigned char)3); +} + +T_TEST_CASE(check_ge_uchar) +{ + T_ge_uchar((unsigned char)1, (unsigned char)1); + T_ge_uchar((unsigned char)2, (unsigned char)3); + T_quiet_ge_uchar((unsigned char)4, (unsigned char)4); + T_quiet_ge_uchar((unsigned char)5, (unsigned char)6); + T_step_ge_uchar(2, (unsigned char)7, (unsigned char)7); + T_step_ge_uchar(3, (unsigned char)8, (unsigned char)9); + T_assert_ge_uchar((unsigned char)10, (unsigned char)10); + T_assert_ge_uchar((unsigned char)11, (unsigned char)12); +} + +T_TEST_CASE(step_assert_gt_uchar) +{ + T_plan(2); + T_step_assert_gt_uchar(0, (unsigned char)2, (unsigned char)1); + T_step_assert_gt_uchar(1, (unsigned char)3, (unsigned char)3); +} + +T_TEST_CASE(check_gt_uchar) +{ + T_gt_uchar((unsigned char)2, (unsigned char)1); + T_gt_uchar((unsigned char)3, (unsigned char)3); + T_quiet_gt_uchar((unsigned char)5, (unsigned char)4); + T_quiet_gt_uchar((unsigned char)6, (unsigned char)6); + T_step_gt_uchar(2, (unsigned char)8, (unsigned char)7); + T_step_gt_uchar(3, (unsigned char)9, (unsigned char)9); + T_assert_gt_uchar((unsigned char)10, (unsigned char)11); + T_assert_gt_uchar((unsigned char)12, (unsigned char)12); +} + +T_TEST_CASE(step_assert_le_uchar) +{ + T_plan(2); + T_step_assert_le_uchar(0, (unsigned char)1, (unsigned char)1); + T_step_assert_le_uchar(1, (unsigned char)3, (unsigned char)2); +} + +T_TEST_CASE(check_le_uchar) +{ + T_le_uchar((unsigned char)1, (unsigned char)1); + T_le_uchar((unsigned char)3, (unsigned char)2); + T_quiet_le_uchar((unsigned char)4, (unsigned char)4); + T_quiet_le_uchar((unsigned char)6, (unsigned char)5); + T_step_le_uchar(2, (unsigned char)7, (unsigned char)7); + T_step_le_uchar(3, (unsigned char)9, (unsigned char)8); + T_assert_le_uchar((unsigned char)10, (unsigned char)10); + T_assert_le_uchar((unsigned char)12, (unsigned char)11); +} + +T_TEST_CASE(step_assert_lt_uchar) +{ + T_plan(2); + T_step_assert_lt_uchar(0, (unsigned char)1, (unsigned char)2); + T_step_assert_lt_uchar(1, (unsigned char)3, (unsigned char)3); +} + +T_TEST_CASE(check_lt_uchar) +{ + T_lt_uchar((unsigned char)1, (unsigned char)2); + T_lt_uchar((unsigned char)3, (unsigned char)3); + T_quiet_lt_uchar((unsigned char)4, (unsigned char)5); + T_quiet_lt_uchar((unsigned char)6, (unsigned char)6); + T_step_lt_uchar(2, (unsigned char)7, (unsigned char)8); + T_step_lt_uchar(3, (unsigned char)9, (unsigned char)9); + T_assert_lt_uchar((unsigned char)10, (unsigned char)11); + T_assert_lt_uchar((unsigned char)12, (unsigned char)12); +} + +T_TEST_CASE(step_assert_eq_short) +{ + T_plan(2); + T_step_assert_eq_short(0, (short)1, (short)1); + T_step_assert_eq_short(1, (short)2, (short)3); +} + +T_TEST_CASE(check_eq_short) +{ + T_eq_short((short)1, (short)1); + T_eq_short((short)2, (short)3); + T_quiet_eq_short((short)4, (short)4); + T_quiet_eq_short((short)5, (short)6); + T_step_eq_short(2, (short)7, (short)7); + T_step_eq_short(3, (short)8, (short)9); + T_assert_eq_short((short)10, (short)10); + T_assert_eq_short((short)11, (short)12); +} + +T_TEST_CASE(step_assert_ne_short) +{ + T_plan(2); + T_step_assert_ne_short(0, (short)2, (short)3); + T_step_assert_ne_short(1, (short)1, (short)1); +} + +T_TEST_CASE(check_ne_short) +{ + T_ne_short((short)2, (short)3); + T_ne_short((short)1, (short)1); + T_quiet_ne_short((short)5, (short)6); + T_quiet_ne_short((short)4, (short)4); + T_step_ne_short(2, (short)8, (short)9); + T_step_ne_short(3, (short)7, (short)7); + T_assert_ne_short((short)11, (short)12); + T_assert_ne_short((short)10, (short)10); +} + +T_TEST_CASE(step_assert_ge_short) +{ + T_plan(2); + T_step_assert_ge_short(0, (short)1, (short)1); + T_step_assert_ge_short(1, (short)2, (short)3); +} + +T_TEST_CASE(check_ge_short) +{ + T_ge_short((short)1, (short)1); + T_ge_short((short)2, (short)3); + T_quiet_ge_short((short)4, (short)4); + T_quiet_ge_short((short)5, (short)6); + T_step_ge_short(2, (short)7, (short)7); + T_step_ge_short(3, (short)8, (short)9); + T_assert_ge_short((short)10, (short)10); + T_assert_ge_short((short)11, (short)12); +} + +T_TEST_CASE(step_assert_gt_short) +{ + T_plan(2); + T_step_assert_gt_short(0, (short)2, (short)1); + T_step_assert_gt_short(1, (short)3, (short)3); +} + +T_TEST_CASE(check_gt_short) +{ + T_gt_short((short)2, (short)1); + T_gt_short((short)3, (short)3); + T_quiet_gt_short((short)5, (short)4); + T_quiet_gt_short((short)6, (short)6); + T_step_gt_short(2, (short)8, (short)7); + T_step_gt_short(3, (short)9, (short)9); + T_assert_gt_short((short)10, (short)11); + T_assert_gt_short((short)12, (short)12); +} + +T_TEST_CASE(step_assert_le_short) +{ + T_plan(2); + T_step_assert_le_short(0, (short)1, (short)1); + T_step_assert_le_short(1, (short)3, (short)2); +} + +T_TEST_CASE(check_le_short) +{ + T_le_short((short)1, (short)1); + T_le_short((short)3, (short)2); + T_quiet_le_short((short)4, (short)4); + T_quiet_le_short((short)6, (short)5); + T_step_le_short(2, (short)7, (short)7); + T_step_le_short(3, (short)9, (short)8); + T_assert_le_short((short)10, (short)10); + T_assert_le_short((short)12, (short)11); +} + +T_TEST_CASE(step_assert_lt_short) +{ + T_plan(2); + T_step_assert_lt_short(0, (short)1, (short)2); + T_step_assert_lt_short(1, (short)3, (short)3); +} + +T_TEST_CASE(check_lt_short) +{ + T_lt_short((short)1, (short)2); + T_lt_short((short)3, (short)3); + T_quiet_lt_short((short)4, (short)5); + T_quiet_lt_short((short)6, (short)6); + T_step_lt_short(2, (short)7, (short)8); + T_step_lt_short(3, (short)9, (short)9); + T_assert_lt_short((short)10, (short)11); + T_assert_lt_short((short)12, (short)12); +} + +T_TEST_CASE(step_assert_eq_ushort) +{ + T_plan(2); + T_step_assert_eq_ushort(0, (unsigned short)1, (unsigned short)1); + T_step_assert_eq_ushort(1, (unsigned short)2, (unsigned short)3); +} + +T_TEST_CASE(check_eq_ushort) +{ + T_eq_ushort((unsigned short)1, (unsigned short)1); + T_eq_ushort((unsigned short)2, (unsigned short)3); + T_quiet_eq_ushort((unsigned short)4, (unsigned short)4); + T_quiet_eq_ushort((unsigned short)5, (unsigned short)6); + T_step_eq_ushort(2, (unsigned short)7, (unsigned short)7); + T_step_eq_ushort(3, (unsigned short)8, (unsigned short)9); + T_assert_eq_ushort((unsigned short)10, (unsigned short)10); + T_assert_eq_ushort((unsigned short)11, (unsigned short)12); +} + +T_TEST_CASE(step_assert_ne_ushort) +{ + T_plan(2); + T_step_assert_ne_ushort(0, (unsigned short)2, (unsigned short)3); + T_step_assert_ne_ushort(1, (unsigned short)1, (unsigned short)1); +} + +T_TEST_CASE(check_ne_ushort) +{ + T_ne_ushort((unsigned short)2, (unsigned short)3); + T_ne_ushort((unsigned short)1, (unsigned short)1); + T_quiet_ne_ushort((unsigned short)5, (unsigned short)6); + T_quiet_ne_ushort((unsigned short)4, (unsigned short)4); + T_step_ne_ushort(2, (unsigned short)8, (unsigned short)9); + T_step_ne_ushort(3, (unsigned short)7, (unsigned short)7); + T_assert_ne_ushort((unsigned short)11, (unsigned short)12); + T_assert_ne_ushort((unsigned short)10, (unsigned short)10); +} + +T_TEST_CASE(step_assert_ge_ushort) +{ + T_plan(2); + T_step_assert_ge_ushort(0, (unsigned short)1, (unsigned short)1); + T_step_assert_ge_ushort(1, (unsigned short)2, (unsigned short)3); +} + +T_TEST_CASE(check_ge_ushort) +{ + T_ge_ushort((unsigned short)1, (unsigned short)1); + T_ge_ushort((unsigned short)2, (unsigned short)3); + T_quiet_ge_ushort((unsigned short)4, (unsigned short)4); + T_quiet_ge_ushort((unsigned short)5, (unsigned short)6); + T_step_ge_ushort(2, (unsigned short)7, (unsigned short)7); + T_step_ge_ushort(3, (unsigned short)8, (unsigned short)9); + T_assert_ge_ushort((unsigned short)10, (unsigned short)10); + T_assert_ge_ushort((unsigned short)11, (unsigned short)12); +} + +T_TEST_CASE(step_assert_gt_ushort) +{ + T_plan(2); + T_step_assert_gt_ushort(0, (unsigned short)2, (unsigned short)1); + T_step_assert_gt_ushort(1, (unsigned short)3, (unsigned short)3); +} + +T_TEST_CASE(check_gt_ushort) +{ + T_gt_ushort((unsigned short)2, (unsigned short)1); + T_gt_ushort((unsigned short)3, (unsigned short)3); + T_quiet_gt_ushort((unsigned short)5, (unsigned short)4); + T_quiet_gt_ushort((unsigned short)6, (unsigned short)6); + T_step_gt_ushort(2, (unsigned short)8, (unsigned short)7); + T_step_gt_ushort(3, (unsigned short)9, (unsigned short)9); + T_assert_gt_ushort((unsigned short)10, (unsigned short)11); + T_assert_gt_ushort((unsigned short)12, (unsigned short)12); +} + +T_TEST_CASE(step_assert_le_ushort) +{ + T_plan(2); + T_step_assert_le_ushort(0, (unsigned short)1, (unsigned short)1); + T_step_assert_le_ushort(1, (unsigned short)3, (unsigned short)2); +} + +T_TEST_CASE(check_le_ushort) +{ + T_le_ushort((unsigned short)1, (unsigned short)1); + T_le_ushort((unsigned short)3, (unsigned short)2); + T_quiet_le_ushort((unsigned short)4, (unsigned short)4); + T_quiet_le_ushort((unsigned short)6, (unsigned short)5); + T_step_le_ushort(2, (unsigned short)7, (unsigned short)7); + T_step_le_ushort(3, (unsigned short)9, (unsigned short)8); + T_assert_le_ushort((unsigned short)10, (unsigned short)10); + T_assert_le_ushort((unsigned short)12, (unsigned short)11); +} + +T_TEST_CASE(step_assert_lt_ushort) +{ + T_plan(2); + T_step_assert_lt_ushort(0, (unsigned short)1, (unsigned short)2); + T_step_assert_lt_ushort(1, (unsigned short)3, (unsigned short)3); +} + +T_TEST_CASE(check_lt_ushort) +{ + T_lt_ushort((unsigned short)1, (unsigned short)2); + T_lt_ushort((unsigned short)3, (unsigned short)3); + T_quiet_lt_ushort((unsigned short)4, (unsigned short)5); + T_quiet_lt_ushort((unsigned short)6, (unsigned short)6); + T_step_lt_ushort(2, (unsigned short)7, (unsigned short)8); + T_step_lt_ushort(3, (unsigned short)9, (unsigned short)9); + T_assert_lt_ushort((unsigned short)10, (unsigned short)11); + T_assert_lt_ushort((unsigned short)12, (unsigned short)12); +} + +T_TEST_CASE(step_assert_eq_int) +{ + T_plan(2); + T_step_assert_eq_int(0, 1, 1); + T_step_assert_eq_int(1, 2, 3); +} + +T_TEST_CASE(check_eq_int) +{ + T_eq_int(1, 1); + T_eq_int(2, 3); + T_quiet_eq_int(4, 4); + T_quiet_eq_int(5, 6); + T_step_eq_int(2, 7, 7); + T_step_eq_int(3, 8, 9); + T_assert_eq_int(10, 10); + T_assert_eq_int(11, 12); +} + +T_TEST_CASE(step_assert_ne_int) +{ + T_plan(2); + T_step_assert_ne_int(0, 2, 3); + T_step_assert_ne_int(1, 1, 1); +} + +T_TEST_CASE(check_ne_int) +{ + T_ne_int(2, 3); + T_ne_int(1, 1); + T_quiet_ne_int(5, 6); + T_quiet_ne_int(4, 4); + T_step_ne_int(2, 8, 9); + T_step_ne_int(3, 7, 7); + T_assert_ne_int(11, 12); + T_assert_ne_int(10, 10); +} + +T_TEST_CASE(step_assert_ge_int) +{ + T_plan(2); + T_step_assert_ge_int(0, 1, 1); + T_step_assert_ge_int(1, 2, 3); +} + +T_TEST_CASE(check_ge_int) +{ + T_ge_int(1, 1); + T_ge_int(2, 3); + T_quiet_ge_int(4, 4); + T_quiet_ge_int(5, 6); + T_step_ge_int(2, 7, 7); + T_step_ge_int(3, 8, 9); + T_assert_ge_int(10, 10); + T_assert_ge_int(11, 12); +} + +T_TEST_CASE(step_assert_gt_int) +{ + T_plan(2); + T_step_assert_gt_int(0, 2, 1); + T_step_assert_gt_int(1, 3, 3); +} + +T_TEST_CASE(check_gt_int) +{ + T_gt_int(2, 1); + T_gt_int(3, 3); + T_quiet_gt_int(5, 4); + T_quiet_gt_int(6, 6); + T_step_gt_int(2, 8, 7); + T_step_gt_int(3, 9, 9); + T_assert_gt_int(10, 11); + T_assert_gt_int(12, 12); +} + +T_TEST_CASE(step_assert_le_int) +{ + T_plan(2); + T_step_assert_le_int(0, 1, 1); + T_step_assert_le_int(1, 3, 2); +} + +T_TEST_CASE(check_le_int) +{ + T_le_int(1, 1); + T_le_int(3, 2); + T_quiet_le_int(4, 4); + T_quiet_le_int(6, 5); + T_step_le_int(2, 7, 7); + T_step_le_int(3, 9, 8); + T_assert_le_int(10, 10); + T_assert_le_int(12, 11); +} + +T_TEST_CASE(step_assert_lt_int) +{ + T_plan(2); + T_step_assert_lt_int(0, 1, 2); + T_step_assert_lt_int(1, 3, 3); +} + +T_TEST_CASE(check_lt_int) +{ + T_lt_int(1, 2); + T_lt_int(3, 3); + T_quiet_lt_int(4, 5); + T_quiet_lt_int(6, 6); + T_step_lt_int(2, 7, 8); + T_step_lt_int(3, 9, 9); + T_assert_lt_int(10, 11); + T_assert_lt_int(12, 12); +} + +T_TEST_CASE(step_assert_eq_uint) +{ + T_plan(2); + T_step_assert_eq_uint(0, 1U, 1U); + T_step_assert_eq_uint(1, 2U, 3U); +} + +T_TEST_CASE(check_eq_uint) +{ + T_eq_uint(1U, 1U); + T_eq_uint(2U, 3U); + T_quiet_eq_uint(4U, 4U); + T_quiet_eq_uint(5U, 6U); + T_step_eq_uint(2, 7U, 7U); + T_step_eq_uint(3, 8U, 9U); + T_assert_eq_uint(10U, 10U); + T_assert_eq_uint(11U, 12U); +} + +T_TEST_CASE(step_assert_ne_uint) +{ + T_plan(2); + T_step_assert_ne_uint(0, 2U, 3U); + T_step_assert_ne_uint(1, 1U, 1U); +} + +T_TEST_CASE(check_ne_uint) +{ + T_ne_uint(2U, 3U); + T_ne_uint(1U, 1U); + T_quiet_ne_uint(5U, 6U); + T_quiet_ne_uint(4U, 4U); + T_step_ne_uint(2, 8U, 9U); + T_step_ne_uint(3, 7U, 7U); + T_assert_ne_uint(11U, 12U); + T_assert_ne_uint(10U, 10U); +} + +T_TEST_CASE(step_assert_ge_uint) +{ + T_plan(2); + T_step_assert_ge_uint(0, 1U, 1U); + T_step_assert_ge_uint(1, 2U, 3U); +} + +T_TEST_CASE(check_ge_uint) +{ + T_ge_uint(1U, 1U); + T_ge_uint(2U, 3U); + T_quiet_ge_uint(4U, 4U); + T_quiet_ge_uint(5U, 6U); + T_step_ge_uint(2, 7U, 7U); + T_step_ge_uint(3, 8U, 9U); + T_assert_ge_uint(10U, 10U); + T_assert_ge_uint(11U, 12U); +} + +T_TEST_CASE(step_assert_gt_uint) +{ + T_plan(2); + T_step_assert_gt_uint(0, 2U, 1U); + T_step_assert_gt_uint(1, 3U, 3U); +} + +T_TEST_CASE(check_gt_uint) +{ + T_gt_uint(2U, 1U); + T_gt_uint(3U, 3U); + T_quiet_gt_uint(5U, 4U); + T_quiet_gt_uint(6U, 6U); + T_step_gt_uint(2, 8U, 7U); + T_step_gt_uint(3, 9U, 9U); + T_assert_gt_uint(10U, 11U); + T_assert_gt_uint(12U, 12U); +} + +T_TEST_CASE(step_assert_le_uint) +{ + T_plan(2); + T_step_assert_le_uint(0, 1U, 1U); + T_step_assert_le_uint(1, 3U, 2U); +} + +T_TEST_CASE(check_le_uint) +{ + T_le_uint(1U, 1U); + T_le_uint(3U, 2U); + T_quiet_le_uint(4U, 4U); + T_quiet_le_uint(6U, 5U); + T_step_le_uint(2, 7U, 7U); + T_step_le_uint(3, 9U, 8U); + T_assert_le_uint(10U, 10U); + T_assert_le_uint(12U, 11U); +} + +T_TEST_CASE(step_assert_lt_uint) +{ + T_plan(2); + T_step_assert_lt_uint(0, 1U, 2U); + T_step_assert_lt_uint(1, 3U, 3U); +} + +T_TEST_CASE(check_lt_uint) +{ + T_lt_uint(1U, 2U); + T_lt_uint(3U, 3U); + T_quiet_lt_uint(4U, 5U); + T_quiet_lt_uint(6U, 6U); + T_step_lt_uint(2, 7U, 8U); + T_step_lt_uint(3, 9U, 9U); + T_assert_lt_uint(10U, 11U); + T_assert_lt_uint(12U, 12U); +} + +T_TEST_CASE(step_assert_eq_long) +{ + T_plan(2); + T_step_assert_eq_long(0, 1L, 1L); + T_step_assert_eq_long(1, 2L, 3L); +} + +T_TEST_CASE(check_eq_long) +{ + T_eq_long(1L, 1L); + T_eq_long(2L, 3L); + T_quiet_eq_long(4L, 4L); + T_quiet_eq_long(5L, 6L); + T_step_eq_long(2, 7L, 7L); + T_step_eq_long(3, 8L, 9L); + T_assert_eq_long(10L, 10L); + T_assert_eq_long(11L, 12L); +} + +T_TEST_CASE(step_assert_ne_long) +{ + T_plan(2); + T_step_assert_ne_long(0, 2L, 3L); + T_step_assert_ne_long(1, 1L, 1L); +} + +T_TEST_CASE(check_ne_long) +{ + T_ne_long(2L, 3L); + T_ne_long(1L, 1L); + T_quiet_ne_long(5L, 6L); + T_quiet_ne_long(4L, 4L); + T_step_ne_long(2, 8L, 9L); + T_step_ne_long(3, 7L, 7L); + T_assert_ne_long(11L, 12L); + T_assert_ne_long(10L, 10L); +} + +T_TEST_CASE(step_assert_ge_long) +{ + T_plan(2); + T_step_assert_ge_long(0, 1L, 1L); + T_step_assert_ge_long(1, 2L, 3L); +} + +T_TEST_CASE(check_ge_long) +{ + T_ge_long(1L, 1L); + T_ge_long(2L, 3L); + T_quiet_ge_long(4L, 4L); + T_quiet_ge_long(5L, 6L); + T_step_ge_long(2, 7L, 7L); + T_step_ge_long(3, 8L, 9L); + T_assert_ge_long(10L, 10L); + T_assert_ge_long(11L, 12L); +} + +T_TEST_CASE(step_assert_gt_long) +{ + T_plan(2); + T_step_assert_gt_long(0, 2L, 1L); + T_step_assert_gt_long(1, 3L, 3L); +} + +T_TEST_CASE(check_gt_long) +{ + T_gt_long(2L, 1L); + T_gt_long(3L, 3L); + T_quiet_gt_long(5L, 4L); + T_quiet_gt_long(6L, 6L); + T_step_gt_long(2, 8L, 7L); + T_step_gt_long(3, 9L, 9L); + T_assert_gt_long(10L, 11L); + T_assert_gt_long(12L, 12L); +} + +T_TEST_CASE(step_assert_le_long) +{ + T_plan(2); + T_step_assert_le_long(0, 1L, 1L); + T_step_assert_le_long(1, 3L, 2L); +} + +T_TEST_CASE(check_le_long) +{ + T_le_long(1L, 1L); + T_le_long(3L, 2L); + T_quiet_le_long(4L, 4L); + T_quiet_le_long(6L, 5L); + T_step_le_long(2, 7L, 7L); + T_step_le_long(3, 9L, 8L); + T_assert_le_long(10L, 10L); + T_assert_le_long(12L, 11L); +} + +T_TEST_CASE(step_assert_lt_long) +{ + T_plan(2); + T_step_assert_lt_long(0, 1L, 2L); + T_step_assert_lt_long(1, 3L, 3L); +} + +T_TEST_CASE(check_lt_long) +{ + T_lt_long(1L, 2L); + T_lt_long(3L, 3L); + T_quiet_lt_long(4L, 5L); + T_quiet_lt_long(6L, 6L); + T_step_lt_long(2, 7L, 8L); + T_step_lt_long(3, 9L, 9L); + T_assert_lt_long(10L, 11L); + T_assert_lt_long(12L, 12L); +} + +T_TEST_CASE(step_assert_eq_ulong) +{ + T_plan(2); + T_step_assert_eq_ulong(0, 1UL, 1UL); + T_step_assert_eq_ulong(1, 2UL, 3UL); +} + +T_TEST_CASE(check_eq_ulong) +{ + T_eq_ulong(1UL, 1UL); + T_eq_ulong(2UL, 3UL); + T_quiet_eq_ulong(4UL, 4UL); + T_quiet_eq_ulong(5UL, 6UL); + T_step_eq_ulong(2, 7UL, 7UL); + T_step_eq_ulong(3, 8UL, 9UL); + T_assert_eq_ulong(10UL, 10UL); + T_assert_eq_ulong(11UL, 12UL); +} + +T_TEST_CASE(step_assert_ne_ulong) +{ + T_plan(2); + T_step_assert_ne_ulong(0, 2UL, 3UL); + T_step_assert_ne_ulong(1, 1UL, 1UL); +} + +T_TEST_CASE(check_ne_ulong) +{ + T_ne_ulong(2UL, 3UL); + T_ne_ulong(1UL, 1UL); + T_quiet_ne_ulong(5UL, 6UL); + T_quiet_ne_ulong(4UL, 4UL); + T_step_ne_ulong(2, 8UL, 9UL); + T_step_ne_ulong(3, 7UL, 7UL); + T_assert_ne_ulong(11UL, 12UL); + T_assert_ne_ulong(10UL, 10UL); +} + +T_TEST_CASE(step_assert_ge_ulong) +{ + T_plan(2); + T_step_assert_ge_ulong(0, 1UL, 1UL); + T_step_assert_ge_ulong(1, 2UL, 3UL); +} + +T_TEST_CASE(check_ge_ulong) +{ + T_ge_ulong(1UL, 1UL); + T_ge_ulong(2UL, 3UL); + T_quiet_ge_ulong(4UL, 4UL); + T_quiet_ge_ulong(5UL, 6UL); + T_step_ge_ulong(2, 7UL, 7UL); + T_step_ge_ulong(3, 8UL, 9UL); + T_assert_ge_ulong(10UL, 10UL); + T_assert_ge_ulong(11UL, 12UL); +} + +T_TEST_CASE(step_assert_gt_ulong) +{ + T_plan(2); + T_step_assert_gt_ulong(0, 2UL, 1UL); + T_step_assert_gt_ulong(1, 3UL, 3UL); +} + +T_TEST_CASE(check_gt_ulong) +{ + T_gt_ulong(2UL, 1UL); + T_gt_ulong(3UL, 3UL); + T_quiet_gt_ulong(5UL, 4UL); + T_quiet_gt_ulong(6UL, 6UL); + T_step_gt_ulong(2, 8UL, 7UL); + T_step_gt_ulong(3, 9UL, 9UL); + T_assert_gt_ulong(10UL, 11UL); + T_assert_gt_ulong(12UL, 12UL); +} + +T_TEST_CASE(step_assert_le_ulong) +{ + T_plan(2); + T_step_assert_le_ulong(0, 1UL, 1UL); + T_step_assert_le_ulong(1, 3UL, 2UL); +} + +T_TEST_CASE(check_le_ulong) +{ + T_le_ulong(1UL, 1UL); + T_le_ulong(3UL, 2UL); + T_quiet_le_ulong(4UL, 4UL); + T_quiet_le_ulong(6UL, 5UL); + T_step_le_ulong(2, 7UL, 7UL); + T_step_le_ulong(3, 9UL, 8UL); + T_assert_le_ulong(10UL, 10UL); + T_assert_le_ulong(12UL, 11UL); +} + +T_TEST_CASE(step_assert_lt_ulong) +{ + T_plan(2); + T_step_assert_lt_ulong(0, 1UL, 2UL); + T_step_assert_lt_ulong(1, 3UL, 3UL); +} + +T_TEST_CASE(check_lt_ulong) +{ + T_lt_ulong(1UL, 2UL); + T_lt_ulong(3UL, 3UL); + T_quiet_lt_ulong(4UL, 5UL); + T_quiet_lt_ulong(6UL, 6UL); + T_step_lt_ulong(2, 7UL, 8UL); + T_step_lt_ulong(3, 9UL, 9UL); + T_assert_lt_ulong(10UL, 11UL); + T_assert_lt_ulong(12UL, 12UL); +} + +T_TEST_CASE(step_assert_eq_ll) +{ + T_plan(2); + T_step_assert_eq_ll(0, 1LL, 1LL); + T_step_assert_eq_ll(1, 2LL, 3LL); +} + +T_TEST_CASE(check_eq_ll) +{ + T_eq_ll(1LL, 1LL); + T_eq_ll(2LL, 3LL); + T_quiet_eq_ll(4LL, 4LL); + T_quiet_eq_ll(5LL, 6LL); + T_step_eq_ll(2, 7LL, 7LL); + T_step_eq_ll(3, 8LL, 9LL); + T_assert_eq_ll(10LL, 10LL); + T_assert_eq_ll(11LL, 12LL); +} + +T_TEST_CASE(step_assert_ne_ll) +{ + T_plan(2); + T_step_assert_ne_ll(0, 2LL, 3LL); + T_step_assert_ne_ll(1, 1LL, 1LL); +} + +T_TEST_CASE(check_ne_ll) +{ + T_ne_ll(2LL, 3LL); + T_ne_ll(1LL, 1LL); + T_quiet_ne_ll(5LL, 6LL); + T_quiet_ne_ll(4LL, 4LL); + T_step_ne_ll(2, 8LL, 9LL); + T_step_ne_ll(3, 7LL, 7LL); + T_assert_ne_ll(11LL, 12LL); + T_assert_ne_ll(10LL, 10LL); +} + +T_TEST_CASE(step_assert_ge_ll) +{ + T_plan(2); + T_step_assert_ge_ll(0, 1LL, 1LL); + T_step_assert_ge_ll(1, 2LL, 3LL); +} + +T_TEST_CASE(check_ge_ll) +{ + T_ge_ll(1LL, 1LL); + T_ge_ll(2LL, 3LL); + T_quiet_ge_ll(4LL, 4LL); + T_quiet_ge_ll(5LL, 6LL); + T_step_ge_ll(2, 7LL, 7LL); + T_step_ge_ll(3, 8LL, 9LL); + T_assert_ge_ll(10LL, 10LL); + T_assert_ge_ll(11LL, 12LL); +} + +T_TEST_CASE(step_assert_gt_ll) +{ + T_plan(2); + T_step_assert_gt_ll(0, 2LL, 1LL); + T_step_assert_gt_ll(1, 3LL, 3LL); +} + +T_TEST_CASE(check_gt_ll) +{ + T_gt_ll(2LL, 1LL); + T_gt_ll(3LL, 3LL); + T_quiet_gt_ll(5LL, 4LL); + T_quiet_gt_ll(6LL, 6LL); + T_step_gt_ll(2, 8LL, 7LL); + T_step_gt_ll(3, 9LL, 9LL); + T_assert_gt_ll(10LL, 11LL); + T_assert_gt_ll(12LL, 12LL); +} + +T_TEST_CASE(step_assert_le_ll) +{ + T_plan(2); + T_step_assert_le_ll(0, 1LL, 1LL); + T_step_assert_le_ll(1, 3LL, 2LL); +} + +T_TEST_CASE(check_le_ll) +{ + T_le_ll(1LL, 1LL); + T_le_ll(3LL, 2LL); + T_quiet_le_ll(4LL, 4LL); + T_quiet_le_ll(6LL, 5LL); + T_step_le_ll(2, 7LL, 7LL); + T_step_le_ll(3, 9LL, 8LL); + T_assert_le_ll(10LL, 10LL); + T_assert_le_ll(12LL, 11LL); +} + +T_TEST_CASE(step_assert_lt_ll) +{ + T_plan(2); + T_step_assert_lt_ll(0, 1LL, 2LL); + T_step_assert_lt_ll(1, 3LL, 3LL); +} + +T_TEST_CASE(check_lt_ll) +{ + T_lt_ll(1LL, 2LL); + T_lt_ll(3LL, 3LL); + T_quiet_lt_ll(4LL, 5LL); + T_quiet_lt_ll(6LL, 6LL); + T_step_lt_ll(2, 7LL, 8LL); + T_step_lt_ll(3, 9LL, 9LL); + T_assert_lt_ll(10LL, 11LL); + T_assert_lt_ll(12LL, 12LL); +} + +T_TEST_CASE(step_assert_eq_ull) +{ + T_plan(2); + T_step_assert_eq_ull(0, 1ULL, 1ULL); + T_step_assert_eq_ull(1, 2ULL, 3ULL); +} + +T_TEST_CASE(check_eq_ull) +{ + T_eq_ull(1ULL, 1ULL); + T_eq_ull(2ULL, 3ULL); + T_quiet_eq_ull(4ULL, 4ULL); + T_quiet_eq_ull(5ULL, 6ULL); + T_step_eq_ull(2, 7ULL, 7ULL); + T_step_eq_ull(3, 8ULL, 9ULL); + T_assert_eq_ull(10ULL, 10ULL); + T_assert_eq_ull(11ULL, 12ULL); +} + +T_TEST_CASE(step_assert_ne_ull) +{ + T_plan(2); + T_step_assert_ne_ull(0, 2ULL, 3ULL); + T_step_assert_ne_ull(1, 1ULL, 1ULL); +} + +T_TEST_CASE(check_ne_ull) +{ + T_ne_ull(2ULL, 3ULL); + T_ne_ull(1ULL, 1ULL); + T_quiet_ne_ull(5ULL, 6ULL); + T_quiet_ne_ull(4ULL, 4ULL); + T_step_ne_ull(2, 8ULL, 9ULL); + T_step_ne_ull(3, 7ULL, 7ULL); + T_assert_ne_ull(11ULL, 12ULL); + T_assert_ne_ull(10ULL, 10ULL); +} + +T_TEST_CASE(step_assert_ge_ull) +{ + T_plan(2); + T_step_assert_ge_ull(0, 1ULL, 1ULL); + T_step_assert_ge_ull(1, 2ULL, 3ULL); +} + +T_TEST_CASE(check_ge_ull) +{ + T_ge_ull(1ULL, 1ULL); + T_ge_ull(2ULL, 3ULL); + T_quiet_ge_ull(4ULL, 4ULL); + T_quiet_ge_ull(5ULL, 6ULL); + T_step_ge_ull(2, 7ULL, 7ULL); + T_step_ge_ull(3, 8ULL, 9ULL); + T_assert_ge_ull(10ULL, 10ULL); + T_assert_ge_ull(11ULL, 12ULL); +} + +T_TEST_CASE(step_assert_gt_ull) +{ + T_plan(2); + T_step_assert_gt_ull(0, 2ULL, 1ULL); + T_step_assert_gt_ull(1, 3ULL, 3ULL); +} + +T_TEST_CASE(check_gt_ull) +{ + T_gt_ull(2ULL, 1ULL); + T_gt_ull(3ULL, 3ULL); + T_quiet_gt_ull(5ULL, 4ULL); + T_quiet_gt_ull(6ULL, 6ULL); + T_step_gt_ull(2, 8ULL, 7ULL); + T_step_gt_ull(3, 9ULL, 9ULL); + T_assert_gt_ull(10ULL, 11ULL); + T_assert_gt_ull(12ULL, 12ULL); +} + +T_TEST_CASE(step_assert_le_ull) +{ + T_plan(2); + T_step_assert_le_ull(0, 1ULL, 1ULL); + T_step_assert_le_ull(1, 3ULL, 2ULL); +} + +T_TEST_CASE(check_le_ull) +{ + T_le_ull(1ULL, 1ULL); + T_le_ull(3ULL, 2ULL); + T_quiet_le_ull(4ULL, 4ULL); + T_quiet_le_ull(6ULL, 5ULL); + T_step_le_ull(2, 7ULL, 7ULL); + T_step_le_ull(3, 9ULL, 8ULL); + T_assert_le_ull(10ULL, 10ULL); + T_assert_le_ull(12ULL, 11ULL); +} + +T_TEST_CASE(step_assert_lt_ull) +{ + T_plan(2); + T_step_assert_lt_ull(0, 1ULL, 2ULL); + T_step_assert_lt_ull(1, 3ULL, 3ULL); +} + +T_TEST_CASE(check_lt_ull) +{ + T_lt_ull(1ULL, 2ULL); + T_lt_ull(3ULL, 3ULL); + T_quiet_lt_ull(4ULL, 5ULL); + T_quiet_lt_ull(6ULL, 6ULL); + T_step_lt_ull(2, 7ULL, 8ULL); + T_step_lt_ull(3, 9ULL, 9ULL); + T_assert_lt_ull(10ULL, 11ULL); + T_assert_lt_ull(12ULL, 12ULL); +} + +T_TEST_CASE(step_assert_eq_i8) +{ + T_plan(2); + T_step_assert_eq_i8(0, INT8_C(1), INT8_C(1)); + T_step_assert_eq_i8(1, INT8_C(2), INT8_C(3)); +} + +T_TEST_CASE(check_eq_i8) +{ + T_eq_i8(INT8_C(1), INT8_C(1)); + T_eq_i8(INT8_C(2), INT8_C(3)); + T_quiet_eq_i8(INT8_C(4), INT8_C(4)); + T_quiet_eq_i8(INT8_C(5), INT8_C(6)); + T_step_eq_i8(2, INT8_C(7), INT8_C(7)); + T_step_eq_i8(3, INT8_C(8), INT8_C(9)); + T_assert_eq_i8(INT8_C(10), INT8_C(10)); + T_assert_eq_i8(INT8_C(11), INT8_C(12)); +} + +T_TEST_CASE(step_assert_ne_i8) +{ + T_plan(2); + T_step_assert_ne_i8(0, INT8_C(2), INT8_C(3)); + T_step_assert_ne_i8(1, INT8_C(1), INT8_C(1)); +} + +T_TEST_CASE(check_ne_i8) +{ + T_ne_i8(INT8_C(2), INT8_C(3)); + T_ne_i8(INT8_C(1), INT8_C(1)); + T_quiet_ne_i8(INT8_C(5), INT8_C(6)); + T_quiet_ne_i8(INT8_C(4), INT8_C(4)); + T_step_ne_i8(2, INT8_C(8), INT8_C(9)); + T_step_ne_i8(3, INT8_C(7), INT8_C(7)); + T_assert_ne_i8(INT8_C(11), INT8_C(12)); + T_assert_ne_i8(INT8_C(10), INT8_C(10)); +} + +T_TEST_CASE(step_assert_ge_i8) +{ + T_plan(2); + T_step_assert_ge_i8(0, INT8_C(1), INT8_C(1)); + T_step_assert_ge_i8(1, INT8_C(2), INT8_C(3)); +} + +T_TEST_CASE(check_ge_i8) +{ + T_ge_i8(INT8_C(1), INT8_C(1)); + T_ge_i8(INT8_C(2), INT8_C(3)); + T_quiet_ge_i8(INT8_C(4), INT8_C(4)); + T_quiet_ge_i8(INT8_C(5), INT8_C(6)); + T_step_ge_i8(2, INT8_C(7), INT8_C(7)); + T_step_ge_i8(3, INT8_C(8), INT8_C(9)); + T_assert_ge_i8(INT8_C(10), INT8_C(10)); + T_assert_ge_i8(INT8_C(11), INT8_C(12)); +} + +T_TEST_CASE(step_assert_gt_i8) +{ + T_plan(2); + T_step_assert_gt_i8(0, INT8_C(2), INT8_C(1)); + T_step_assert_gt_i8(1, INT8_C(3), INT8_C(3)); +} + +T_TEST_CASE(check_gt_i8) +{ + T_gt_i8(INT8_C(2), INT8_C(1)); + T_gt_i8(INT8_C(3), INT8_C(3)); + T_quiet_gt_i8(INT8_C(5), INT8_C(4)); + T_quiet_gt_i8(INT8_C(6), INT8_C(6)); + T_step_gt_i8(2, INT8_C(8), INT8_C(7)); + T_step_gt_i8(3, INT8_C(9), INT8_C(9)); + T_assert_gt_i8(INT8_C(10), INT8_C(11)); + T_assert_gt_i8(INT8_C(12), INT8_C(12)); +} + +T_TEST_CASE(step_assert_le_i8) +{ + T_plan(2); + T_step_assert_le_i8(0, INT8_C(1), INT8_C(1)); + T_step_assert_le_i8(1, INT8_C(3), INT8_C(2)); +} + +T_TEST_CASE(check_le_i8) +{ + T_le_i8(INT8_C(1), INT8_C(1)); + T_le_i8(INT8_C(3), INT8_C(2)); + T_quiet_le_i8(INT8_C(4), INT8_C(4)); + T_quiet_le_i8(INT8_C(6), INT8_C(5)); + T_step_le_i8(2, INT8_C(7), INT8_C(7)); + T_step_le_i8(3, INT8_C(9), INT8_C(8)); + T_assert_le_i8(INT8_C(10), INT8_C(10)); + T_assert_le_i8(INT8_C(12), INT8_C(11)); +} + +T_TEST_CASE(step_assert_lt_i8) +{ + T_plan(2); + T_step_assert_lt_i8(0, INT8_C(1), INT8_C(2)); + T_step_assert_lt_i8(1, INT8_C(3), INT8_C(3)); +} + +T_TEST_CASE(check_lt_i8) +{ + T_lt_i8(INT8_C(1), INT8_C(2)); + T_lt_i8(INT8_C(3), INT8_C(3)); + T_quiet_lt_i8(INT8_C(4), INT8_C(5)); + T_quiet_lt_i8(INT8_C(6), INT8_C(6)); + T_step_lt_i8(2, INT8_C(7), INT8_C(8)); + T_step_lt_i8(3, INT8_C(9), INT8_C(9)); + T_assert_lt_i8(INT8_C(10), INT8_C(11)); + T_assert_lt_i8(INT8_C(12), INT8_C(12)); +} + +T_TEST_CASE(step_assert_eq_u8) +{ + T_plan(2); + T_step_assert_eq_u8(0, UINT8_C(1), UINT8_C(1)); + T_step_assert_eq_u8(1, UINT8_C(2), UINT8_C(3)); +} + +T_TEST_CASE(check_eq_u8) +{ + T_eq_u8(UINT8_C(1), UINT8_C(1)); + T_eq_u8(UINT8_C(2), UINT8_C(3)); + T_quiet_eq_u8(UINT8_C(4), UINT8_C(4)); + T_quiet_eq_u8(UINT8_C(5), UINT8_C(6)); + T_step_eq_u8(2, UINT8_C(7), UINT8_C(7)); + T_step_eq_u8(3, UINT8_C(8), UINT8_C(9)); + T_assert_eq_u8(UINT8_C(10), UINT8_C(10)); + T_assert_eq_u8(UINT8_C(11), UINT8_C(12)); +} + +T_TEST_CASE(step_assert_ne_u8) +{ + T_plan(2); + T_step_assert_ne_u8(0, UINT8_C(2), UINT8_C(3)); + T_step_assert_ne_u8(1, UINT8_C(1), UINT8_C(1)); +} + +T_TEST_CASE(check_ne_u8) +{ + T_ne_u8(UINT8_C(2), UINT8_C(3)); + T_ne_u8(UINT8_C(1), UINT8_C(1)); + T_quiet_ne_u8(UINT8_C(5), UINT8_C(6)); + T_quiet_ne_u8(UINT8_C(4), UINT8_C(4)); + T_step_ne_u8(2, UINT8_C(8), UINT8_C(9)); + T_step_ne_u8(3, UINT8_C(7), UINT8_C(7)); + T_assert_ne_u8(UINT8_C(11), UINT8_C(12)); + T_assert_ne_u8(UINT8_C(10), UINT8_C(10)); +} + +T_TEST_CASE(step_assert_ge_u8) +{ + T_plan(2); + T_step_assert_ge_u8(0, UINT8_C(1), UINT8_C(1)); + T_step_assert_ge_u8(1, UINT8_C(2), UINT8_C(3)); +} + +T_TEST_CASE(check_ge_u8) +{ + T_ge_u8(UINT8_C(1), UINT8_C(1)); + T_ge_u8(UINT8_C(2), UINT8_C(3)); + T_quiet_ge_u8(UINT8_C(4), UINT8_C(4)); + T_quiet_ge_u8(UINT8_C(5), UINT8_C(6)); + T_step_ge_u8(2, UINT8_C(7), UINT8_C(7)); + T_step_ge_u8(3, UINT8_C(8), UINT8_C(9)); + T_assert_ge_u8(UINT8_C(10), UINT8_C(10)); + T_assert_ge_u8(UINT8_C(11), UINT8_C(12)); +} + +T_TEST_CASE(step_assert_gt_u8) +{ + T_plan(2); + T_step_assert_gt_u8(0, UINT8_C(2), UINT8_C(1)); + T_step_assert_gt_u8(1, UINT8_C(3), UINT8_C(3)); +} + +T_TEST_CASE(check_gt_u8) +{ + T_gt_u8(UINT8_C(2), UINT8_C(1)); + T_gt_u8(UINT8_C(3), UINT8_C(3)); + T_quiet_gt_u8(UINT8_C(5), UINT8_C(4)); + T_quiet_gt_u8(UINT8_C(6), UINT8_C(6)); + T_step_gt_u8(2, UINT8_C(8), UINT8_C(7)); + T_step_gt_u8(3, UINT8_C(9), UINT8_C(9)); + T_assert_gt_u8(UINT8_C(10), UINT8_C(11)); + T_assert_gt_u8(UINT8_C(12), UINT8_C(12)); +} + +T_TEST_CASE(step_assert_le_u8) +{ + T_plan(2); + T_step_assert_le_u8(0, UINT8_C(1), UINT8_C(1)); + T_step_assert_le_u8(1, UINT8_C(3), UINT8_C(2)); +} + +T_TEST_CASE(check_le_u8) +{ + T_le_u8(UINT8_C(1), UINT8_C(1)); + T_le_u8(UINT8_C(3), UINT8_C(2)); + T_quiet_le_u8(UINT8_C(4), UINT8_C(4)); + T_quiet_le_u8(UINT8_C(6), UINT8_C(5)); + T_step_le_u8(2, UINT8_C(7), UINT8_C(7)); + T_step_le_u8(3, UINT8_C(9), UINT8_C(8)); + T_assert_le_u8(UINT8_C(10), UINT8_C(10)); + T_assert_le_u8(UINT8_C(12), UINT8_C(11)); +} + +T_TEST_CASE(step_assert_lt_u8) +{ + T_plan(2); + T_step_assert_lt_u8(0, UINT8_C(1), UINT8_C(2)); + T_step_assert_lt_u8(1, UINT8_C(3), UINT8_C(3)); +} + +T_TEST_CASE(check_lt_u8) +{ + T_lt_u8(UINT8_C(1), UINT8_C(2)); + T_lt_u8(UINT8_C(3), UINT8_C(3)); + T_quiet_lt_u8(UINT8_C(4), UINT8_C(5)); + T_quiet_lt_u8(UINT8_C(6), UINT8_C(6)); + T_step_lt_u8(2, UINT8_C(7), UINT8_C(8)); + T_step_lt_u8(3, UINT8_C(9), UINT8_C(9)); + T_assert_lt_u8(UINT8_C(10), UINT8_C(11)); + T_assert_lt_u8(UINT8_C(12), UINT8_C(12)); +} + +T_TEST_CASE(step_assert_eq_i16) +{ + T_plan(2); + T_step_assert_eq_i16(0, INT16_C(1), INT16_C(1)); + T_step_assert_eq_i16(1, INT16_C(2), INT16_C(3)); +} + +T_TEST_CASE(check_eq_i16) +{ + T_eq_i16(INT16_C(1), INT16_C(1)); + T_eq_i16(INT16_C(2), INT16_C(3)); + T_quiet_eq_i16(INT16_C(4), INT16_C(4)); + T_quiet_eq_i16(INT16_C(5), INT16_C(6)); + T_step_eq_i16(2, INT16_C(7), INT16_C(7)); + T_step_eq_i16(3, INT16_C(8), INT16_C(9)); + T_assert_eq_i16(INT16_C(10), INT16_C(10)); + T_assert_eq_i16(INT16_C(11), INT16_C(12)); +} + +T_TEST_CASE(step_assert_ne_i16) +{ + T_plan(2); + T_step_assert_ne_i16(0, INT16_C(2), INT16_C(3)); + T_step_assert_ne_i16(1, INT16_C(1), INT16_C(1)); +} + +T_TEST_CASE(check_ne_i16) +{ + T_ne_i16(INT16_C(2), INT16_C(3)); + T_ne_i16(INT16_C(1), INT16_C(1)); + T_quiet_ne_i16(INT16_C(5), INT16_C(6)); + T_quiet_ne_i16(INT16_C(4), INT16_C(4)); + T_step_ne_i16(2, INT16_C(8), INT16_C(9)); + T_step_ne_i16(3, INT16_C(7), INT16_C(7)); + T_assert_ne_i16(INT16_C(11), INT16_C(12)); + T_assert_ne_i16(INT16_C(10), INT16_C(10)); +} + +T_TEST_CASE(step_assert_ge_i16) +{ + T_plan(2); + T_step_assert_ge_i16(0, INT16_C(1), INT16_C(1)); + T_step_assert_ge_i16(1, INT16_C(2), INT16_C(3)); +} + +T_TEST_CASE(check_ge_i16) +{ + T_ge_i16(INT16_C(1), INT16_C(1)); + T_ge_i16(INT16_C(2), INT16_C(3)); + T_quiet_ge_i16(INT16_C(4), INT16_C(4)); + T_quiet_ge_i16(INT16_C(5), INT16_C(6)); + T_step_ge_i16(2, INT16_C(7), INT16_C(7)); + T_step_ge_i16(3, INT16_C(8), INT16_C(9)); + T_assert_ge_i16(INT16_C(10), INT16_C(10)); + T_assert_ge_i16(INT16_C(11), INT16_C(12)); +} + +T_TEST_CASE(step_assert_gt_i16) +{ + T_plan(2); + T_step_assert_gt_i16(0, INT16_C(2), INT16_C(1)); + T_step_assert_gt_i16(1, INT16_C(3), INT16_C(3)); +} + +T_TEST_CASE(check_gt_i16) +{ + T_gt_i16(INT16_C(2), INT16_C(1)); + T_gt_i16(INT16_C(3), INT16_C(3)); + T_quiet_gt_i16(INT16_C(5), INT16_C(4)); + T_quiet_gt_i16(INT16_C(6), INT16_C(6)); + T_step_gt_i16(2, INT16_C(8), INT16_C(7)); + T_step_gt_i16(3, INT16_C(9), INT16_C(9)); + T_assert_gt_i16(INT16_C(10), INT16_C(11)); + T_assert_gt_i16(INT16_C(12), INT16_C(12)); +} + +T_TEST_CASE(step_assert_le_i16) +{ + T_plan(2); + T_step_assert_le_i16(0, INT16_C(1), INT16_C(1)); + T_step_assert_le_i16(1, INT16_C(3), INT16_C(2)); +} + +T_TEST_CASE(check_le_i16) +{ + T_le_i16(INT16_C(1), INT16_C(1)); + T_le_i16(INT16_C(3), INT16_C(2)); + T_quiet_le_i16(INT16_C(4), INT16_C(4)); + T_quiet_le_i16(INT16_C(6), INT16_C(5)); + T_step_le_i16(2, INT16_C(7), INT16_C(7)); + T_step_le_i16(3, INT16_C(9), INT16_C(8)); + T_assert_le_i16(INT16_C(10), INT16_C(10)); + T_assert_le_i16(INT16_C(12), INT16_C(11)); +} + +T_TEST_CASE(step_assert_lt_i16) +{ + T_plan(2); + T_step_assert_lt_i16(0, INT16_C(1), INT16_C(2)); + T_step_assert_lt_i16(1, INT16_C(3), INT16_C(3)); +} + +T_TEST_CASE(check_lt_i16) +{ + T_lt_i16(INT16_C(1), INT16_C(2)); + T_lt_i16(INT16_C(3), INT16_C(3)); + T_quiet_lt_i16(INT16_C(4), INT16_C(5)); + T_quiet_lt_i16(INT16_C(6), INT16_C(6)); + T_step_lt_i16(2, INT16_C(7), INT16_C(8)); + T_step_lt_i16(3, INT16_C(9), INT16_C(9)); + T_assert_lt_i16(INT16_C(10), INT16_C(11)); + T_assert_lt_i16(INT16_C(12), INT16_C(12)); +} + +T_TEST_CASE(step_assert_eq_u16) +{ + T_plan(2); + T_step_assert_eq_u16(0, UINT16_C(1), UINT16_C(1)); + T_step_assert_eq_u16(1, UINT16_C(2), UINT16_C(3)); +} + +T_TEST_CASE(check_eq_u16) +{ + T_eq_u16(UINT16_C(1), UINT16_C(1)); + T_eq_u16(UINT16_C(2), UINT16_C(3)); + T_quiet_eq_u16(UINT16_C(4), UINT16_C(4)); + T_quiet_eq_u16(UINT16_C(5), UINT16_C(6)); + T_step_eq_u16(2, UINT16_C(7), UINT16_C(7)); + T_step_eq_u16(3, UINT16_C(8), UINT16_C(9)); + T_assert_eq_u16(UINT16_C(10), UINT16_C(10)); + T_assert_eq_u16(UINT16_C(11), UINT16_C(12)); +} + +T_TEST_CASE(step_assert_ne_u16) +{ + T_plan(2); + T_step_assert_ne_u16(0, UINT16_C(2), UINT16_C(3)); + T_step_assert_ne_u16(1, UINT16_C(1), UINT16_C(1)); +} + +T_TEST_CASE(check_ne_u16) +{ + T_ne_u16(UINT16_C(2), UINT16_C(3)); + T_ne_u16(UINT16_C(1), UINT16_C(1)); + T_quiet_ne_u16(UINT16_C(5), UINT16_C(6)); + T_quiet_ne_u16(UINT16_C(4), UINT16_C(4)); + T_step_ne_u16(2, UINT16_C(8), UINT16_C(9)); + T_step_ne_u16(3, UINT16_C(7), UINT16_C(7)); + T_assert_ne_u16(UINT16_C(11), UINT16_C(12)); + T_assert_ne_u16(UINT16_C(10), UINT16_C(10)); +} + +T_TEST_CASE(step_assert_ge_u16) +{ + T_plan(2); + T_step_assert_ge_u16(0, UINT16_C(1), UINT16_C(1)); + T_step_assert_ge_u16(1, UINT16_C(2), UINT16_C(3)); +} + +T_TEST_CASE(check_ge_u16) +{ + T_ge_u16(UINT16_C(1), UINT16_C(1)); + T_ge_u16(UINT16_C(2), UINT16_C(3)); + T_quiet_ge_u16(UINT16_C(4), UINT16_C(4)); + T_quiet_ge_u16(UINT16_C(5), UINT16_C(6)); + T_step_ge_u16(2, UINT16_C(7), UINT16_C(7)); + T_step_ge_u16(3, UINT16_C(8), UINT16_C(9)); + T_assert_ge_u16(UINT16_C(10), UINT16_C(10)); + T_assert_ge_u16(UINT16_C(11), UINT16_C(12)); +} + +T_TEST_CASE(step_assert_gt_u16) +{ + T_plan(2); + T_step_assert_gt_u16(0, UINT16_C(2), UINT16_C(1)); + T_step_assert_gt_u16(1, UINT16_C(3), UINT16_C(3)); +} + +T_TEST_CASE(check_gt_u16) +{ + T_gt_u16(UINT16_C(2), UINT16_C(1)); + T_gt_u16(UINT16_C(3), UINT16_C(3)); + T_quiet_gt_u16(UINT16_C(5), UINT16_C(4)); + T_quiet_gt_u16(UINT16_C(6), UINT16_C(6)); + T_step_gt_u16(2, UINT16_C(8), UINT16_C(7)); + T_step_gt_u16(3, UINT16_C(9), UINT16_C(9)); + T_assert_gt_u16(UINT16_C(10), UINT16_C(11)); + T_assert_gt_u16(UINT16_C(12), UINT16_C(12)); +} + +T_TEST_CASE(step_assert_le_u16) +{ + T_plan(2); + T_step_assert_le_u16(0, UINT16_C(1), UINT16_C(1)); + T_step_assert_le_u16(1, UINT16_C(3), UINT16_C(2)); +} + +T_TEST_CASE(check_le_u16) +{ + T_le_u16(UINT16_C(1), UINT16_C(1)); + T_le_u16(UINT16_C(3), UINT16_C(2)); + T_quiet_le_u16(UINT16_C(4), UINT16_C(4)); + T_quiet_le_u16(UINT16_C(6), UINT16_C(5)); + T_step_le_u16(2, UINT16_C(7), UINT16_C(7)); + T_step_le_u16(3, UINT16_C(9), UINT16_C(8)); + T_assert_le_u16(UINT16_C(10), UINT16_C(10)); + T_assert_le_u16(UINT16_C(12), UINT16_C(11)); +} + +T_TEST_CASE(step_assert_lt_u16) +{ + T_plan(2); + T_step_assert_lt_u16(0, UINT16_C(1), UINT16_C(2)); + T_step_assert_lt_u16(1, UINT16_C(3), UINT16_C(3)); +} + +T_TEST_CASE(check_lt_u16) +{ + T_lt_u16(UINT16_C(1), UINT16_C(2)); + T_lt_u16(UINT16_C(3), UINT16_C(3)); + T_quiet_lt_u16(UINT16_C(4), UINT16_C(5)); + T_quiet_lt_u16(UINT16_C(6), UINT16_C(6)); + T_step_lt_u16(2, UINT16_C(7), UINT16_C(8)); + T_step_lt_u16(3, UINT16_C(9), UINT16_C(9)); + T_assert_lt_u16(UINT16_C(10), UINT16_C(11)); + T_assert_lt_u16(UINT16_C(12), UINT16_C(12)); +} + +T_TEST_CASE(step_assert_eq_i32) +{ + T_plan(2); + T_step_assert_eq_i32(0, INT32_C(1), INT32_C(1)); + T_step_assert_eq_i32(1, INT32_C(2), INT32_C(3)); +} + +T_TEST_CASE(check_eq_i32) +{ + T_eq_i32(INT32_C(1), INT32_C(1)); + T_eq_i32(INT32_C(2), INT32_C(3)); + T_quiet_eq_i32(INT32_C(4), INT32_C(4)); + T_quiet_eq_i32(INT32_C(5), INT32_C(6)); + T_step_eq_i32(2, INT32_C(7), INT32_C(7)); + T_step_eq_i32(3, INT32_C(8), INT32_C(9)); + T_assert_eq_i32(INT32_C(10), INT32_C(10)); + T_assert_eq_i32(INT32_C(11), INT32_C(12)); +} + +T_TEST_CASE(step_assert_ne_i32) +{ + T_plan(2); + T_step_assert_ne_i32(0, INT32_C(2), INT32_C(3)); + T_step_assert_ne_i32(1, INT32_C(1), INT32_C(1)); +} + +T_TEST_CASE(check_ne_i32) +{ + T_ne_i32(INT32_C(2), INT32_C(3)); + T_ne_i32(INT32_C(1), INT32_C(1)); + T_quiet_ne_i32(INT32_C(5), INT32_C(6)); + T_quiet_ne_i32(INT32_C(4), INT32_C(4)); + T_step_ne_i32(2, INT32_C(8), INT32_C(9)); + T_step_ne_i32(3, INT32_C(7), INT32_C(7)); + T_assert_ne_i32(INT32_C(11), INT32_C(12)); + T_assert_ne_i32(INT32_C(10), INT32_C(10)); +} + +T_TEST_CASE(step_assert_ge_i32) +{ + T_plan(2); + T_step_assert_ge_i32(0, INT32_C(1), INT32_C(1)); + T_step_assert_ge_i32(1, INT32_C(2), INT32_C(3)); +} + +T_TEST_CASE(check_ge_i32) +{ + T_ge_i32(INT32_C(1), INT32_C(1)); + T_ge_i32(INT32_C(2), INT32_C(3)); + T_quiet_ge_i32(INT32_C(4), INT32_C(4)); + T_quiet_ge_i32(INT32_C(5), INT32_C(6)); + T_step_ge_i32(2, INT32_C(7), INT32_C(7)); + T_step_ge_i32(3, INT32_C(8), INT32_C(9)); + T_assert_ge_i32(INT32_C(10), INT32_C(10)); + T_assert_ge_i32(INT32_C(11), INT32_C(12)); +} + +T_TEST_CASE(step_assert_gt_i32) +{ + T_plan(2); + T_step_assert_gt_i32(0, INT32_C(2), INT32_C(1)); + T_step_assert_gt_i32(1, INT32_C(3), INT32_C(3)); +} + +T_TEST_CASE(check_gt_i32) +{ + T_gt_i32(INT32_C(2), INT32_C(1)); + T_gt_i32(INT32_C(3), INT32_C(3)); + T_quiet_gt_i32(INT32_C(5), INT32_C(4)); + T_quiet_gt_i32(INT32_C(6), INT32_C(6)); + T_step_gt_i32(2, INT32_C(8), INT32_C(7)); + T_step_gt_i32(3, INT32_C(9), INT32_C(9)); + T_assert_gt_i32(INT32_C(10), INT32_C(11)); + T_assert_gt_i32(INT32_C(12), INT32_C(12)); +} + +T_TEST_CASE(step_assert_le_i32) +{ + T_plan(2); + T_step_assert_le_i32(0, INT32_C(1), INT32_C(1)); + T_step_assert_le_i32(1, INT32_C(3), INT32_C(2)); +} + +T_TEST_CASE(check_le_i32) +{ + T_le_i32(INT32_C(1), INT32_C(1)); + T_le_i32(INT32_C(3), INT32_C(2)); + T_quiet_le_i32(INT32_C(4), INT32_C(4)); + T_quiet_le_i32(INT32_C(6), INT32_C(5)); + T_step_le_i32(2, INT32_C(7), INT32_C(7)); + T_step_le_i32(3, INT32_C(9), INT32_C(8)); + T_assert_le_i32(INT32_C(10), INT32_C(10)); + T_assert_le_i32(INT32_C(12), INT32_C(11)); +} + +T_TEST_CASE(step_assert_lt_i32) +{ + T_plan(2); + T_step_assert_lt_i32(0, INT32_C(1), INT32_C(2)); + T_step_assert_lt_i32(1, INT32_C(3), INT32_C(3)); +} + +T_TEST_CASE(check_lt_i32) +{ + T_lt_i32(INT32_C(1), INT32_C(2)); + T_lt_i32(INT32_C(3), INT32_C(3)); + T_quiet_lt_i32(INT32_C(4), INT32_C(5)); + T_quiet_lt_i32(INT32_C(6), INT32_C(6)); + T_step_lt_i32(2, INT32_C(7), INT32_C(8)); + T_step_lt_i32(3, INT32_C(9), INT32_C(9)); + T_assert_lt_i32(INT32_C(10), INT32_C(11)); + T_assert_lt_i32(INT32_C(12), INT32_C(12)); +} + +T_TEST_CASE(step_assert_eq_u32) +{ + T_plan(2); + T_step_assert_eq_u32(0, UINT32_C(1), UINT32_C(1)); + T_step_assert_eq_u32(1, UINT32_C(2), UINT32_C(3)); +} + +T_TEST_CASE(check_eq_u32) +{ + T_eq_u32(UINT32_C(1), UINT32_C(1)); + T_eq_u32(UINT32_C(2), UINT32_C(3)); + T_quiet_eq_u32(UINT32_C(4), UINT32_C(4)); + T_quiet_eq_u32(UINT32_C(5), UINT32_C(6)); + T_step_eq_u32(2, UINT32_C(7), UINT32_C(7)); + T_step_eq_u32(3, UINT32_C(8), UINT32_C(9)); + T_assert_eq_u32(UINT32_C(10), UINT32_C(10)); + T_assert_eq_u32(UINT32_C(11), UINT32_C(12)); +} + +T_TEST_CASE(step_assert_ne_u32) +{ + T_plan(2); + T_step_assert_ne_u32(0, UINT32_C(2), UINT32_C(3)); + T_step_assert_ne_u32(1, UINT32_C(1), UINT32_C(1)); +} + +T_TEST_CASE(check_ne_u32) +{ + T_ne_u32(UINT32_C(2), UINT32_C(3)); + T_ne_u32(UINT32_C(1), UINT32_C(1)); + T_quiet_ne_u32(UINT32_C(5), UINT32_C(6)); + T_quiet_ne_u32(UINT32_C(4), UINT32_C(4)); + T_step_ne_u32(2, UINT32_C(8), UINT32_C(9)); + T_step_ne_u32(3, UINT32_C(7), UINT32_C(7)); + T_assert_ne_u32(UINT32_C(11), UINT32_C(12)); + T_assert_ne_u32(UINT32_C(10), UINT32_C(10)); +} + +T_TEST_CASE(step_assert_ge_u32) +{ + T_plan(2); + T_step_assert_ge_u32(0, UINT32_C(1), UINT32_C(1)); + T_step_assert_ge_u32(1, UINT32_C(2), UINT32_C(3)); +} + +T_TEST_CASE(check_ge_u32) +{ + T_ge_u32(UINT32_C(1), UINT32_C(1)); + T_ge_u32(UINT32_C(2), UINT32_C(3)); + T_quiet_ge_u32(UINT32_C(4), UINT32_C(4)); + T_quiet_ge_u32(UINT32_C(5), UINT32_C(6)); + T_step_ge_u32(2, UINT32_C(7), UINT32_C(7)); + T_step_ge_u32(3, UINT32_C(8), UINT32_C(9)); + T_assert_ge_u32(UINT32_C(10), UINT32_C(10)); + T_assert_ge_u32(UINT32_C(11), UINT32_C(12)); +} + +T_TEST_CASE(step_assert_gt_u32) +{ + T_plan(2); + T_step_assert_gt_u32(0, UINT32_C(2), UINT32_C(1)); + T_step_assert_gt_u32(1, UINT32_C(3), UINT32_C(3)); +} + +T_TEST_CASE(check_gt_u32) +{ + T_gt_u32(UINT32_C(2), UINT32_C(1)); + T_gt_u32(UINT32_C(3), UINT32_C(3)); + T_quiet_gt_u32(UINT32_C(5), UINT32_C(4)); + T_quiet_gt_u32(UINT32_C(6), UINT32_C(6)); + T_step_gt_u32(2, UINT32_C(8), UINT32_C(7)); + T_step_gt_u32(3, UINT32_C(9), UINT32_C(9)); + T_assert_gt_u32(UINT32_C(10), UINT32_C(11)); + T_assert_gt_u32(UINT32_C(12), UINT32_C(12)); +} + +T_TEST_CASE(step_assert_le_u32) +{ + T_plan(2); + T_step_assert_le_u32(0, UINT32_C(1), UINT32_C(1)); + T_step_assert_le_u32(1, UINT32_C(3), UINT32_C(2)); +} + +T_TEST_CASE(check_le_u32) +{ + T_le_u32(UINT32_C(1), UINT32_C(1)); + T_le_u32(UINT32_C(3), UINT32_C(2)); + T_quiet_le_u32(UINT32_C(4), UINT32_C(4)); + T_quiet_le_u32(UINT32_C(6), UINT32_C(5)); + T_step_le_u32(2, UINT32_C(7), UINT32_C(7)); + T_step_le_u32(3, UINT32_C(9), UINT32_C(8)); + T_assert_le_u32(UINT32_C(10), UINT32_C(10)); + T_assert_le_u32(UINT32_C(12), UINT32_C(11)); +} + +T_TEST_CASE(step_assert_lt_u32) +{ + T_plan(2); + T_step_assert_lt_u32(0, UINT32_C(1), UINT32_C(2)); + T_step_assert_lt_u32(1, UINT32_C(3), UINT32_C(3)); +} + +T_TEST_CASE(check_lt_u32) +{ + T_lt_u32(UINT32_C(1), UINT32_C(2)); + T_lt_u32(UINT32_C(3), UINT32_C(3)); + T_quiet_lt_u32(UINT32_C(4), UINT32_C(5)); + T_quiet_lt_u32(UINT32_C(6), UINT32_C(6)); + T_step_lt_u32(2, UINT32_C(7), UINT32_C(8)); + T_step_lt_u32(3, UINT32_C(9), UINT32_C(9)); + T_assert_lt_u32(UINT32_C(10), UINT32_C(11)); + T_assert_lt_u32(UINT32_C(12), UINT32_C(12)); +} + +T_TEST_CASE(step_assert_eq_i64) +{ + T_plan(2); + T_step_assert_eq_i64(0, INT64_C(1), INT64_C(1)); + T_step_assert_eq_i64(1, INT64_C(2), INT64_C(3)); +} + +T_TEST_CASE(check_eq_i64) +{ + T_eq_i64(INT64_C(1), INT64_C(1)); + T_eq_i64(INT64_C(2), INT64_C(3)); + T_quiet_eq_i64(INT64_C(4), INT64_C(4)); + T_quiet_eq_i64(INT64_C(5), INT64_C(6)); + T_step_eq_i64(2, INT64_C(7), INT64_C(7)); + T_step_eq_i64(3, INT64_C(8), INT64_C(9)); + T_assert_eq_i64(INT64_C(10), INT64_C(10)); + T_assert_eq_i64(INT64_C(11), INT64_C(12)); +} + +T_TEST_CASE(step_assert_ne_i64) +{ + T_plan(2); + T_step_assert_ne_i64(0, INT64_C(2), INT64_C(3)); + T_step_assert_ne_i64(1, INT64_C(1), INT64_C(1)); +} + +T_TEST_CASE(check_ne_i64) +{ + T_ne_i64(INT64_C(2), INT64_C(3)); + T_ne_i64(INT64_C(1), INT64_C(1)); + T_quiet_ne_i64(INT64_C(5), INT64_C(6)); + T_quiet_ne_i64(INT64_C(4), INT64_C(4)); + T_step_ne_i64(2, INT64_C(8), INT64_C(9)); + T_step_ne_i64(3, INT64_C(7), INT64_C(7)); + T_assert_ne_i64(INT64_C(11), INT64_C(12)); + T_assert_ne_i64(INT64_C(10), INT64_C(10)); +} + +T_TEST_CASE(step_assert_ge_i64) +{ + T_plan(2); + T_step_assert_ge_i64(0, INT64_C(1), INT64_C(1)); + T_step_assert_ge_i64(1, INT64_C(2), INT64_C(3)); +} + +T_TEST_CASE(check_ge_i64) +{ + T_ge_i64(INT64_C(1), INT64_C(1)); + T_ge_i64(INT64_C(2), INT64_C(3)); + T_quiet_ge_i64(INT64_C(4), INT64_C(4)); + T_quiet_ge_i64(INT64_C(5), INT64_C(6)); + T_step_ge_i64(2, INT64_C(7), INT64_C(7)); + T_step_ge_i64(3, INT64_C(8), INT64_C(9)); + T_assert_ge_i64(INT64_C(10), INT64_C(10)); + T_assert_ge_i64(INT64_C(11), INT64_C(12)); +} + +T_TEST_CASE(step_assert_gt_i64) +{ + T_plan(2); + T_step_assert_gt_i64(0, INT64_C(2), INT64_C(1)); + T_step_assert_gt_i64(1, INT64_C(3), INT64_C(3)); +} + +T_TEST_CASE(check_gt_i64) +{ + T_gt_i64(INT64_C(2), INT64_C(1)); + T_gt_i64(INT64_C(3), INT64_C(3)); + T_quiet_gt_i64(INT64_C(5), INT64_C(4)); + T_quiet_gt_i64(INT64_C(6), INT64_C(6)); + T_step_gt_i64(2, INT64_C(8), INT64_C(7)); + T_step_gt_i64(3, INT64_C(9), INT64_C(9)); + T_assert_gt_i64(INT64_C(10), INT64_C(11)); + T_assert_gt_i64(INT64_C(12), INT64_C(12)); +} + +T_TEST_CASE(step_assert_le_i64) +{ + T_plan(2); + T_step_assert_le_i64(0, INT64_C(1), INT64_C(1)); + T_step_assert_le_i64(1, INT64_C(3), INT64_C(2)); +} + +T_TEST_CASE(check_le_i64) +{ + T_le_i64(INT64_C(1), INT64_C(1)); + T_le_i64(INT64_C(3), INT64_C(2)); + T_quiet_le_i64(INT64_C(4), INT64_C(4)); + T_quiet_le_i64(INT64_C(6), INT64_C(5)); + T_step_le_i64(2, INT64_C(7), INT64_C(7)); + T_step_le_i64(3, INT64_C(9), INT64_C(8)); + T_assert_le_i64(INT64_C(10), INT64_C(10)); + T_assert_le_i64(INT64_C(12), INT64_C(11)); +} + +T_TEST_CASE(step_assert_lt_i64) +{ + T_plan(2); + T_step_assert_lt_i64(0, INT64_C(1), INT64_C(2)); + T_step_assert_lt_i64(1, INT64_C(3), INT64_C(3)); +} + +T_TEST_CASE(check_lt_i64) +{ + T_lt_i64(INT64_C(1), INT64_C(2)); + T_lt_i64(INT64_C(3), INT64_C(3)); + T_quiet_lt_i64(INT64_C(4), INT64_C(5)); + T_quiet_lt_i64(INT64_C(6), INT64_C(6)); + T_step_lt_i64(2, INT64_C(7), INT64_C(8)); + T_step_lt_i64(3, INT64_C(9), INT64_C(9)); + T_assert_lt_i64(INT64_C(10), INT64_C(11)); + T_assert_lt_i64(INT64_C(12), INT64_C(12)); +} + +T_TEST_CASE(step_assert_eq_u64) +{ + T_plan(2); + T_step_assert_eq_u64(0, UINT64_C(1), UINT64_C(1)); + T_step_assert_eq_u64(1, UINT64_C(2), UINT64_C(3)); +} + +T_TEST_CASE(check_eq_u64) +{ + T_eq_u64(UINT64_C(1), UINT64_C(1)); + T_eq_u64(UINT64_C(2), UINT64_C(3)); + T_quiet_eq_u64(UINT64_C(4), UINT64_C(4)); + T_quiet_eq_u64(UINT64_C(5), UINT64_C(6)); + T_step_eq_u64(2, UINT64_C(7), UINT64_C(7)); + T_step_eq_u64(3, UINT64_C(8), UINT64_C(9)); + T_assert_eq_u64(UINT64_C(10), UINT64_C(10)); + T_assert_eq_u64(UINT64_C(11), UINT64_C(12)); +} + +T_TEST_CASE(step_assert_ne_u64) +{ + T_plan(2); + T_step_assert_ne_u64(0, UINT64_C(2), UINT64_C(3)); + T_step_assert_ne_u64(1, UINT64_C(1), UINT64_C(1)); +} + +T_TEST_CASE(check_ne_u64) +{ + T_ne_u64(UINT64_C(2), UINT64_C(3)); + T_ne_u64(UINT64_C(1), UINT64_C(1)); + T_quiet_ne_u64(UINT64_C(5), UINT64_C(6)); + T_quiet_ne_u64(UINT64_C(4), UINT64_C(4)); + T_step_ne_u64(2, UINT64_C(8), UINT64_C(9)); + T_step_ne_u64(3, UINT64_C(7), UINT64_C(7)); + T_assert_ne_u64(UINT64_C(11), UINT64_C(12)); + T_assert_ne_u64(UINT64_C(10), UINT64_C(10)); +} + +T_TEST_CASE(step_assert_ge_u64) +{ + T_plan(2); + T_step_assert_ge_u64(0, UINT64_C(1), UINT64_C(1)); + T_step_assert_ge_u64(1, UINT64_C(2), UINT64_C(3)); +} + +T_TEST_CASE(check_ge_u64) +{ + T_ge_u64(UINT64_C(1), UINT64_C(1)); + T_ge_u64(UINT64_C(2), UINT64_C(3)); + T_quiet_ge_u64(UINT64_C(4), UINT64_C(4)); + T_quiet_ge_u64(UINT64_C(5), UINT64_C(6)); + T_step_ge_u64(2, UINT64_C(7), UINT64_C(7)); + T_step_ge_u64(3, UINT64_C(8), UINT64_C(9)); + T_assert_ge_u64(UINT64_C(10), UINT64_C(10)); + T_assert_ge_u64(UINT64_C(11), UINT64_C(12)); +} + +T_TEST_CASE(step_assert_gt_u64) +{ + T_plan(2); + T_step_assert_gt_u64(0, UINT64_C(2), UINT64_C(1)); + T_step_assert_gt_u64(1, UINT64_C(3), UINT64_C(3)); +} + +T_TEST_CASE(check_gt_u64) +{ + T_gt_u64(UINT64_C(2), UINT64_C(1)); + T_gt_u64(UINT64_C(3), UINT64_C(3)); + T_quiet_gt_u64(UINT64_C(5), UINT64_C(4)); + T_quiet_gt_u64(UINT64_C(6), UINT64_C(6)); + T_step_gt_u64(2, UINT64_C(8), UINT64_C(7)); + T_step_gt_u64(3, UINT64_C(9), UINT64_C(9)); + T_assert_gt_u64(UINT64_C(10), UINT64_C(11)); + T_assert_gt_u64(UINT64_C(12), UINT64_C(12)); +} + +T_TEST_CASE(step_assert_le_u64) +{ + T_plan(2); + T_step_assert_le_u64(0, UINT64_C(1), UINT64_C(1)); + T_step_assert_le_u64(1, UINT64_C(3), UINT64_C(2)); +} + +T_TEST_CASE(check_le_u64) +{ + T_le_u64(UINT64_C(1), UINT64_C(1)); + T_le_u64(UINT64_C(3), UINT64_C(2)); + T_quiet_le_u64(UINT64_C(4), UINT64_C(4)); + T_quiet_le_u64(UINT64_C(6), UINT64_C(5)); + T_step_le_u64(2, UINT64_C(7), UINT64_C(7)); + T_step_le_u64(3, UINT64_C(9), UINT64_C(8)); + T_assert_le_u64(UINT64_C(10), UINT64_C(10)); + T_assert_le_u64(UINT64_C(12), UINT64_C(11)); +} + +T_TEST_CASE(step_assert_lt_u64) +{ + T_plan(2); + T_step_assert_lt_u64(0, UINT64_C(1), UINT64_C(2)); + T_step_assert_lt_u64(1, UINT64_C(3), UINT64_C(3)); +} + +T_TEST_CASE(check_lt_u64) +{ + T_lt_u64(UINT64_C(1), UINT64_C(2)); + T_lt_u64(UINT64_C(3), UINT64_C(3)); + T_quiet_lt_u64(UINT64_C(4), UINT64_C(5)); + T_quiet_lt_u64(UINT64_C(6), UINT64_C(6)); + T_step_lt_u64(2, UINT64_C(7), UINT64_C(8)); + T_step_lt_u64(3, UINT64_C(9), UINT64_C(9)); + T_assert_lt_u64(UINT64_C(10), UINT64_C(11)); + T_assert_lt_u64(UINT64_C(12), UINT64_C(12)); +} + +T_TEST_CASE(step_assert_eq_iptr) +{ + T_plan(2); + T_step_assert_eq_iptr(0, (intptr_t)1, (intptr_t)1); + T_step_assert_eq_iptr(1, (intptr_t)2, (intptr_t)3); +} + +T_TEST_CASE(check_eq_iptr) +{ + T_eq_iptr((intptr_t)1, (intptr_t)1); + T_eq_iptr((intptr_t)2, (intptr_t)3); + T_quiet_eq_iptr((intptr_t)4, (intptr_t)4); + T_quiet_eq_iptr((intptr_t)5, (intptr_t)6); + T_step_eq_iptr(2, (intptr_t)7, (intptr_t)7); + T_step_eq_iptr(3, (intptr_t)8, (intptr_t)9); + T_assert_eq_iptr((intptr_t)10, (intptr_t)10); + T_assert_eq_iptr((intptr_t)11, (intptr_t)12); +} + +T_TEST_CASE(step_assert_ne_iptr) +{ + T_plan(2); + T_step_assert_ne_iptr(0, (intptr_t)2, (intptr_t)3); + T_step_assert_ne_iptr(1, (intptr_t)1, (intptr_t)1); +} + +T_TEST_CASE(check_ne_iptr) +{ + T_ne_iptr((intptr_t)2, (intptr_t)3); + T_ne_iptr((intptr_t)1, (intptr_t)1); + T_quiet_ne_iptr((intptr_t)5, (intptr_t)6); + T_quiet_ne_iptr((intptr_t)4, (intptr_t)4); + T_step_ne_iptr(2, (intptr_t)8, (intptr_t)9); + T_step_ne_iptr(3, (intptr_t)7, (intptr_t)7); + T_assert_ne_iptr((intptr_t)11, (intptr_t)12); + T_assert_ne_iptr((intptr_t)10, (intptr_t)10); +} + +T_TEST_CASE(step_assert_ge_iptr) +{ + T_plan(2); + T_step_assert_ge_iptr(0, (intptr_t)1, (intptr_t)1); + T_step_assert_ge_iptr(1, (intptr_t)2, (intptr_t)3); +} + +T_TEST_CASE(check_ge_iptr) +{ + T_ge_iptr((intptr_t)1, (intptr_t)1); + T_ge_iptr((intptr_t)2, (intptr_t)3); + T_quiet_ge_iptr((intptr_t)4, (intptr_t)4); + T_quiet_ge_iptr((intptr_t)5, (intptr_t)6); + T_step_ge_iptr(2, (intptr_t)7, (intptr_t)7); + T_step_ge_iptr(3, (intptr_t)8, (intptr_t)9); + T_assert_ge_iptr((intptr_t)10, (intptr_t)10); + T_assert_ge_iptr((intptr_t)11, (intptr_t)12); +} + +T_TEST_CASE(step_assert_gt_iptr) +{ + T_plan(2); + T_step_assert_gt_iptr(0, (intptr_t)2, (intptr_t)1); + T_step_assert_gt_iptr(1, (intptr_t)3, (intptr_t)3); +} + +T_TEST_CASE(check_gt_iptr) +{ + T_gt_iptr((intptr_t)2, (intptr_t)1); + T_gt_iptr((intptr_t)3, (intptr_t)3); + T_quiet_gt_iptr((intptr_t)5, (intptr_t)4); + T_quiet_gt_iptr((intptr_t)6, (intptr_t)6); + T_step_gt_iptr(2, (intptr_t)8, (intptr_t)7); + T_step_gt_iptr(3, (intptr_t)9, (intptr_t)9); + T_assert_gt_iptr((intptr_t)10, (intptr_t)11); + T_assert_gt_iptr((intptr_t)12, (intptr_t)12); +} + +T_TEST_CASE(step_assert_le_iptr) +{ + T_plan(2); + T_step_assert_le_iptr(0, (intptr_t)1, (intptr_t)1); + T_step_assert_le_iptr(1, (intptr_t)3, (intptr_t)2); +} + +T_TEST_CASE(check_le_iptr) +{ + T_le_iptr((intptr_t)1, (intptr_t)1); + T_le_iptr((intptr_t)3, (intptr_t)2); + T_quiet_le_iptr((intptr_t)4, (intptr_t)4); + T_quiet_le_iptr((intptr_t)6, (intptr_t)5); + T_step_le_iptr(2, (intptr_t)7, (intptr_t)7); + T_step_le_iptr(3, (intptr_t)9, (intptr_t)8); + T_assert_le_iptr((intptr_t)10, (intptr_t)10); + T_assert_le_iptr((intptr_t)12, (intptr_t)11); +} + +T_TEST_CASE(step_assert_lt_iptr) +{ + T_plan(2); + T_step_assert_lt_iptr(0, (intptr_t)1, (intptr_t)2); + T_step_assert_lt_iptr(1, (intptr_t)3, (intptr_t)3); +} + +T_TEST_CASE(check_lt_iptr) +{ + T_lt_iptr((intptr_t)1, (intptr_t)2); + T_lt_iptr((intptr_t)3, (intptr_t)3); + T_quiet_lt_iptr((intptr_t)4, (intptr_t)5); + T_quiet_lt_iptr((intptr_t)6, (intptr_t)6); + T_step_lt_iptr(2, (intptr_t)7, (intptr_t)8); + T_step_lt_iptr(3, (intptr_t)9, (intptr_t)9); + T_assert_lt_iptr((intptr_t)10, (intptr_t)11); + T_assert_lt_iptr((intptr_t)12, (intptr_t)12); +} + +T_TEST_CASE(step_assert_eq_uptr) +{ + T_plan(2); + T_step_assert_eq_uptr(0, (size_t)1, (size_t)1); + T_step_assert_eq_uptr(1, (size_t)2, (size_t)3); +} + +T_TEST_CASE(check_eq_uptr) +{ + T_eq_uptr((size_t)1, (size_t)1); + T_eq_uptr((size_t)2, (size_t)3); + T_quiet_eq_uptr((size_t)4, (size_t)4); + T_quiet_eq_uptr((size_t)5, (size_t)6); + T_step_eq_uptr(2, (size_t)7, (size_t)7); + T_step_eq_uptr(3, (size_t)8, (size_t)9); + T_assert_eq_uptr((size_t)10, (size_t)10); + T_assert_eq_uptr((size_t)11, (size_t)12); +} + +T_TEST_CASE(step_assert_ne_uptr) +{ + T_plan(2); + T_step_assert_ne_uptr(0, (size_t)2, (size_t)3); + T_step_assert_ne_uptr(1, (size_t)1, (size_t)1); +} + +T_TEST_CASE(check_ne_uptr) +{ + T_ne_uptr((size_t)2, (size_t)3); + T_ne_uptr((size_t)1, (size_t)1); + T_quiet_ne_uptr((size_t)5, (size_t)6); + T_quiet_ne_uptr((size_t)4, (size_t)4); + T_step_ne_uptr(2, (size_t)8, (size_t)9); + T_step_ne_uptr(3, (size_t)7, (size_t)7); + T_assert_ne_uptr((size_t)11, (size_t)12); + T_assert_ne_uptr((size_t)10, (size_t)10); +} + +T_TEST_CASE(step_assert_ge_uptr) +{ + T_plan(2); + T_step_assert_ge_uptr(0, (size_t)1, (size_t)1); + T_step_assert_ge_uptr(1, (size_t)2, (size_t)3); +} + +T_TEST_CASE(check_ge_uptr) +{ + T_ge_uptr((size_t)1, (size_t)1); + T_ge_uptr((size_t)2, (size_t)3); + T_quiet_ge_uptr((size_t)4, (size_t)4); + T_quiet_ge_uptr((size_t)5, (size_t)6); + T_step_ge_uptr(2, (size_t)7, (size_t)7); + T_step_ge_uptr(3, (size_t)8, (size_t)9); + T_assert_ge_uptr((size_t)10, (size_t)10); + T_assert_ge_uptr((size_t)11, (size_t)12); +} + +T_TEST_CASE(step_assert_gt_uptr) +{ + T_plan(2); + T_step_assert_gt_uptr(0, (size_t)2, (size_t)1); + T_step_assert_gt_uptr(1, (size_t)3, (size_t)3); +} + +T_TEST_CASE(check_gt_uptr) +{ + T_gt_uptr((size_t)2, (size_t)1); + T_gt_uptr((size_t)3, (size_t)3); + T_quiet_gt_uptr((size_t)5, (size_t)4); + T_quiet_gt_uptr((size_t)6, (size_t)6); + T_step_gt_uptr(2, (size_t)8, (size_t)7); + T_step_gt_uptr(3, (size_t)9, (size_t)9); + T_assert_gt_uptr((size_t)10, (size_t)11); + T_assert_gt_uptr((size_t)12, (size_t)12); +} + +T_TEST_CASE(step_assert_le_uptr) +{ + T_plan(2); + T_step_assert_le_uptr(0, (size_t)1, (size_t)1); + T_step_assert_le_uptr(1, (size_t)3, (size_t)2); +} + +T_TEST_CASE(check_le_uptr) +{ + T_le_uptr((size_t)1, (size_t)1); + T_le_uptr((size_t)3, (size_t)2); + T_quiet_le_uptr((size_t)4, (size_t)4); + T_quiet_le_uptr((size_t)6, (size_t)5); + T_step_le_uptr(2, (size_t)7, (size_t)7); + T_step_le_uptr(3, (size_t)9, (size_t)8); + T_assert_le_uptr((size_t)10, (size_t)10); + T_assert_le_uptr((size_t)12, (size_t)11); +} + +T_TEST_CASE(step_assert_lt_uptr) +{ + T_plan(2); + T_step_assert_lt_uptr(0, (size_t)1, (size_t)2); + T_step_assert_lt_uptr(1, (size_t)3, (size_t)3); +} + +T_TEST_CASE(check_lt_uptr) +{ + T_lt_uptr((size_t)1, (size_t)2); + T_lt_uptr((size_t)3, (size_t)3); + T_quiet_lt_uptr((size_t)4, (size_t)5); + T_quiet_lt_uptr((size_t)6, (size_t)6); + T_step_lt_uptr(2, (size_t)7, (size_t)8); + T_step_lt_uptr(3, (size_t)9, (size_t)9); + T_assert_lt_uptr((size_t)10, (size_t)11); + T_assert_lt_uptr((size_t)12, (size_t)12); +} + +T_TEST_CASE(step_assert_eq_ssz) +{ + T_plan(2); + T_step_assert_eq_ssz(0, (ssize_t)1, (ssize_t)1); + T_step_assert_eq_ssz(1, (ssize_t)2, (ssize_t)3); +} + +T_TEST_CASE(check_eq_ssz) +{ + T_eq_ssz((ssize_t)1, (ssize_t)1); + T_eq_ssz((ssize_t)2, (ssize_t)3); + T_quiet_eq_ssz((ssize_t)4, (ssize_t)4); + T_quiet_eq_ssz((ssize_t)5, (ssize_t)6); + T_step_eq_ssz(2, (ssize_t)7, (ssize_t)7); + T_step_eq_ssz(3, (ssize_t)8, (ssize_t)9); + T_assert_eq_ssz((ssize_t)10, (ssize_t)10); + T_assert_eq_ssz((ssize_t)11, (ssize_t)12); +} + +T_TEST_CASE(step_assert_ne_ssz) +{ + T_plan(2); + T_step_assert_ne_ssz(0, (ssize_t)2, (ssize_t)3); + T_step_assert_ne_ssz(1, (ssize_t)1, (ssize_t)1); +} + +T_TEST_CASE(check_ne_ssz) +{ + T_ne_ssz((ssize_t)2, (ssize_t)3); + T_ne_ssz((ssize_t)1, (ssize_t)1); + T_quiet_ne_ssz((ssize_t)5, (ssize_t)6); + T_quiet_ne_ssz((ssize_t)4, (ssize_t)4); + T_step_ne_ssz(2, (ssize_t)8, (ssize_t)9); + T_step_ne_ssz(3, (ssize_t)7, (ssize_t)7); + T_assert_ne_ssz((ssize_t)11, (ssize_t)12); + T_assert_ne_ssz((ssize_t)10, (ssize_t)10); +} + +T_TEST_CASE(step_assert_ge_ssz) +{ + T_plan(2); + T_step_assert_ge_ssz(0, (ssize_t)1, (ssize_t)1); + T_step_assert_ge_ssz(1, (ssize_t)2, (ssize_t)3); +} + +T_TEST_CASE(check_ge_ssz) +{ + T_ge_ssz((ssize_t)1, (ssize_t)1); + T_ge_ssz((ssize_t)2, (ssize_t)3); + T_quiet_ge_ssz((ssize_t)4, (ssize_t)4); + T_quiet_ge_ssz((ssize_t)5, (ssize_t)6); + T_step_ge_ssz(2, (ssize_t)7, (ssize_t)7); + T_step_ge_ssz(3, (ssize_t)8, (ssize_t)9); + T_assert_ge_ssz((ssize_t)10, (ssize_t)10); + T_assert_ge_ssz((ssize_t)11, (ssize_t)12); +} + +T_TEST_CASE(step_assert_gt_ssz) +{ + T_plan(2); + T_step_assert_gt_ssz(0, (ssize_t)2, (ssize_t)1); + T_step_assert_gt_ssz(1, (ssize_t)3, (ssize_t)3); +} + +T_TEST_CASE(check_gt_ssz) +{ + T_gt_ssz((ssize_t)2, (ssize_t)1); + T_gt_ssz((ssize_t)3, (ssize_t)3); + T_quiet_gt_ssz((ssize_t)5, (ssize_t)4); + T_quiet_gt_ssz((ssize_t)6, (ssize_t)6); + T_step_gt_ssz(2, (ssize_t)8, (ssize_t)7); + T_step_gt_ssz(3, (ssize_t)9, (ssize_t)9); + T_assert_gt_ssz((ssize_t)10, (ssize_t)11); + T_assert_gt_ssz((ssize_t)12, (ssize_t)12); +} + +T_TEST_CASE(step_assert_le_ssz) +{ + T_plan(2); + T_step_assert_le_ssz(0, (ssize_t)1, (ssize_t)1); + T_step_assert_le_ssz(1, (ssize_t)3, (ssize_t)2); +} + +T_TEST_CASE(check_le_ssz) +{ + T_le_ssz((ssize_t)1, (ssize_t)1); + T_le_ssz((ssize_t)3, (ssize_t)2); + T_quiet_le_ssz((ssize_t)4, (ssize_t)4); + T_quiet_le_ssz((ssize_t)6, (ssize_t)5); + T_step_le_ssz(2, (ssize_t)7, (ssize_t)7); + T_step_le_ssz(3, (ssize_t)9, (ssize_t)8); + T_assert_le_ssz((ssize_t)10, (ssize_t)10); + T_assert_le_ssz((ssize_t)12, (ssize_t)11); +} + +T_TEST_CASE(step_assert_lt_ssz) +{ + T_plan(2); + T_step_assert_lt_ssz(0, (ssize_t)1, (ssize_t)2); + T_step_assert_lt_ssz(1, (ssize_t)3, (ssize_t)3); +} + +T_TEST_CASE(check_lt_ssz) +{ + T_lt_ssz((ssize_t)1, (ssize_t)2); + T_lt_ssz((ssize_t)3, (ssize_t)3); + T_quiet_lt_ssz((ssize_t)4, (ssize_t)5); + T_quiet_lt_ssz((ssize_t)6, (ssize_t)6); + T_step_lt_ssz(2, (ssize_t)7, (ssize_t)8); + T_step_lt_ssz(3, (ssize_t)9, (ssize_t)9); + T_assert_lt_ssz((ssize_t)10, (ssize_t)11); + T_assert_lt_ssz((ssize_t)12, (ssize_t)12); +} + +T_TEST_CASE(step_assert_eq_sz) +{ + T_plan(2); + T_step_assert_eq_sz(0, (size_t)1, (size_t)1); + T_step_assert_eq_sz(1, (size_t)2, (size_t)3); +} + +T_TEST_CASE(check_eq_sz) +{ + T_eq_sz((size_t)1, (size_t)1); + T_eq_sz((size_t)2, (size_t)3); + T_quiet_eq_sz((size_t)4, (size_t)4); + T_quiet_eq_sz((size_t)5, (size_t)6); + T_step_eq_sz(2, (size_t)7, (size_t)7); + T_step_eq_sz(3, (size_t)8, (size_t)9); + T_assert_eq_sz((size_t)10, (size_t)10); + T_assert_eq_sz((size_t)11, (size_t)12); +} + +T_TEST_CASE(step_assert_ne_sz) +{ + T_plan(2); + T_step_assert_ne_sz(0, (size_t)2, (size_t)3); + T_step_assert_ne_sz(1, (size_t)1, (size_t)1); +} + +T_TEST_CASE(check_ne_sz) +{ + T_ne_sz((size_t)2, (size_t)3); + T_ne_sz((size_t)1, (size_t)1); + T_quiet_ne_sz((size_t)5, (size_t)6); + T_quiet_ne_sz((size_t)4, (size_t)4); + T_step_ne_sz(2, (size_t)8, (size_t)9); + T_step_ne_sz(3, (size_t)7, (size_t)7); + T_assert_ne_sz((size_t)11, (size_t)12); + T_assert_ne_sz((size_t)10, (size_t)10); +} + +T_TEST_CASE(step_assert_ge_sz) +{ + T_plan(2); + T_step_assert_ge_sz(0, (size_t)1, (size_t)1); + T_step_assert_ge_sz(1, (size_t)2, (size_t)3); +} + +T_TEST_CASE(check_ge_sz) +{ + T_ge_sz((size_t)1, (size_t)1); + T_ge_sz((size_t)2, (size_t)3); + T_quiet_ge_sz((size_t)4, (size_t)4); + T_quiet_ge_sz((size_t)5, (size_t)6); + T_step_ge_sz(2, (size_t)7, (size_t)7); + T_step_ge_sz(3, (size_t)8, (size_t)9); + T_assert_ge_sz((size_t)10, (size_t)10); + T_assert_ge_sz((size_t)11, (size_t)12); +} + +T_TEST_CASE(step_assert_gt_sz) +{ + T_plan(2); + T_step_assert_gt_sz(0, (size_t)2, (size_t)1); + T_step_assert_gt_sz(1, (size_t)3, (size_t)3); +} + +T_TEST_CASE(check_gt_sz) +{ + T_gt_sz((size_t)2, (size_t)1); + T_gt_sz((size_t)3, (size_t)3); + T_quiet_gt_sz((size_t)5, (size_t)4); + T_quiet_gt_sz((size_t)6, (size_t)6); + T_step_gt_sz(2, (size_t)8, (size_t)7); + T_step_gt_sz(3, (size_t)9, (size_t)9); + T_assert_gt_sz((size_t)10, (size_t)11); + T_assert_gt_sz((size_t)12, (size_t)12); +} + +T_TEST_CASE(step_assert_le_sz) +{ + T_plan(2); + T_step_assert_le_sz(0, (size_t)1, (size_t)1); + T_step_assert_le_sz(1, (size_t)3, (size_t)2); +} + +T_TEST_CASE(check_le_sz) +{ + T_le_sz((size_t)1, (size_t)1); + T_le_sz((size_t)3, (size_t)2); + T_quiet_le_sz((size_t)4, (size_t)4); + T_quiet_le_sz((size_t)6, (size_t)5); + T_step_le_sz(2, (size_t)7, (size_t)7); + T_step_le_sz(3, (size_t)9, (size_t)8); + T_assert_le_sz((size_t)10, (size_t)10); + T_assert_le_sz((size_t)12, (size_t)11); +} + +T_TEST_CASE(step_assert_lt_sz) +{ + T_plan(2); + T_step_assert_lt_sz(0, (size_t)1, (size_t)2); + T_step_assert_lt_sz(1, (size_t)3, (size_t)3); +} + +T_TEST_CASE(check_lt_sz) +{ + T_lt_sz((size_t)1, (size_t)2); + T_lt_sz((size_t)3, (size_t)3); + T_quiet_lt_sz((size_t)4, (size_t)5); + T_quiet_lt_sz((size_t)6, (size_t)6); + T_step_lt_sz(2, (size_t)7, (size_t)8); + T_step_lt_sz(3, (size_t)9, (size_t)9); + T_assert_lt_sz((size_t)10, (size_t)11); + T_assert_lt_sz((size_t)12, (size_t)12); +} + +/* + * The license is at the end of the file to be able to use the test code and + * output in examples in the documentation. This is also the reason for the + * dual licensing. The license for RTEMS documentation is CC-BY-SA-4.0. + */ + +/* + * SPDX-License-Identifier: BSD-2-Clause OR CC-BY-SA-4.0 + * + * Copyright (C) 2018, 2019 embedded brains GmbH + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * ALTERNATIVELY, this software may be distributed under the terms of the + * Creative Commons Attribution-ShareAlike 4.0 International Public License as + * published by Creative Commons, PO Box 1866, Mountain View, CA 94042 + * (https://creativecommons.org/licenses/by-sa/4.0/legalcode). + */ diff --git a/testsuites/libtests/ttest01/test-destructor.c b/testsuites/libtests/ttest01/test-destructor.c new file mode 100644 index 0000000000..df2a4e6b0a --- /dev/null +++ b/testsuites/libtests/ttest01/test-destructor.c @@ -0,0 +1,54 @@ +#include + +static void +destroy(T_destructor *dtor) +{ + (void)dtor; + T_step(0, "destroy"); +} + +T_TEST_CASE(destructor) +{ + static T_destructor dtor; + + T_plan(1); + T_add_destructor(&dtor, destroy); +} + +/* + * The license is at the end of the file to be able to use the test code and + * output in examples in the documentation. This is also the reason for the + * dual licensing. The license for RTEMS documentation is CC-BY-SA-4.0. + */ + +/* + * SPDX-License-Identifier: BSD-2-Clause OR CC-BY-SA-4.0 + * + * Copyright (C) 2018, 2019 embedded brains GmbH + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * ALTERNATIVELY, this software may be distributed under the terms of the + * Creative Commons Attribution-ShareAlike 4.0 International Public License as + * published by Creative Commons, PO Box 1866, Mountain View, CA 94042 + * (https://creativecommons.org/licenses/by-sa/4.0/legalcode). + */ diff --git a/testsuites/libtests/ttest01/test-eno.c b/testsuites/libtests/ttest01/test-eno.c new file mode 100644 index 0000000000..e34ada4f8e --- /dev/null +++ b/testsuites/libtests/ttest01/test-eno.c @@ -0,0 +1,60 @@ +#include +#include + +T_TEST_CASE(test_eno) +{ + T_eno(ENOMEM, ENOMEM); + T_eno(ENOMEM, ERANGE); + T_quiet_eno(ENOMEM, ENOMEM); + T_quiet_eno(ENOMEM, ERANGE); + T_assert_eno(ENOMEM, ENOMEM); + T_assert_eno(ENOMEM, ERANGE); +} + +T_TEST_CASE(test_eno_success) +{ + T_eno_success(0); + T_eno_success(ENOMEM); + T_quiet_eno_success(0); + T_quiet_eno_success(ENOMEM); + T_assert_eno_success(0); + T_assert_eno_success(ENOMEM); +} + +/* + * The license is at the end of the file to be able to use the test code and + * output in examples in the documentation. This is also the reason for the + * dual licensing. The license for RTEMS documentation is CC-BY-SA-4.0. + */ + +/* + * SPDX-License-Identifier: BSD-2-Clause OR CC-BY-SA-4.0 + * + * Copyright (C) 2018, 2019 embedded brains GmbH + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * ALTERNATIVELY, this software may be distributed under the terms of the + * Creative Commons Attribution-ShareAlike 4.0 International Public License as + * published by Creative Commons, PO Box 1866, Mountain View, CA 94042 + * (https://creativecommons.org/licenses/by-sa/4.0/legalcode). + */ diff --git a/testsuites/libtests/ttest01/test-fixture.c b/testsuites/libtests/ttest01/test-fixture.c new file mode 100644 index 0000000000..b5b8d4493a --- /dev/null +++ b/testsuites/libtests/ttest01/test-fixture.c @@ -0,0 +1,96 @@ +#include + +static int initial_value = 3; + +static int counter; + +static void +setup(void *ctx) +{ + int *c; + + T_log(T_QUIET, "setup begin"); + T_eq_ptr(ctx, &initial_value); + T_eq_ptr(ctx, T_fixture_context()); + c = ctx; + counter = *c; + T_set_fixture_context(&counter); + T_eq_ptr(&counter, T_fixture_context()); + T_log(T_QUIET, "setup end"); +} + +static void +stop(void *ctx) +{ + int *c; + + T_log(T_QUIET, "stop begin"); + T_eq_ptr(ctx, &counter); + c = ctx; + ++(*c); + T_log(T_QUIET, "stop end"); +} + +static void +teardown(void *ctx) +{ + int *c; + + T_log(T_QUIET, "teardown begin"); + T_eq_ptr(ctx, &counter); + c = ctx; + T_eq_int(*c, 4); + T_log(T_QUIET, "teardown end"); +} + +static const T_fixture fixture = { + .setup = setup, + .stop = stop, + .teardown = teardown, + .initial_context = &initial_value +}; + +T_TEST_CASE_FIXTURE(fixture, &fixture) +{ + T_assert_true(true, "all right"); + T_assert_true(false, "test fails and we stop the test case"); + T_log(T_QUIET, "not reached"); +} + +/* + * The license is at the end of the file to be able to use the test code and + * output in examples in the documentation. This is also the reason for the + * dual licensing. The license for RTEMS documentation is CC-BY-SA-4.0. + */ + +/* + * SPDX-License-Identifier: BSD-2-Clause OR CC-BY-SA-4.0 + * + * Copyright (C) 2018, 2019 embedded brains GmbH + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * ALTERNATIVELY, this software may be distributed under the terms of the + * Creative Commons Attribution-ShareAlike 4.0 International Public License as + * published by Creative Commons, PO Box 1866, Mountain View, CA 94042 + * (https://creativecommons.org/licenses/by-sa/4.0/legalcode). + */ diff --git a/testsuites/libtests/ttest01/test-leak.c b/testsuites/libtests/ttest01/test-leak.c new file mode 100644 index 0000000000..b9d35e4ba4 --- /dev/null +++ b/testsuites/libtests/ttest01/test-leak.c @@ -0,0 +1,170 @@ +#include + +#include + +#include + +T_TEST_CASE(missing_sema_delete) +{ + rtems_status_code sc; + rtems_id id; + + sc = rtems_semaphore_create(rtems_build_name('S', 'E', 'M', 'A'), 0, + RTEMS_COUNTING_SEMAPHORE, 0, &id); + T_rsc_success(sc); +} + +T_TEST_CASE(missing_free) +{ + void *p; + + p = malloc(1); + T_not_null(p); +} + +#include +#include +#include +#include + +T_TEST_CASE(missing_close) +{ + int fd; + + fd = open("/", O_RDONLY); + T_ge_int(fd, 0); +} + +T_TEST_CASE(missing_barrier_delete) +{ + rtems_status_code sc; + rtems_id id; + + sc = rtems_barrier_create(rtems_build_name('T', 'E', 'S', 'T'), + RTEMS_DEFAULT_ATTRIBUTES, 1, &id); + T_rsc_success(sc); +} + +T_TEST_CASE(missing_extension_delete) +{ + rtems_status_code sc; + rtems_id id; + rtems_extensions_table table; + + memset(&table, 0, sizeof(table)); + sc = rtems_extension_create(rtems_build_name('T', 'E', 'S', 'T'), + &table, &id); + T_rsc_success(sc); +} + +T_TEST_CASE(missing_mq_delete) +{ + rtems_status_code sc; + rtems_id id; + + sc = rtems_message_queue_create(rtems_build_name('T', 'E', 'S', 'T'), + 1, 1, RTEMS_DEFAULT_ATTRIBUTES, &id); + T_rsc_success(sc); +} + +T_TEST_CASE(missing_part_delete) +{ + rtems_status_code sc; + rtems_id id; + long buf[32]; + + sc = rtems_partition_create(rtems_build_name('T', 'E', 'S', 'T'), buf, + sizeof(buf), sizeof(buf), RTEMS_DEFAULT_ATTRIBUTES, &id); + T_rsc_success(sc); +} + +T_TEST_CASE(missing_period_delete) +{ + rtems_status_code sc; + rtems_id id; + + sc = rtems_rate_monotonic_create(rtems_build_name('T', 'E', 'S', 'T'), + &id); + T_rsc_success(sc); +} + +T_TEST_CASE(missing_region_delete) +{ + rtems_status_code sc; + rtems_id id; + long buf[32]; + + sc = rtems_region_create(rtems_build_name('T', 'E', 'S', 'T'), buf, + sizeof(buf), 1, RTEMS_DEFAULT_ATTRIBUTES, &id); + T_rsc_success(sc); +} + +T_TEST_CASE(missing_task_delete) +{ + rtems_status_code sc; + rtems_id id; + + sc = rtems_task_create(rtems_build_name('T', 'E', 'S', 'T'), 1, + RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, + RTEMS_DEFAULT_ATTRIBUTES, &id); + T_rsc_success(sc); +} + +T_TEST_CASE(missing_timer_delete) +{ + rtems_status_code sc; + rtems_id id; + + sc = rtems_timer_create(rtems_build_name('T', 'E', 'S', 'T'), &id); + T_rsc_success(sc); +} + +T_TEST_CASE(missing_key_delete) +{ + pthread_key_t key; + int eno; + + eno = pthread_key_create(&key, NULL); + T_psx_success(eno); + + eno = pthread_setspecific(key, &key); + T_psx_success(eno); +} + +/* + * The license is at the end of the file to be able to use the test code and + * output in examples in the documentation. This is also the reason for the + * dual licensing. The license for RTEMS documentation is CC-BY-SA-4.0. + */ + +/* + * SPDX-License-Identifier: BSD-2-Clause OR CC-BY-SA-4.0 + * + * Copyright (C) 2018, 2019 embedded brains GmbH + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * ALTERNATIVELY, this software may be distributed under the terms of the + * Creative Commons Attribution-ShareAlike 4.0 International Public License as + * published by Creative Commons, PO Box 1866, Mountain View, CA 94042 + * (https://creativecommons.org/licenses/by-sa/4.0/legalcode). + */ diff --git a/testsuites/libtests/ttest01/test-log.c b/testsuites/libtests/ttest01/test-log.c new file mode 100644 index 0000000000..0ea1e668fd --- /dev/null +++ b/testsuites/libtests/ttest01/test-log.c @@ -0,0 +1,46 @@ +#include + +T_TEST_CASE(log) +{ + T_log(T_NORMAL, "a custom message %i, %i, %i", 1, 2, 3); + T_set_verbosity(T_QUIET); + T_log(T_NORMAL, "not verbose enough"); +} + +/* + * The license is at the end of the file to be able to use the test code and + * output in examples in the documentation. This is also the reason for the + * dual licensing. The license for RTEMS documentation is CC-BY-SA-4.0. + */ + +/* + * SPDX-License-Identifier: BSD-2-Clause OR CC-BY-SA-4.0 + * + * Copyright (C) 2018, 2019 embedded brains GmbH + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * ALTERNATIVELY, this software may be distributed under the terms of the + * Creative Commons Attribution-ShareAlike 4.0 International Public License as + * published by Creative Commons, PO Box 1866, Mountain View, CA 94042 + * (https://creativecommons.org/licenses/by-sa/4.0/legalcode). + */ diff --git a/testsuites/libtests/ttest01/test-malloc.c b/testsuites/libtests/ttest01/test-malloc.c new file mode 100644 index 0000000000..961379fe5c --- /dev/null +++ b/testsuites/libtests/ttest01/test-malloc.c @@ -0,0 +1,93 @@ +#include + +T_TEST_CASE(malloc_free) +{ + void *p; + + p = T_malloc(1); + T_assert_not_null(p); + T_free(p); +} + +T_TEST_CASE(malloc_auto) +{ + void *p; + + p = T_malloc(1); + T_assert_not_null(p); +} + +static void +destroy(void *p) +{ + int *i; + + i = p; + T_step_eq_int(2, *i, 1); +} + +T_TEST_CASE(zalloc_auto) +{ + int *i; + + T_plan(3); + i = T_zalloc(sizeof(*i), destroy); + T_step_assert_not_null(0, i); + T_step_eq_int(1, *i, 0); + *i = 1; +} + +T_TEST_CASE(malloc_huge) +{ + void *p; + + p = T_malloc(SIZE_MAX); + T_null(p); +} + +T_TEST_CASE(calloc_auto) +{ + int *i; + + i = T_calloc(1, sizeof(*i)); + T_assert_not_null(i); + T_eq_int(*i, 0); +} + +/* + * The license is at the end of the file to be able to use the test code and + * output in examples in the documentation. This is also the reason for the + * dual licensing. The license for RTEMS documentation is CC-BY-SA-4.0. + */ + +/* + * SPDX-License-Identifier: BSD-2-Clause OR CC-BY-SA-4.0 + * + * Copyright (C) 2018, 2019 embedded brains GmbH + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * ALTERNATIVELY, this software may be distributed under the terms of the + * Creative Commons Attribution-ShareAlike 4.0 International Public License as + * published by Creative Commons, PO Box 1866, Mountain View, CA 94042 + * (https://creativecommons.org/licenses/by-sa/4.0/legalcode). + */ diff --git a/testsuites/libtests/ttest01/test-plan.c b/testsuites/libtests/ttest01/test-plan.c new file mode 100644 index 0000000000..91dc087d96 --- /dev/null +++ b/testsuites/libtests/ttest01/test-plan.c @@ -0,0 +1,73 @@ +#include + +T_TEST_CASE(wrong_step) +{ + T_plan(2); + T_step_true(0, true, "all right"); + T_step_true(2, true, "wrong step"); +} + +T_TEST_CASE(plan_ok) +{ + T_plan(1); + T_step_true(0, true, "all right"); +} + +T_TEST_CASE(plan_failed) +{ + T_plan(2); + T_step_true(0, true, "not enough steps"); + T_quiet_true(true, "quiet test do not count"); +} + +T_TEST_CASE(double_plan) +{ + T_plan(99); + T_plan(2); +} + +T_TEST_CASE(steps) +{ + T_step(0, "a"); + T_plan(3); + T_step(1, "b"); + T_step(2, "c"); +} + +/* + * The license is at the end of the file to be able to use the test code and + * output in examples in the documentation. This is also the reason for the + * dual licensing. The license for RTEMS documentation is CC-BY-SA-4.0. + */ + +/* + * SPDX-License-Identifier: BSD-2-Clause OR CC-BY-SA-4.0 + * + * Copyright (C) 2018, 2019 embedded brains GmbH + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * ALTERNATIVELY, this software may be distributed under the terms of the + * Creative Commons Attribution-ShareAlike 4.0 International Public License as + * published by Creative Commons, PO Box 1866, Mountain View, CA 94042 + * (https://creativecommons.org/licenses/by-sa/4.0/legalcode). + */ diff --git a/testsuites/libtests/ttest01/test-psx.c b/testsuites/libtests/ttest01/test-psx.c new file mode 100644 index 0000000000..b1dbc723b2 --- /dev/null +++ b/testsuites/libtests/ttest01/test-psx.c @@ -0,0 +1,75 @@ +#include + +#include +#include + +T_TEST_CASE(stat) +{ + struct stat st; + int rv; + + errno = 0; + rv = stat("foobar", &st); + T_psx_error(rv, ENOENT); +} + +T_TEST_CASE(test_psx_error) +{ + errno = ENOMEM; + T_psx_error(-1, ENOMEM); + T_psx_error(-1, ERANGE); + T_psx_error(0, ENOMEM); + T_quiet_psx_error(-1, ENOMEM); + T_quiet_psx_error(-1, ERANGE); + T_quiet_psx_error(0, ENOMEM); + T_assert_psx_error(-1, ENOMEM); + T_assert_psx_error(0, ENOMEM); +} + +T_TEST_CASE(test_psx_success) +{ + T_psx_success(0); + T_psx_success(-1); + T_quiet_psx_success(0); + T_quiet_psx_success(-1); + T_assert_psx_success(0); + T_assert_psx_success(-1); +} + +/* + * The license is at the end of the file to be able to use the test code and + * output in examples in the documentation. This is also the reason for the + * dual licensing. The license for RTEMS documentation is CC-BY-SA-4.0. + */ + +/* + * SPDX-License-Identifier: BSD-2-Clause OR CC-BY-SA-4.0 + * + * Copyright (C) 2018, 2019 embedded brains GmbH + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * ALTERNATIVELY, this software may be distributed under the terms of the + * Creative Commons Attribution-ShareAlike 4.0 International Public License as + * published by Creative Commons, PO Box 1866, Mountain View, CA 94042 + * (https://creativecommons.org/licenses/by-sa/4.0/legalcode). + */ diff --git a/testsuites/libtests/ttest01/test-rtems.c b/testsuites/libtests/ttest01/test-rtems.c new file mode 100644 index 0000000000..74fb89831e --- /dev/null +++ b/testsuites/libtests/ttest01/test-rtems.c @@ -0,0 +1,109 @@ +#include + +#include + +static void +wakeup(rtems_id id, void *arg) +{ + rtems_status_code sc; + rtems_id *task; + + (void)id; + task = arg; + sc = rtems_event_send(*task, RTEMS_EVENT_0); + T_step_rsc_success(3, sc); + T_step_false(4, T_is_runner(), "ISR is runner"); +} + +T_TEST_CASE(timer) +{ + rtems_status_code sc; + rtems_id id; + rtems_id task; + rtems_event_set events; + + T_plan(8); + T_step_true(0, T_is_runner(), "test body is not runner"); + + sc = rtems_timer_create(rtems_build_name('T', 'E', 'S', 'T'), &id); + T_step_assert_rsc_success(1, sc); + + /* + * Make sure that the next step is not immediately interrupted by the + * clock interrupt. + */ + (void)rtems_task_wake_after(1); + + task = rtems_task_self(); + sc = rtems_timer_fire_after(id, 1, wakeup, &task); + T_step_rsc_success(2, sc); + + events = 0; + sc = rtems_event_receive(RTEMS_EVENT_0, RTEMS_WAIT | RTEMS_EVENT_ALL, + RTEMS_NO_TIMEOUT, &events); + T_step_rsc_success(5, sc); + T_step_eq_u32(6, events, RTEMS_EVENT_0); + + sc = rtems_timer_delete(id); + T_step_rsc_success(7, sc); +} + +T_TEST_CASE(rsc) +{ + T_plan(6); + T_rsc(RTEMS_INVALID_ID, RTEMS_INVALID_ID); + T_rsc(RTEMS_INVALID_NUMBER, RTEMS_INVALID_ID); + T_quiet_rsc(RTEMS_INVALID_ID, RTEMS_INVALID_ID); + T_quiet_rsc(RTEMS_INVALID_NUMBER, RTEMS_INVALID_ID); + T_assert_rsc(RTEMS_INVALID_ID, RTEMS_INVALID_ID); + T_assert_rsc(RTEMS_INVALID_NUMBER, RTEMS_INVALID_ID); +} + +T_TEST_CASE(rsc_success) +{ + T_plan(6); + T_rsc_success(RTEMS_SUCCESSFUL); + T_rsc_success(RTEMS_INVALID_NUMBER); + T_quiet_rsc_success(RTEMS_SUCCESSFUL); + T_quiet_rsc_success(RTEMS_INVALID_NUMBER); + T_assert_rsc_success(RTEMS_SUCCESSFUL); + T_assert_rsc_success(RTEMS_INVALID_NUMBER); +} + +/* + * The license is at the end of the file to be able to use the test code and + * output in examples in the documentation. This is also the reason for the + * dual licensing. The license for RTEMS documentation is CC-BY-SA-4.0. + */ + +/* + * SPDX-License-Identifier: BSD-2-Clause OR CC-BY-SA-4.0 + * + * Copyright (C) 2018, 2019 embedded brains GmbH + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * ALTERNATIVELY, this software may be distributed under the terms of the + * Creative Commons Attribution-ShareAlike 4.0 International Public License as + * published by Creative Commons, PO Box 1866, Mountain View, CA 94042 + * (https://creativecommons.org/licenses/by-sa/4.0/legalcode). + */ diff --git a/testsuites/libtests/ttest01/test-simple.c b/testsuites/libtests/ttest01/test-simple.c new file mode 100644 index 0000000000..1f69ab22a7 --- /dev/null +++ b/testsuites/libtests/ttest01/test-simple.c @@ -0,0 +1,53 @@ +#include + +static int add(int a, int b) +{ + return a + b; +} + +T_TEST_CASE(a_test_case) +{ + int actual_value; + + actual_value = add(1, 1); + T_eq_int(actual_value, 2); + T_true(false, "a test failure message"); +} + +/* + * The license is at the end of the file to be able to use the test code and + * output in examples in the documentation. This is also the reason for the + * dual licensing. The license for RTEMS documentation is CC-BY-SA-4.0. + */ + +/* + * SPDX-License-Identifier: BSD-2-Clause OR CC-BY-SA-4.0 + * + * Copyright (C) 2018, 2019 embedded brains GmbH + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * ALTERNATIVELY, this software may be distributed under the terms of the + * Creative Commons Attribution-ShareAlike 4.0 International Public License as + * published by Creative Commons, PO Box 1866, Mountain View, CA 94042 + * (https://creativecommons.org/licenses/by-sa/4.0/legalcode). + */ diff --git a/testsuites/libtests/ttest01/test-step.c b/testsuites/libtests/ttest01/test-step.c new file mode 100644 index 0000000000..3c8e22da90 --- /dev/null +++ b/testsuites/libtests/ttest01/test-step.c @@ -0,0 +1,45 @@ +#include + +T_TEST_CASE(step) +{ + T_step_true(0, true, "all right"); + T_step_true(2, true, "not the right step"); +} + +/* + * The license is at the end of the file to be able to use the test code and + * output in examples in the documentation. This is also the reason for the + * dual licensing. The license for RTEMS documentation is CC-BY-SA-4.0. + */ + +/* + * SPDX-License-Identifier: BSD-2-Clause OR CC-BY-SA-4.0 + * + * Copyright (C) 2018, 2019 embedded brains GmbH + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * ALTERNATIVELY, this software may be distributed under the terms of the + * Creative Commons Attribution-ShareAlike 4.0 International Public License as + * published by Creative Commons, PO Box 1866, Mountain View, CA 94042 + * (https://creativecommons.org/licenses/by-sa/4.0/legalcode). + */ diff --git a/testsuites/libtests/ttest01/test-time.c b/testsuites/libtests/ttest01/test-time.c new file mode 100644 index 0000000000..648c644739 --- /dev/null +++ b/testsuites/libtests/ttest01/test-time.c @@ -0,0 +1,228 @@ +#include + +T_TEST_CASE(time_to_string) +{ + T_time_string ts; + T_time t; + uint32_t s; + uint32_t ns; + + t = T_seconds_and_nanoseconds_to_time(0, 123456789); + T_eq_str(T_time_to_string_ns(t, ts), "0.123456789"); + T_eq_str(T_time_to_string_us(t, ts), "0.123456"); + T_eq_str(T_time_to_string_ms(t, ts), "0.123"); + T_eq_str(T_time_to_string_s(t, ts), "0"); + + T_time_to_seconds_and_nanoseconds(t, &s, &ns); + T_eq_u32(s, 0); + T_eq_u32(ns, 123456789); +} + +T_TEST_CASE(now) +{ + T_time_string ts; + T_time t0; + T_time t1; + + t0 = T_now(); + t1 = T_now(); + T_log(T_QUIET, "%s", T_time_to_string_ns(t1 - t0, ts)); +} + +T_TEST_CASE(tick) +{ + T_ticks t; + uint64_t i; + + t = T_tick(); + i = 0; + + do { + ++i; + } while (T_tick() == t); + + T_gt_u64(i, 0); +} + +T_TEST_CASE(time) +{ + T_time_string ts; + T_time t; + uint32_t s; + uint32_t ns; + + t = T_seconds_and_nanoseconds_to_time(1, 123456789); + T_eq_str(T_time_to_string_ns(t, ts), "1.123456789"); + T_eq_str(T_time_to_string_us(t, ts), "1.123456"); + T_eq_str(T_time_to_string_ms(t, ts), "1.123"); + T_eq_str(T_time_to_string_s(t, ts), "1"); + + t = T_seconds_and_nanoseconds_to_time(1, 0); + T_eq_str(T_time_to_string_ns(t, ts), "1.000000000"); + T_time_to_seconds_and_nanoseconds(t, &s, &ns); + T_eq_u32(s, 1); + T_eq_u32(ns, 0); + + t = T_seconds_and_nanoseconds_to_time(1, 1); + T_eq_str(T_time_to_string_ns(t, ts), "1.000000001"); + T_time_to_seconds_and_nanoseconds(t, &s, &ns); + T_eq_u32(s, 1); + T_eq_u32(ns, 1); + + t = T_seconds_and_nanoseconds_to_time(1, 2); + T_eq_str(T_time_to_string_ns(t, ts), "1.000000002"); + T_time_to_seconds_and_nanoseconds(t, &s, &ns); + T_eq_u32(s, 1); + T_eq_u32(ns, 2); + + t = T_seconds_and_nanoseconds_to_time(1, 3); + T_eq_str(T_time_to_string_ns(t, ts), "1.000000003"); + T_time_to_seconds_and_nanoseconds(t, &s, &ns); + T_eq_u32(s, 1); + T_eq_u32(ns, 3); + + t = T_seconds_and_nanoseconds_to_time(1, 4); + T_eq_str(T_time_to_string_ns(t, ts), "1.000000004"); + T_time_to_seconds_and_nanoseconds(t, &s, &ns); + T_eq_u32(s, 1); + T_eq_u32(ns, 4); + + t = T_seconds_and_nanoseconds_to_time(1, 5); + T_eq_str(T_time_to_string_ns(t, ts), "1.000000005"); + T_time_to_seconds_and_nanoseconds(t, &s, &ns); + T_eq_u32(s, 1); + T_eq_u32(ns, 5); + + t = T_seconds_and_nanoseconds_to_time(1, 6); + T_eq_str(T_time_to_string_ns(t, ts), "1.000000006"); + T_time_to_seconds_and_nanoseconds(t, &s, &ns); + T_eq_u32(s, 1); + T_eq_u32(ns, 6); + + t = T_seconds_and_nanoseconds_to_time(1, 7); + T_eq_str(T_time_to_string_ns(t, ts), "1.000000007"); + T_time_to_seconds_and_nanoseconds(t, &s, &ns); + T_eq_u32(s, 1); + T_eq_u32(ns, 7); + + t = T_seconds_and_nanoseconds_to_time(1, 8); + T_eq_str(T_time_to_string_ns(t, ts), "1.000000008"); + T_time_to_seconds_and_nanoseconds(t, &s, &ns); + T_eq_u32(s, 1); + T_eq_u32(ns, 8); + + t = T_seconds_and_nanoseconds_to_time(1, 9); + T_eq_str(T_time_to_string_ns(t, ts), "1.000000009"); + T_time_to_seconds_and_nanoseconds(t, &s, &ns); + T_eq_u32(s, 1); + T_eq_u32(ns, 9); + + t = T_seconds_and_nanoseconds_to_time(1, 10); + T_eq_str(T_time_to_string_ns(t, ts), "1.000000010"); + T_time_to_seconds_and_nanoseconds(t, &s, &ns); + T_eq_u32(s, 1); + T_eq_u32(ns, 10); + + t = T_seconds_and_nanoseconds_to_time(1, 999999999); + T_eq_str(T_time_to_string_ns(t, ts), "1.999999999"); + T_time_to_seconds_and_nanoseconds(t, &s, &ns); + T_eq_u32(s, 1); + T_eq_u32(ns, 999999999); +} + +T_TEST_CASE(ticks) +{ + T_time_string ts; + T_time t; + T_time r; + T_ticks k; + uint64_t f; + uint32_t s; + uint32_t ns; + uint32_t m; + size_t n; + + t = T_seconds_and_nanoseconds_to_time(1, 0); + f = T_time_to_ticks(t); + T_gt_u64(f, 0); + + r = T_ticks_to_time(1); + T_time_to_seconds_and_nanoseconds(r, &s, &ns); + T_eq_u32(s, 0); + T_ne_u32(ns, 0); + + n = 1; + m = 10; + + do { + if (ns / m == 0) { + break; + } + + ++n; + m *= 10; + } while (n < 10); + + n = 10 - n; + + t = T_seconds_and_nanoseconds_to_time(1, 123456789); + k = T_time_to_ticks(t); + + n += 2; + T_eq_nstr(T_ticks_to_string_ns(k, ts), "1.123456789", n); + T_eq_nstr(T_ticks_to_string_us(k, ts), "1.123456", n); + T_eq_nstr(T_ticks_to_string_ms(k, ts), "1.123", n); + T_eq_str(T_ticks_to_string_s(k, ts), "1"); +} + +T_TEST_CASE(begin_time) +{ + T_time_string ts; + T_time t0; + T_time t1; + T_time d; + + t1 = T_now(); + t0 = T_case_begin_time(); + d = t1 - t0; + T_log(T_QUIET, "time at test case begin %s", + T_time_to_string_ns(d, ts)); +} + +/* + * The license is at the end of the file to be able to use the test code and + * output in examples in the documentation. This is also the reason for the + * dual licensing. The license for RTEMS documentation is CC-BY-SA-4.0. + */ + +/* + * SPDX-License-Identifier: BSD-2-Clause OR CC-BY-SA-4.0 + * + * Copyright (C) 2018, 2019 embedded brains GmbH + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * ALTERNATIVELY, this software may be distributed under the terms of the + * Creative Commons Attribution-ShareAlike 4.0 International Public License as + * published by Creative Commons, PO Box 1866, Mountain View, CA 94042 + * (https://creativecommons.org/licenses/by-sa/4.0/legalcode). + */ diff --git a/testsuites/libtests/ttest01/test-verbosity.c b/testsuites/libtests/ttest01/test-verbosity.c new file mode 100644 index 0000000000..e4e8adf84f --- /dev/null +++ b/testsuites/libtests/ttest01/test-verbosity.c @@ -0,0 +1,55 @@ +#include + +T_TEST_CASE(verbosity_changes) +{ + T_verbosity verbosity; + + verbosity = T_set_verbosity(T_QUIET); + T_true(true, "quiet: check passes -> no output"); + T_true(false, "quiet: check fails -> no output"); + T_set_verbosity(T_NORMAL); + T_true(true, "normal: check passes -> no output"); + T_true(false, "normal: check fails -> with output"); + T_set_verbosity(T_VERBOSE); + T_true(true, "verbose: check passes -> with output"); + T_true(false, "verbose: check fails -> with output"); + T_set_verbosity(verbosity); +} + +/* + * The license is at the end of the file to be able to use the test code and + * output in examples in the documentation. This is also the reason for the + * dual licensing. The license for RTEMS documentation is CC-BY-SA-4.0. + */ + +/* + * SPDX-License-Identifier: BSD-2-Clause OR CC-BY-SA-4.0 + * + * Copyright (C) 2018, 2019 embedded brains GmbH + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * ALTERNATIVELY, this software may be distributed under the terms of the + * Creative Commons Attribution-ShareAlike 4.0 International Public License as + * published by Creative Commons, PO Box 1866, Mountain View, CA 94042 + * (https://creativecommons.org/licenses/by-sa/4.0/legalcode). + */ -- cgit v1.2.3