[PATCH 2/3] ttest01: Add more test cases
Sebastian Huber
sebastian.huber at embedded-brains.de
Tue Oct 1 13:20:02 UTC 2019
Update #3199.
---
testsuites/libtests/Makefile.am | 15 +
testsuites/libtests/ttest01/init.c | 54 +-
testsuites/libtests/ttest01/test-assert.c | 90 +
testsuites/libtests/ttest01/test-checks.c | 2914 +++++++++++++++++++++++++
testsuites/libtests/ttest01/test-destructor.c | 49 +
testsuites/libtests/ttest01/test-eno.c | 55 +
testsuites/libtests/ttest01/test-fixture.c | 91 +
testsuites/libtests/ttest01/test-leak.c | 165 ++
testsuites/libtests/ttest01/test-log.c | 41 +
testsuites/libtests/ttest01/test-malloc.c | 88 +
testsuites/libtests/ttest01/test-plan.c | 68 +
testsuites/libtests/ttest01/test-psx.c | 70 +
testsuites/libtests/ttest01/test-rtems.c | 104 +
testsuites/libtests/ttest01/test-simple.c | 48 +
testsuites/libtests/ttest01/test-step.c | 40 +
testsuites/libtests/ttest01/test-time.c | 223 ++
testsuites/libtests/ttest01/test-verbosity.c | 50 +
17 files changed, 4162 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 406961ca73..a668dda103 100644
--- a/testsuites/libtests/Makefile.am
+++ b/testsuites/libtests/Makefile.am
@@ -1513,7 +1513,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 <rtems.h>
#include <rtems/bspIo.h>
+#include <rtems/timecounter.h>
+#include <rtems/sysinit.h>
#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..9055d37194
--- /dev/null
+++ b/testsuites/libtests/ttest01/test-assert.c
@@ -0,0 +1,90 @@
+#include <t.h>
+
+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");
+}
+
+/*
+ * SPDX-License-Identifier: BSD-2-Clause
+ * SPDX-License-Identifier: 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..9d5b4da548
--- /dev/null
+++ b/testsuites/libtests/ttest01/test-checks.c
@@ -0,0 +1,2914 @@
+#include <t.h>
+
+#include <sys/types.h>
+
+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);
+}
+
+/*
+ * SPDX-License-Identifier: BSD-2-Clause
+ * SPDX-License-Identifier: 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..d1dd97c6d9
--- /dev/null
+++ b/testsuites/libtests/ttest01/test-destructor.c
@@ -0,0 +1,49 @@
+#include <t.h>
+
+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);
+}
+
+/*
+ * SPDX-License-Identifier: BSD-2-Clause
+ * SPDX-License-Identifier: 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..2c7948aa99
--- /dev/null
+++ b/testsuites/libtests/ttest01/test-eno.c
@@ -0,0 +1,55 @@
+#include <t.h>
+#include <errno.h>
+
+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);
+}
+
+/*
+ * SPDX-License-Identifier: BSD-2-Clause
+ * SPDX-License-Identifier: 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..087202c91e
--- /dev/null
+++ b/testsuites/libtests/ttest01/test-fixture.c
@@ -0,0 +1,91 @@
+#include <t.h>
+
+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");
+}
+
+/*
+ * SPDX-License-Identifier: BSD-2-Clause
+ * SPDX-License-Identifier: 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..9c1d97f7f9
--- /dev/null
+++ b/testsuites/libtests/ttest01/test-leak.c
@@ -0,0 +1,165 @@
+#include <t.h>
+
+#include <stdlib.h>
+
+#include <rtems.h>
+
+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 <sys/stat.h>
+#include <fcntl.h>
+#include <pthread.h>
+#include <string.h>
+
+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);
+}
+
+/*
+ * SPDX-License-Identifier: BSD-2-Clause
+ * SPDX-License-Identifier: 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..debfb53169
--- /dev/null
+++ b/testsuites/libtests/ttest01/test-log.c
@@ -0,0 +1,41 @@
+#include <t.h>
+
+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");
+}
+
+/*
+ * SPDX-License-Identifier: BSD-2-Clause
+ * SPDX-License-Identifier: 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..0e5585fed8
--- /dev/null
+++ b/testsuites/libtests/ttest01/test-malloc.c
@@ -0,0 +1,88 @@
+#include <t.h>
+
+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);
+}
+
+/*
+ * SPDX-License-Identifier: BSD-2-Clause
+ * SPDX-License-Identifier: 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..da06ff568e
--- /dev/null
+++ b/testsuites/libtests/ttest01/test-plan.c
@@ -0,0 +1,68 @@
+#include <t.h>
+
+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");
+}
+
+/*
+ * SPDX-License-Identifier: BSD-2-Clause
+ * SPDX-License-Identifier: 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..2eb45bb3b5
--- /dev/null
+++ b/testsuites/libtests/ttest01/test-psx.c
@@ -0,0 +1,70 @@
+#include <t.h>
+
+#include <sys/stat.h>
+#include <errno.h>
+
+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);
+}
+
+/*
+ * SPDX-License-Identifier: BSD-2-Clause
+ * SPDX-License-Identifier: 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..39d33285ff
--- /dev/null
+++ b/testsuites/libtests/ttest01/test-rtems.c
@@ -0,0 +1,104 @@
+#include <t.h>
+
+#include <rtems.h>
+
+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);
+}
+
+/*
+ * SPDX-License-Identifier: BSD-2-Clause
+ * SPDX-License-Identifier: 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..df689d6c7c
--- /dev/null
+++ b/testsuites/libtests/ttest01/test-simple.c
@@ -0,0 +1,48 @@
+#include <t.h>
+
+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");
+}
+
+/*
+ * SPDX-License-Identifier: BSD-2-Clause
+ * SPDX-License-Identifier: 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..bbe84123fc
--- /dev/null
+++ b/testsuites/libtests/ttest01/test-step.c
@@ -0,0 +1,40 @@
+#include <t.h>
+
+T_TEST_CASE(step)
+{
+ T_step_true(0, true, "all right");
+ T_step_true(2, true, "not the right step");
+}
+
+/*
+ * SPDX-License-Identifier: BSD-2-Clause
+ * SPDX-License-Identifier: 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..6ae44bac62
--- /dev/null
+++ b/testsuites/libtests/ttest01/test-time.c
@@ -0,0 +1,223 @@
+#include <t.h>
+
+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));
+}
+
+/*
+ * SPDX-License-Identifier: BSD-2-Clause
+ * SPDX-License-Identifier: 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..c3b0fdbb0c
--- /dev/null
+++ b/testsuites/libtests/ttest01/test-verbosity.c
@@ -0,0 +1,50 @@
+#include <t.h>
+
+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);
+}
+
+/*
+ * SPDX-License-Identifier: BSD-2-Clause
+ * SPDX-License-Identifier: 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).
+ */
--
2.16.4
More information about the devel
mailing list