Context Navigation

source: rtems/cpukit/include/t.h @ bbdf938

5

Last change on this file since bbdf938 was bbdf938, checked in by Andreas Dachsberger <andreas.dachsberger@…>, on 04/03/19 at 06:23:41

doxygen: Added RTEMS Test Framework to API

Update #3706.

Property mode set to 100644

File size: 83.0 KB

Line
1	/*
2	* SPDX-License-Identifier: BSD-2-Clause
3	*
4	* Copyright (C) 2018, 2019 embedded brains GmbH
5	*
6	* Redistribution and use in source and binary forms, with or without
7	* modification, are permitted provided that the following conditions
8	* are met:
9	* 1. Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.
11	* 2. Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.
14	*
15	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
16	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
19	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
20	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
21	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
22	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
23	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
24	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
25	* POSSIBILITY OF SUCH DAMAGE.
26	*/
27
28	#ifndef THE_T_TEST_FRAMEWORK_H
29	#define THE_T_TEST_FRAMEWORK_H
30
31	#include <stdarg.h>
32	#include <stdbool.h>
33	#include <stddef.h>
34	#include <stdint.h>
35	#include <string.h>
36
37	#ifdef __rtems__
38	#include <rtems/score/cpu.h>
39	#endif
40
41	#ifdef __cplusplus
42	extern "C" {
43	#endif /* __cplusplus */
44
45	/**
46	* @defgroup RTEMSTestFramework RTEMS Test Framework
47	*
48	* @ingroup RTEMSAPI
49	*
50	* @brief The RTEMS Test Framework helps you to write tests.
51	*
52	* @{
53	*/
54
55	typedef enum {
56	T_QUIET,
57	T_NORMAL,
58	T_VERBOSE
59	} T_verbosity;
60
61	typedef struct T_fixture {
62	void (setup)(void );
63	void (stop)(void );
64	void (teardown)(void );
65	void *initial_context;
66	} T_fixture;
67
68	#define T_ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0]))
69
70	/*
71	* The __FILE__ includes the full file path from the command line. Enable the
72	* build system to give a sorter file name via a command line define.
73	*/
74	#ifndef T_FILE_NAME
75	#define T_FILE_NAME __FILE__
76	#endif
77
78	/** @} */
79
80	/**
81	* @defgroup RTEMSTestFrameworkImpl RTEMS Test Framework Implementation
82	*
83	* @ingroup RTEMSTestFramework
84	*
85	* @brief Implementation details.
86	*
87	* @{
88	*/
89
90	typedef struct T_case_context {
91	const char *name;
92	void (*body)(void);
93	const T_fixture *fixture;
94	const struct T_case_context *next;
95	} T_case_context;
96
97	void T_case_register(T_case_context *);
98
99	#define T_CHECK_STOP 1U
100
101	#define T_CHECK_QUIET 2U
102
103	#define T_CHECK_STEP_FLAG 4U
104
105	#define T_CHECK_STEP_TO_FLAGS(step) ((unsigned int)(step) << 8)
106
107	#define T_CHECK_STEP_FROM_FLAGS(flags) ((flags) >> 8)
108
109	#define T_CHECK_STEP(step) (T_CHECK_STEP_TO_FLAGS(step) \| T_CHECK_STEP_FLAG)
110
111	typedef struct {
112	const char *file;
113	int line;
114	unsigned int flags;
115	} T_check_context;
116
117	typedef struct {
118	T_check_context base;
119	const char *msg;
120	} T_check_context_msg;
121
122	void T_check_true(bool, const T_check_context , const char , ...);
123
124	#define T_flags_true(a, flags, ...) \
125	{ \
126	static const T_check_context T_check_instance = { \
127	T_FILE_NAME, __LINE__, flags }; \
128	T_check_true(a, &T_check_instance, __VA_ARGS__); \
129	}
130
131	#define T_flags_eq(a, e, flags, ...) \
132	T_flags_true((a) == (e), flags, __VA_ARGS__)
133
134	#define T_flags_ne(a, e, flags, ...) \
135	T_flags_true((a) != (e), flags, __VA_ARGS__)
136
137	void T_check_eq_ptr(const void , const T_check_context_msg , const void *);
138
139	#define T_flags_eq_ptr(a, e, flags, sa, se) \
140	{ \
141	static const T_check_context_msg T_check_instance = { \
142	{ T_FILE_NAME, __LINE__, flags }, sa " == " se }; \
143	T_check_eq_ptr(a, &T_check_instance, e); \
144	}
145
146	void T_check_ne_ptr(const void , const T_check_context_msg , const void *);
147
148	#define T_flags_ne_ptr(a, e, flags, sa, se) \
149	{ \
150	static const T_check_context_msg T_check_instance = { \
151	{ T_FILE_NAME, __LINE__, flags }, sa " != " se }; \
152	T_check_ne_ptr(a, &T_check_instance, e); \
153	}
154
155	void T_check_null(const void , const T_check_context_msg );
156
157	#define T_flags_null(a, flags, sa) \
158	{ \
159	static const T_check_context_msg T_check_instance = { \
160	{ T_FILE_NAME, __LINE__, flags }, sa }; \
161	T_check_null(a, &T_check_instance); \
162	}
163
164	void T_check_not_null(const void , const T_check_context_msg );
165
166	#define T_flags_not_null(a, flags, sa) \
167	{ \
168	static const T_check_context_msg T_check_instance = { \
169	{ T_FILE_NAME, __LINE__, flags }, sa }; \
170	T_check_not_null(a, &T_check_instance); \
171	}
172
173	void T_check_eq_mem(const void , const T_check_context_msg , const void *,
174	size_t);
175
176	#define T_flags_eq_mem(a, e, n, flags, sa, se, sn) \
177	{ \
178	static const T_check_context_msg T_check_instance = { \
179	{ T_FILE_NAME, __LINE__, flags }, \
180	"memcmp(" sa ", " se ", " sn ") == 0" }; \
181	T_check_eq_mem(a, &T_check_instance, e, n); \
182	}
183
184	void T_check_ne_mem(const void , const T_check_context_msg , const void *,
185	size_t);
186
187	#define T_flags_ne_mem(a, e, n, flags, sa, se, sn) \
188	{ \
189	static const T_check_context_msg T_check_instance = { \
190	{ T_FILE_NAME, __LINE__, flags }, \
191	"memcmp(" sa ", " se ", " sn ") != 0" }; \
192	T_check_ne_mem(a, &T_check_instance, e, n); \
193	}
194
195	void T_check_eq_str(const char , const T_check_context , const char *);
196
197	#define T_flags_eq_str(a, e, flags) \
198	{ \
199	static const T_check_context T_check_instance = { \
200	T_FILE_NAME, __LINE__, flags }; \
201	T_check_eq_str(a, &T_check_instance, e); \
202	}
203
204	void T_check_ne_str(const char , const T_check_context , const char *);
205
206	#define T_flags_ne_str(a, e, flags) \
207	{ \
208	static const T_check_context T_check_instance = { \
209	T_FILE_NAME, __LINE__, flags }; \
210	T_check_ne_str(a, &T_check_instance, e); \
211	}
212
213	void T_check_eq_nstr(const char , const T_check_context , const char *,
214	size_t);
215
216	#define T_flags_eq_nstr(a, e, n, flags) \
217	{ \
218	static const T_check_context T_check_instance = { \
219	T_FILE_NAME, __LINE__, flags }; \
220	T_check_eq_nstr(a, &T_check_instance, e, n); \
221	}
222
223	void T_check_ne_nstr(const char , const T_check_context , const char *,
224	size_t);
225
226	#define T_flags_ne_nstr(a, e, n, flags) \
227	{ \
228	static const T_check_context T_check_instance = { \
229	T_FILE_NAME, __LINE__, flags }; \
230	T_check_ne_nstr(a, &T_check_instance, e, n); \
231	}
232
233	void T_check_eq_char(char, const T_check_context *, char);
234
235	#define T_flags_eq_char(a, e, flags) \
236	{ \
237	static const T_check_context T_check_instance = { \
238	T_FILE_NAME, __LINE__, flags }; \
239	T_check_eq_char(a, &T_check_instance, e); \
240	}
241
242	void T_check_ne_char(char, const T_check_context *, char);
243
244	#define T_flags_ne_char(a, e, flags) \
245	{ \
246	static const T_check_context T_check_instance = { \
247	T_FILE_NAME, __LINE__, flags }; \
248	T_check_ne_char(a, &T_check_instance, e); \
249	}
250
251	void T_check_eq_int(int, const T_check_context *, int);
252
253	#define T_flags_eq_int(a, e, flags) \
254	{ \
255	static const T_check_context T_check_instance = { \
256	T_FILE_NAME, __LINE__, flags }; \
257	T_check_eq_int(a, &T_check_instance, e); \
258	}
259
260	void T_check_ne_int(int, const T_check_context *, int);
261
262	#define T_flags_ne_int(a, e, flags) \
263	{ \
264	static const T_check_context T_check_instance = { \
265	T_FILE_NAME, __LINE__, flags }; \
266	T_check_ne_int(a, &T_check_instance, e); \
267	}
268
269	void T_check_ge_int(int, const T_check_context *, int);
270
271	#define T_flags_ge_int(a, e, flags) \
272	{ \
273	static const T_check_context T_check_instance = { \
274	T_FILE_NAME, __LINE__, flags }; \
275	T_check_ge_int(a, &T_check_instance, e); \
276	}
277
278	void T_check_gt_int(int, const T_check_context *, int);
279
280	#define T_flags_gt_int(a, e, flags) \
281	{ \
282	static const T_check_context T_check_instance = { \
283	T_FILE_NAME, __LINE__, flags }; \
284	T_check_gt_int(a, &T_check_instance, e); \
285	}
286
287	void T_check_le_int(int, const T_check_context *, int);
288
289	#define T_flags_le_int(a, e, flags) \
290	{ \
291	static const T_check_context T_check_instance = { \
292	T_FILE_NAME, __LINE__, flags }; \
293	T_check_le_int(a, &T_check_instance, e); \
294	}
295
296	void T_check_lt_int(int, const T_check_context *, int);
297
298	#define T_flags_lt_int(a, e, flags) \
299	{ \
300	static const T_check_context T_check_instance = { \
301	T_FILE_NAME, __LINE__, flags }; \
302	T_check_lt_int(a, &T_check_instance, e); \
303	}
304
305	void T_check_eq_uint(unsigned int, const T_check_context *, unsigned int);
306
307	#define T_flags_eq_uint(a, e, flags) \
308	{ \
309	static const T_check_context T_check_instance = { \
310	T_FILE_NAME, __LINE__, flags }; \
311	T_check_eq_uint(a, &T_check_instance, e); \
312	}
313
314	void T_check_ne_uint(unsigned int, const T_check_context *, unsigned int);
315
316	#define T_flags_ne_uint(a, e, flags) \
317	{ \
318	static const T_check_context T_check_instance = { \
319	T_FILE_NAME, __LINE__, flags }; \
320	T_check_ne_uint(a, &T_check_instance, e); \
321	}
322
323	void T_check_ge_uint(unsigned int, const T_check_context *, unsigned int);
324
325	#define T_flags_ge_uint(a, e, flags) \
326	{ \
327	static const T_check_context T_check_instance = { \
328	T_FILE_NAME, __LINE__, flags }; \
329	T_check_ge_uint(a, &T_check_instance, e); \
330	}
331
332	void T_check_gt_uint(unsigned int, const T_check_context *, unsigned int);
333
334	#define T_flags_gt_uint(a, e, flags) \
335	{ \
336	static const T_check_context T_check_instance = { \
337	T_FILE_NAME, __LINE__, flags }; \
338	T_check_gt_uint(a, &T_check_instance, e); \
339	}
340
341	void T_check_le_uint(unsigned int, const T_check_context *, unsigned int);
342
343	#define T_flags_le_uint(a, e, flags) \
344	{ \
345	static const T_check_context T_check_instance = { \
346	T_FILE_NAME, __LINE__, flags }; \
347	T_check_le_uint(a, &T_check_instance, e); \
348	}
349
350	void T_check_lt_uint(unsigned int, const T_check_context *, unsigned int);
351
352	#define T_flags_lt_uint(a, e, flags) \
353	{ \
354	static const T_check_context T_check_instance = { \
355	T_FILE_NAME, __LINE__, flags }; \
356	T_check_lt_uint(a, &T_check_instance, e); \
357	}
358
359	void T_check_eq_long(long, const T_check_context *, long);
360
361	#define T_flags_eq_long(a, e, flags) \
362	{ \
363	static const T_check_context T_check_instance = { \
364	T_FILE_NAME, __LINE__, flags }; \
365	T_check_eq_long(a, &T_check_instance, e); \
366	}
367
368	void T_check_ne_long(long, const T_check_context *, long);
369
370	#define T_flags_ne_long(a, e, flags) \
371	{ \
372	static const T_check_context T_check_instance = { \
373	T_FILE_NAME, __LINE__, flags }; \
374	T_check_ne_long(a, &T_check_instance, e); \
375	}
376
377	void T_check_ge_long(long, const T_check_context *, long);
378
379	#define T_flags_ge_long(a, e, flags) \
380	{ \
381	static const T_check_context T_check_instance = { \
382	T_FILE_NAME, __LINE__, flags }; \
383	T_check_ge_long(a, &T_check_instance, e); \
384	}
385
386	void T_check_gt_long(long, const T_check_context *, long);
387
388	#define T_flags_gt_long(a, e, flags) \
389	{ \
390	static const T_check_context T_check_instance = { \
391	T_FILE_NAME, __LINE__, flags }; \
392	T_check_gt_long(a, &T_check_instance, e); \
393	}
394
395	void T_check_le_long(long, const T_check_context *, long);
396
397	#define T_flags_le_long(a, e, flags) \
398	{ \
399	static const T_check_context T_check_instance = { \
400	T_FILE_NAME, __LINE__, flags }; \
401	T_check_le_long(a, &T_check_instance, e); \
402	}
403
404	void T_check_lt_long(long, const T_check_context *, long);
405
406	#define T_flags_lt_long(a, e, flags) \
407	{ \
408	static const T_check_context T_check_instance = { \
409	T_FILE_NAME, __LINE__, flags }; \
410	T_check_lt_long(a, &T_check_instance, e); \
411	}
412
413	void T_check_eq_ulong(unsigned long, const T_check_context *, unsigned long);
414
415	#define T_flags_eq_ulong(a, e, flags) \
416	{ \
417	static const T_check_context T_check_instance = { \
418	T_FILE_NAME, __LINE__, flags }; \
419	T_check_eq_ulong(a, &T_check_instance, e); \
420	}
421
422	void T_check_ne_ulong(unsigned long, const T_check_context *, unsigned long);
423
424	#define T_flags_ne_ulong(a, e, flags) \
425	{ \
426	static const T_check_context T_check_instance = { \
427	T_FILE_NAME, __LINE__, flags }; \
428	T_check_ne_ulong(a, &T_check_instance, e); \
429	}
430
431	void T_check_ge_ulong(unsigned long, const T_check_context *, unsigned long);
432
433	#define T_flags_ge_ulong(a, e, flags) \
434	{ \
435	static const T_check_context T_check_instance = { \
436	T_FILE_NAME, __LINE__, flags }; \
437	T_check_ge_ulong(a, &T_check_instance, e); \
438	}
439
440	void T_check_gt_ulong(unsigned long, const T_check_context *, unsigned long);
441
442	#define T_flags_gt_ulong(a, e, flags) \
443	{ \
444	static const T_check_context T_check_instance = { \
445	T_FILE_NAME, __LINE__, flags }; \
446	T_check_gt_ulong(a, &T_check_instance, e); \
447	}
448
449	void T_check_le_ulong(unsigned long, const T_check_context *, unsigned long);
450
451	#define T_flags_le_ulong(a, e, flags) \
452	{ \
453	static const T_check_context T_check_instance = { \
454	T_FILE_NAME, __LINE__, flags }; \
455	T_check_le_ulong(a, &T_check_instance, e); \
456	}
457
458	void T_check_lt_ulong(unsigned long, const T_check_context *, unsigned long);
459
460	#define T_flags_lt_ulong(a, e, flags) \
461	{ \
462	static const T_check_context T_check_instance = { \
463	T_FILE_NAME, __LINE__, flags }; \
464	T_check_lt_ulong(a, &T_check_instance, e); \
465	}
466
467	void T_check_eq_ll(long long, const T_check_context *, long long);
468
469	#define T_flags_eq_ll(a, e, flags) \
470	{ \
471	static const T_check_context T_check_instance = { \
472	T_FILE_NAME, __LINE__, flags }; \
473	T_check_eq_ll(a, &T_check_instance, e); \
474	}
475
476	void T_check_ne_ll(long long, const T_check_context *, long long);
477
478	#define T_flags_ne_ll(a, e, flags) \
479	{ \
480	static const T_check_context T_check_instance = { \
481	T_FILE_NAME, __LINE__, flags }; \
482	T_check_ne_ll(a, &T_check_instance, e); \
483	}
484
485	void T_check_ge_ll(long long, const T_check_context *, long long);
486
487	#define T_flags_ge_ll(a, e, flags) \
488	{ \
489	static const T_check_context T_check_instance = { \
490	T_FILE_NAME, __LINE__, flags }; \
491	T_check_ge_ll(a, &T_check_instance, e); \
492	}
493
494	void T_check_gt_ll(long long, const T_check_context *, long long);
495
496	#define T_flags_gt_ll(a, e, flags) \
497	{ \
498	static const T_check_context T_check_instance = { \
499	T_FILE_NAME, __LINE__, flags }; \
500	T_check_gt_ll(a, &T_check_instance, e); \
501	}
502
503	void T_check_le_ll(long long, const T_check_context *, long long);
504
505	#define T_flags_le_ll(a, e, flags) \
506	{ \
507	static const T_check_context T_check_instance = { \
508	T_FILE_NAME, __LINE__, flags }; \
509	T_check_le_ll(a, &T_check_instance, e); \
510	}
511
512	void T_check_lt_ll(long long, const T_check_context *, long long);
513
514	#define T_flags_lt_ll(a, e, flags) \
515	{ \
516	static const T_check_context T_check_instance = { \
517	T_FILE_NAME, __LINE__, flags }; \
518	T_check_lt_ll(a, &T_check_instance, e); \
519	}
520
521	void T_check_eq_ull(unsigned long long, const T_check_context *,
522	unsigned long long);
523
524	#define T_flags_eq_ull(a, e, flags) \
525	{ \
526	static const T_check_context T_check_instance = { \
527	T_FILE_NAME, __LINE__, flags }; \
528	T_check_eq_ull(a, &T_check_instance, e); \
529	}
530
531	void T_check_ne_ull(unsigned long long, const T_check_context *,
532	unsigned long long);
533
534	#define T_flags_ne_ull(a, e, flags) \
535	{ \
536	static const T_check_context T_check_instance = { \
537	T_FILE_NAME, __LINE__, flags }; \
538	T_check_ne_ull(a, &T_check_instance, e); \
539	}
540
541	void T_check_ge_ull(unsigned long long, const T_check_context *,
542	unsigned long long);
543
544	#define T_flags_ge_ull(a, e, flags) \
545	{ \
546	static const T_check_context T_check_instance = { \
547	T_FILE_NAME, __LINE__, flags }; \
548	T_check_ge_ull(a, &T_check_instance, e); \
549	}
550
551	void T_check_gt_ull(unsigned long long, const T_check_context *,
552	unsigned long long);
553
554	#define T_flags_gt_ull(a, e, flags) \
555	{ \
556	static const T_check_context T_check_instance = { \
557	T_FILE_NAME, __LINE__, flags }; \
558	T_check_gt_ull(a, &T_check_instance, e); \
559	}
560
561	void T_check_le_ull(unsigned long long, const T_check_context *,
562	unsigned long long);
563
564	#define T_flags_le_ull(a, e, flags) \
565	{ \
566	static const T_check_context T_check_instance = { \
567	T_FILE_NAME, __LINE__, flags }; \
568	T_check_le_ull(a, &T_check_instance, e); \
569	}
570
571	void T_check_lt_ull(unsigned long long, const T_check_context *,
572	unsigned long long);
573
574	#define T_flags_lt_ull(a, e, flags) \
575	{ \
576	static const T_check_context T_check_instance = { \
577	T_FILE_NAME, __LINE__, flags }; \
578	T_check_lt_ull(a, &T_check_instance, e); \
579	}
580
581	void T_check_eno(int, const T_check_context *, int);
582
583	#define T_flags_eno(a, e, flags) \
584	{ \
585	static const T_check_context T_check_instance = { \
586	T_FILE_NAME, __LINE__, flags }; \
587	T_check_eno(a, &T_check_instance, e); \
588	}
589
590	void T_check_eno_success(int, const T_check_context *);
591
592	#define T_flags_eno_success(a, flags) \
593	{ \
594	static const T_check_context T_check_instance = { \
595	T_FILE_NAME, __LINE__, flags }; \
596	T_check_eno_success(a, &T_check_instance); \
597	}
598
599	void T_check_psx_error(int, const T_check_context *, int);
600
601	#define T_flags_psx_error(a, eno, flags) \
602	{ \
603	static const T_check_context T_check_instance = { \
604	T_FILE_NAME, __LINE__, flags }; \
605	T_check_psx_error(a, &T_check_instance, eno); \
606	}
607
608	void T_check_psx_success(int, const T_check_context *);
609
610	#define T_flags_psx_success(a, flags) \
611	{ \
612	static const T_check_context T_check_instance = { \
613	T_FILE_NAME, __LINE__, flags }; \
614	T_check_psx_success(a, &T_check_instance); \
615	}
616
617	/** @} */
618
619	int T_printf(char const *, ...);
620
621	int T_vprintf(char const *, va_list);
622
623	int T_snprintf(char , size_t, const char , ...);
624
625	void T_log(T_verbosity, char const *, ...);
626
627	const char *T_case_name(void);
628
629	T_verbosity T_set_verbosity(T_verbosity);
630
631	/**
632	* @defgroup RTEMSTestFrameworkChecksBool Boolean Checks
633	*
634	* @ingroup RTEMSTestFramework
635	*
636	* @brief Checks for boolean expressions.
637	*
638	* @{
639	*/
640
641	#define T_true(a, ...) T_flags_true(a, 0, __VA_ARGS__)
642	#define T_assert_true(a, ...) T_flags_true(a, T_CHECK_STOP, __VA_ARGS__)
643	#define T_quiet_true(a, ...) T_flags_true(a, T_CHECK_QUIET, __VA_ARGS__)
644	#define T_step_true(s, a, ...) T_flags_true(a, T_CHECK_STEP(s), __VA_ARGS__)
645	#define T_step_assert_true(s, a, ...) \
646	T_flags_true(a, T_CHECK_STEP(s) \| T_CHECK_STOP, __VA_ARGS__)
647
648	#define T_false(a, ...) T_flags_true(!(a), 0, __VA_ARGS__)
649	#define T_assert_false(a, ...) T_flags_true(!(a), T_CHECK_STOP, __VA_ARGS__)
650	#define T_quiet_false(a, ...) T_flags_true(!(a), T_CHECK_QUIET, __VA_ARGS__)
651	#define T_step_false(s, a, ...) T_flags_true(!(a), T_CHECK_STEP(s), __VA_ARGS__)
652	#define T_step_assert_false(s, a, ...) \
653	T_flags_true(!(a), T_CHECK_STEP(s) \| T_CHECK_STOP, __VA_ARGS__)
654
655	/** @} */
656
657	/**
658	* @defgroup RTEMSTestFrameworkChecksGeneric Generic Checks
659	*
660	* @ingroup RTEMSTestFramework
661	*
662	* @brief Checks for data types with an equality or inequality operator.
663	*
664	* @{
665	*/
666
667	#define T_eq(a, e, ...) T_flags_eq(a, e, 0, __VA_ARGS__)
668	#define T_assert_eq(a, e, ...) T_flags_eq(a, e, T_CHECK_STOP, __VA_ARGS__)
669	#define T_quiet_eq(a, e, ...) T_flags_eq(a, e, T_CHECK_QUIET, __VA_ARGS__)
670	#define T_step_eq(s, a, e, ...) T_flags_eq(a, e, T_CHECK_STEP(s), __VA_ARGS__)
671	#define T_step_assert_eq(s, a, e, ...) \
672	T_flags_eq(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP, __VA_ARGS__)
673
674	#define T_ne(a, e, ...) T_flags_ne(a, e, 0, __VA_ARGS__)
675	#define T_assert_ne(a, e, ...) T_flags_ne(a, e, T_CHECK_STOP, __VA_ARGS__)
676	#define T_quiet_ne(a, e, ...) T_flags_ne(a, e, T_CHECK_QUIET, __VA_ARGS__)
677	#define T_step_ne(s, a, e, ...) T_flags_ne(a, e, T_CHECK_STEP(s), __VA_ARGS__)
678	#define T_step_assert_ne(s, a, e, ...) \
679	T_flags_ne(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP, __VA_ARGS__)
680
681	/** @} */
682
683	/**
684	* @defgroup RTEMSTestFrameworkChecksPointer Pointer Checks
685	*
686	* @ingroup RTEMSTestFramework
687	*
688	* @brief Checks for pointers.
689	*
690	* @{
691	*/
692
693	#define T_eq_ptr(a, e) T_flags_eq_ptr(a, e, 0, #a, #e)
694	#define T_assert_eq_ptr(a, e) T_flags_eq_ptr(a, e, T_CHECK_STOP, #a, #e)
695	#define T_quiet_eq_ptr(a, e) T_flags_eq_ptr(a, e, T_CHECK_QUIET, #a, #e)
696	#define T_step_eq_ptr(s, a, e) T_flags_eq_ptr(a, e, T_CHECK_STEP(s), #a, #e)
697	#define T_step_assert_eq_ptr(s, a, e) \
698	T_flags_eq_ptr(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP, #a, #e)
699
700	#define T_ne_ptr(a, e) T_flags_ne_ptr(a, e, 0, #a, #e)
701	#define T_assert_ne_ptr(a, e) T_flags_ne_ptr(a, e, T_CHECK_STOP, #a, #e)
702	#define T_quiet_ne_ptr(a, e) T_flags_ne_ptr(a, e, T_CHECK_QUIET, #a, #e)
703	#define T_step_ne_ptr(s, a, e) T_flags_ne_ptr(a, e, T_CHECK_STEP(s), #a, #e)
704	#define T_step_assert_ne_ptr(s, a, e) \
705	T_flags_ne_ptr(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP, #a, #e)
706
707	#define T_null(a) T_flags_null(a, 0, #a)
708	#define T_assert_null(a) T_flags_null(a, T_CHECK_STOP, #a)
709	#define T_quiet_null(a) T_flags_null(a, T_CHECK_QUIET, #a)
710	#define T_step_null(s, a) T_flags_null(a, T_CHECK_STEP(s), #a)
711	#define T_step_assert_null(s, a) \
712	T_flags_null(a, T_CHECK_STEP(s) \| T_CHECK_STOP, #a)
713
714	#define T_not_null(a) T_flags_not_null(a, 0, #a)
715	#define T_assert_not_null(a) T_flags_not_null(a, T_CHECK_STOP, #a)
716	#define T_quiet_not_null(a) T_flags_not_null(a, T_CHECK_QUIET, #a)
717	#define T_step_not_null(s, a) T_flags_not_null(a, T_CHECK_STEP(s), #a)
718	#define T_step_assert_not_null(s, a) \
719	T_flags_not_null(a, T_CHECK_STEP(s) \| T_CHECK_STOP, #a)
720
721	/** @} */
722
723	/**
724	* @defgroup RTEMSTestFrameworkChecksMemStr Memory Area Checks
725	*
726	* @ingroup RTEMSTestFramework
727	*
728	* @brief Checks for memory areas.
729	*
730	* @{
731	*/
732
733	#define T_eq_mem(a, e, n) T_flags_eq_mem(a, e, n, 0, #a, #e, #n)
734	#define T_assert_eq_mem(a, e, n) \
735	T_flags_eq_mem(a, e, n, T_CHECK_STOP, #a, #e, #n)
736	#define T_quiet_eq_mem(a, e, n) \
737	T_flags_eq_mem(a, e, n, T_CHECK_QUIET, #a, #e, #n)
738	#define T_step_eq_mem(s, a, e, n) \
739	T_flags_eq_mem(a, e, n, T_CHECK_STEP(s), #a, #e, #n)
740	#define T_step_assert_eq_mem(s, a, e, n) \
741	T_flags_eq_mem(a, e, n, T_CHECK_STEP(s) \| T_CHECK_STOP, #a, #e, #n)
742
743	#define T_ne_mem(a, e, n) T_flags_ne_mem(a, e, n, 0, #a, #e, #n)
744	#define T_assert_ne_mem(a, e, n) \
745	T_flags_ne_mem(a, e, n, T_CHECK_STOP, #a, #e, #n)
746	#define T_quiet_ne_mem(a, e, n) \
747	T_flags_ne_mem(a, e, n, T_CHECK_QUIET, #a, #e, #n)
748	#define T_step_ne_mem(s, a, e, n) \
749	T_flags_ne_mem(a, e, n, T_CHECK_STEP(s), #a, #e, #n)
750	#define T_step_assert_ne_mem(s, a, e, n) \
751	T_flags_ne_mem(a, e, n, T_CHECK_STEP(s) \| T_CHECK_STOP, #a, #e, #n)
752
753	/** @} */
754
755	/**
756	* @defgroup RTEMSTestFrameworkChecksStr String Checks
757	*
758	* @ingroup RTEMSTestFramework
759	*
760	* @brief Checks for strings.
761	*
762	* @{
763	*/
764
765
766	#define T_eq_str(a, e) T_flags_eq_str(a, e, 0)
767	#define T_assert_eq_str(a, e) T_flags_eq_str(a, e, T_CHECK_STOP)
768	#define T_quiet_eq_str(a, e) T_flags_eq_str(a, e, T_CHECK_QUIET)
769	#define T_step_eq_str(s, a, e) T_flags_eq_str(a, e, T_CHECK_STEP(s))
770	#define T_step_assert_eq_str(s, a, e) \
771	T_flags_eq_str(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
772
773	#define T_ne_str(a, e) T_flags_ne_str(a, e, 0)
774	#define T_assert_ne_str(a, e) T_flags_ne_str(a, e, T_CHECK_STOP)
775	#define T_quiet_ne_str(a, e) T_flags_ne_str(a, e, T_CHECK_QUIET)
776	#define T_step_ne_str(s, a, e) T_flags_ne_str(a, e, T_CHECK_STEP(s))
777	#define T_step_assert_ne_str(s, a, e) \
778	T_flags_ne_str(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
779
780	#define T_eq_nstr(a, e, n) T_flags_eq_nstr(a, e, n, 0)
781	#define T_assert_eq_nstr(a, e, n) T_flags_eq_nstr(a, e, n, T_CHECK_STOP)
782	#define T_quiet_eq_nstr(a, e, n) T_flags_eq_nstr(a, e, n, T_CHECK_QUIET)
783	#define T_step_eq_nstr(s, a, e, n) T_flags_eq_nstr(a, e, n, T_CHECK_STEP(s))
784	#define T_step_assert_eq_nstr(s, a, e, n) \
785	T_flags_eq_nstr(a, e, n, T_CHECK_STEP(s) \| T_CHECK_STOP)
786
787	#define T_ne_nstr(a, e, n) T_flags_ne_nstr(a, e, n, 0)
788	#define T_assert_ne_nstr(a, e, n) T_flags_ne_nstr(a, e, n, T_CHECK_STOP)
789	#define T_quiet_ne_nstr(a, e, n) T_flags_ne_nstr(a, e, n, T_CHECK_QUIET)
790	#define T_step_ne_nstr(s, a, e, n) T_flags_ne_nstr(a, e, n, T_CHECK_STEP(s))
791	#define T_step_assert_ne_nstr(s, a, e, n) \
792	T_flags_ne_nstr(a, e, n, T_CHECK_STEP(s) \| T_CHECK_STOP)
793
794	/** @} */
795
796	/**
797	* @defgroup RTEMSTestFrameworkChecksChar Character Checks
798	*
799	* @ingroup RTEMSTestFramework
800	*
801	* @brief Checks for characters (char).
802	*
803	* @{
804	*/
805
806	#define T_eq_char(a, e) T_flags_eq_char(a, e, 0)
807	#define T_assert_eq_char(a, e) T_flags_eq_char(a, e, T_CHECK_STOP)
808	#define T_quiet_eq_char(a, e) T_flags_eq_char(a, e, T_CHECK_QUIET)
809	#define T_step_eq_char(s, a, e) T_flags_eq_char(a, e, T_CHECK_STEP(s))
810	#define T_step_assert_eq_char(s, a, e) \
811	T_flags_eq_char(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
812
813	#define T_ne_char(a, e) T_flags_ne_char(a, e, 0)
814	#define T_assert_ne_char(a, e) T_flags_ne_char(a, e, T_CHECK_STOP)
815	#define T_quiet_ne_char(a, e) T_flags_ne_char(a, e, T_CHECK_QUIET)
816	#define T_step_ne_char(s, a, e) T_flags_ne_char(a, e, T_CHECK_STEP(s))
817	#define T_step_assert_ne_char(s, a, e) \
818	T_flags_ne_char(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
819
820	/** @} */
821
822	/**
823	* @defgroup RTEMSTestFrameworkChecksSChar Signed Character Checks
824	*
825	* @ingroup RTEMSTestFramework
826	*
827	* @brief Checks for signed characters (signed char).
828	*
829	* @{
830	*/
831
832	#define T_eq_schar(a, e) T_flags_eq_int(a, e, 0)
833	#define T_assert_eq_schar(a, e) T_flags_eq_int(a, e, T_CHECK_STOP)
834	#define T_quiet_eq_schar(a, e) T_flags_eq_int(a, e, T_CHECK_QUIET)
835	#define T_step_eq_schar(s, a, e) T_flags_eq_int(a, e, T_CHECK_STEP(s))
836	#define T_step_assert_eq_schar(s, a, e) \
837	T_flags_eq_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
838
839	#define T_ne_schar(a, e) T_flags_ne_int(a, e, 0)
840	#define T_assert_ne_schar(a, e) T_flags_ne_int(a, e, T_CHECK_STOP)
841	#define T_quiet_ne_schar(a, e) T_flags_ne_int(a, e, T_CHECK_QUIET)
842	#define T_step_ne_schar(s, a, e) T_flags_ne_int(a, e, T_CHECK_STEP(s))
843	#define T_step_assert_ne_schar(s, a, e) \
844	T_flags_ne_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
845
846	#define T_ge_schar(a, e) T_flags_ge_int(a, e, 0)
847	#define T_assert_ge_schar(a, e) T_flags_ge_int(a, e, T_CHECK_STOP)
848	#define T_quiet_ge_schar(a, e) T_flags_ge_int(a, e, T_CHECK_QUIET)
849	#define T_step_ge_schar(s, a, e) T_flags_ge_int(a, e, T_CHECK_STEP(s))
850	#define T_step_assert_ge_schar(s, a, e) \
851	T_flags_ge_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
852
853	#define T_gt_schar(a, e) T_flags_gt_int(a, e, 0)
854	#define T_assert_gt_schar(a, e) T_flags_gt_int(a, e, T_CHECK_STOP)
855	#define T_quiet_gt_schar(a, e) T_flags_gt_int(a, e, T_CHECK_QUIET)
856	#define T_step_gt_schar(s, a, e) T_flags_gt_int(a, e, T_CHECK_STEP(s))
857	#define T_step_assert_gt_schar(s, a, e) \
858	T_flags_gt_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
859
860	#define T_le_schar(a, e) T_flags_le_int(a, e, 0)
861	#define T_assert_le_schar(a, e) T_flags_le_int(a, e, T_CHECK_STOP)
862	#define T_quiet_le_schar(a, e) T_flags_le_int(a, e, T_CHECK_QUIET)
863	#define T_step_le_schar(s, a, e) T_flags_le_int(a, e, T_CHECK_STEP(s))
864	#define T_step_assert_le_schar(s, a, e) \
865	T_flags_le_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
866
867	#define T_lt_schar(a, e) T_flags_lt_int(a, e, 0)
868	#define T_assert_lt_schar(a, e) T_flags_lt_int(a, e, T_CHECK_STOP)
869	#define T_quiet_lt_schar(a, e) T_flags_lt_int(a, e, T_CHECK_QUIET)
870	#define T_step_lt_schar(s, a, e) T_flags_lt_int(a, e, T_CHECK_STEP(s))
871	#define T_step_assert_lt_schar(s, a, e) \
872	T_flags_lt_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
873
874	/** @} */
875
876	/**
877	* @defgroup RTEMSTestFrameworkChecksUChar Unsigned Character Checks
878	*
879	* @ingroup RTEMSTestFramework
880	*
881	* @brief Checks for unsigned characters (unsigned char).
882	*
883	* @{
884	*/
885
886	#define T_eq_uchar(a, e) T_flags_eq_uint(a, e, 0)
887	#define T_assert_eq_uchar(a, e) T_flags_eq_uint(a, e, T_CHECK_STOP)
888	#define T_quiet_eq_uchar(a, e) T_flags_eq_uint(a, e, T_CHECK_QUIET)
889	#define T_step_eq_uchar(s, a, e) T_flags_eq_uint(a, e, T_CHECK_STEP(s))
890	#define T_step_assert_eq_uchar(s, a, e) \
891	T_flags_eq_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
892
893	#define T_ne_uchar(a, e) T_flags_ne_uint(a, e, 0)
894	#define T_assert_ne_uchar(a, e) T_flags_ne_uint(a, e, T_CHECK_STOP)
895	#define T_quiet_ne_uchar(a, e) T_flags_ne_uint(a, e, T_CHECK_QUIET)
896	#define T_step_ne_uchar(s, a, e) T_flags_ne_uint(a, e, T_CHECK_STEP(s))
897	#define T_step_assert_ne_uchar(s, a, e) \
898	T_flags_ne_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
899
900	#define T_ge_uchar(a, e) T_flags_ge_uint(a, e, 0)
901	#define T_assert_ge_uchar(a, e) T_flags_ge_uint(a, e, T_CHECK_STOP)
902	#define T_quiet_ge_uchar(a, e) T_flags_ge_uint(a, e, T_CHECK_QUIET)
903	#define T_step_ge_uchar(s, a, e) T_flags_ge_uint(a, e, T_CHECK_STEP(s))
904	#define T_step_assert_ge_uchar(s, a, e) \
905	T_flags_ge_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
906
907	#define T_gt_uchar(a, e) T_flags_gt_uint(a, e, 0)
908	#define T_assert_gt_uchar(a, e) T_flags_gt_uint(a, e, T_CHECK_STOP)
909	#define T_quiet_gt_uchar(a, e) T_flags_gt_uint(a, e, T_CHECK_QUIET)
910	#define T_step_gt_uchar(s, a, e) T_flags_gt_uint(a, e, T_CHECK_STEP(s))
911	#define T_step_assert_gt_uchar(s, a, e) \
912	T_flags_gt_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
913
914	#define T_le_uchar(a, e) T_flags_le_uint(a, e, 0)
915	#define T_assert_le_uchar(a, e) T_flags_le_uint(a, e, T_CHECK_STOP)
916	#define T_quiet_le_uchar(a, e) T_flags_le_uint(a, e, T_CHECK_QUIET)
917	#define T_step_le_uchar(s, a, e) T_flags_le_uint(a, e, T_CHECK_STEP(s))
918	#define T_step_assert_le_uchar(s, a, e) \
919	T_flags_le_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
920
921	#define T_lt_uchar(a, e) T_flags_lt_uint(a, e, 0)
922	#define T_assert_lt_uchar(a, e) T_flags_lt_uint(a, e, T_CHECK_STOP)
923	#define T_quiet_lt_uchar(a, e) T_flags_lt_uint(a, e, T_CHECK_QUIET)
924	#define T_step_lt_uchar(s, a, e) T_flags_lt_uint(a, e, T_CHECK_STEP(s))
925	#define T_step_assert_lt_uchar(s, a, e) \
926	T_flags_lt_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
927
928	/** @} */
929
930	/**
931	* @defgroup RTEMSTestFrameworkChecksShort Signed Short Integer Checks
932	*
933	* @ingroup RTEMSTestFramework
934	*
935	* @brief Checks for signed short integers (short).
936	*
937	* @{
938	*/
939
940	#define T_eq_short(a, e) T_flags_eq_int(a, e, 0)
941	#define T_assert_eq_short(a, e) T_flags_eq_int(a, e, T_CHECK_STOP)
942	#define T_quiet_eq_short(a, e) T_flags_eq_int(a, e, T_CHECK_QUIET)
943	#define T_step_eq_short(s, a, e) T_flags_eq_int(a, e, T_CHECK_STEP(s))
944	#define T_step_assert_eq_short(s, a, e) \
945	T_flags_eq_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
946
947	#define T_ne_short(a, e) T_flags_ne_int(a, e, 0)
948	#define T_assert_ne_short(a, e) T_flags_ne_int(a, e, T_CHECK_STOP)
949	#define T_quiet_ne_short(a, e) T_flags_ne_int(a, e, T_CHECK_QUIET)
950	#define T_step_ne_short(s, a, e) T_flags_ne_int(a, e, T_CHECK_STEP(s))
951	#define T_step_assert_ne_short(s, a, e) \
952	T_flags_ne_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
953
954	#define T_ge_short(a, e) T_flags_ge_int(a, e, 0)
955	#define T_assert_ge_short(a, e) T_flags_ge_int(a, e, T_CHECK_STOP)
956	#define T_quiet_ge_short(a, e) T_flags_ge_int(a, e, T_CHECK_QUIET)
957	#define T_step_ge_short(s, a, e) T_flags_ge_int(a, e, T_CHECK_STEP(s))
958	#define T_step_assert_ge_short(s, a, e) \
959	T_flags_ge_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
960
961	#define T_gt_short(a, e) T_flags_gt_int(a, e, 0)
962	#define T_assert_gt_short(a, e) T_flags_gt_int(a, e, T_CHECK_STOP)
963	#define T_quiet_gt_short(a, e) T_flags_gt_int(a, e, T_CHECK_QUIET)
964	#define T_step_gt_short(s, a, e) T_flags_gt_int(a, e, T_CHECK_STEP(s))
965	#define T_step_assert_gt_short(s, a, e) \
966	T_flags_gt_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
967
968	#define T_le_short(a, e) T_flags_le_int(a, e, 0)
969	#define T_assert_le_short(a, e) T_flags_le_int(a, e, T_CHECK_STOP)
970	#define T_quiet_le_short(a, e) T_flags_le_int(a, e, T_CHECK_QUIET)
971	#define T_step_le_short(s, a, e) T_flags_le_int(a, e, T_CHECK_STEP(s))
972	#define T_step_assert_le_short(s, a, e) \
973	T_flags_le_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
974
975	#define T_lt_short(a, e) T_flags_lt_int(a, e, 0)
976	#define T_assert_lt_short(a, e) T_flags_lt_int(a, e, T_CHECK_STOP)
977	#define T_quiet_lt_short(a, e) T_flags_lt_int(a, e, T_CHECK_QUIET)
978	#define T_step_lt_short(s, a, e) T_flags_lt_int(a, e, T_CHECK_STEP(s))
979	#define T_step_assert_lt_short(s, a, e) \
980	T_flags_lt_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
981
982	/** @} */
983
984	/**
985	* @defgroup RTEMSTestFrameworkChecksUShort Unsigned Short Integer Checks
986	*
987	* @ingroup RTEMSTestFramework
988	*
989	* @brief Checks for unsigned short integers (unsigned short).
990	*
991	* @{
992	*/
993
994	#define T_eq_ushort(a, e) T_flags_eq_uint(a, e, 0)
995	#define T_assert_eq_ushort(a, e) T_flags_eq_uint(a, e, T_CHECK_STOP)
996	#define T_quiet_eq_ushort(a, e) T_flags_eq_uint(a, e, T_CHECK_QUIET)
997	#define T_step_eq_ushort(s, a, e) T_flags_eq_uint(a, e, T_CHECK_STEP(s))
998	#define T_step_assert_eq_ushort(s, a, e) \
999	T_flags_eq_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1000
1001	#define T_ne_ushort(a, e) T_flags_ne_uint(a, e, 0)
1002	#define T_assert_ne_ushort(a, e) T_flags_ne_uint(a, e, T_CHECK_STOP)
1003	#define T_quiet_ne_ushort(a, e) T_flags_ne_uint(a, e, T_CHECK_QUIET)
1004	#define T_step_ne_ushort(s, a, e) T_flags_ne_uint(a, e, T_CHECK_STEP(s))
1005	#define T_step_assert_ne_ushort(s, a, e) \
1006	T_flags_ne_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1007
1008	#define T_ge_ushort(a, e) T_flags_ge_uint(a, e, 0)
1009	#define T_assert_ge_ushort(a, e) T_flags_ge_uint(a, e, T_CHECK_STOP)
1010	#define T_quiet_ge_ushort(a, e) T_flags_ge_uint(a, e, T_CHECK_QUIET)
1011	#define T_step_ge_ushort(s, a, e) T_flags_ge_uint(a, e, T_CHECK_STEP(s))
1012	#define T_step_assert_ge_ushort(s, a, e) \
1013	T_flags_ge_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1014
1015	#define T_gt_ushort(a, e) T_flags_gt_uint(a, e, 0)
1016	#define T_assert_gt_ushort(a, e) T_flags_gt_uint(a, e, T_CHECK_STOP)
1017	#define T_quiet_gt_ushort(a, e) T_flags_gt_uint(a, e, T_CHECK_QUIET)
1018	#define T_step_gt_ushort(s, a, e) T_flags_gt_uint(a, e, T_CHECK_STEP(s))
1019	#define T_step_assert_gt_ushort(s, a, e) \
1020	T_flags_gt_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1021
1022	#define T_le_ushort(a, e) T_flags_le_uint(a, e, 0)
1023	#define T_assert_le_ushort(a, e) T_flags_le_uint(a, e, T_CHECK_STOP)
1024	#define T_quiet_le_ushort(a, e) T_flags_le_uint(a, e, T_CHECK_QUIET)
1025	#define T_step_le_ushort(s, a, e) T_flags_le_uint(a, e, T_CHECK_STEP(s))
1026	#define T_step_assert_le_ushort(s, a, e) \
1027	T_flags_le_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1028
1029	#define T_lt_ushort(a, e) T_flags_lt_uint(a, e, 0)
1030	#define T_assert_lt_ushort(a, e) T_flags_lt_uint(a, e, T_CHECK_STOP)
1031	#define T_quiet_lt_ushort(a, e) T_flags_lt_uint(a, e, T_CHECK_QUIET)
1032	#define T_step_lt_ushort(s, a, e) T_flags_lt_uint(a, e, T_CHECK_STEP(s))
1033	#define T_step_assert_lt_ushort(s, a, e) \
1034	T_flags_lt_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1035
1036	/** @} */
1037
1038	/**
1039	* @defgroup RTEMSTestFrameworkChecksInt Signed Integer Checks
1040	*
1041	* @ingroup RTEMSTestFramework
1042	*
1043	* @brief Checks for signed integers (int).
1044	*
1045	* @{
1046	*/
1047
1048	#define T_eq_int(a, e) T_flags_eq_int(a, e, 0)
1049	#define T_assert_eq_int(a, e) T_flags_eq_int(a, e, T_CHECK_STOP)
1050	#define T_quiet_eq_int(a, e) T_flags_eq_int(a, e, T_CHECK_QUIET)
1051	#define T_step_eq_int(s, a, e) T_flags_eq_int(a, e, T_CHECK_STEP(s))
1052	#define T_step_assert_eq_int(s, a, e) \
1053	T_flags_eq_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1054
1055	#define T_ne_int(a, e) T_flags_ne_int(a, e, 0)
1056	#define T_assert_ne_int(a, e) T_flags_ne_int(a, e, T_CHECK_STOP)
1057	#define T_quiet_ne_int(a, e) T_flags_ne_int(a, e, T_CHECK_QUIET)
1058	#define T_step_ne_int(s, a, e) T_flags_ne_int(a, e, T_CHECK_STEP(s))
1059	#define T_step_assert_ne_int(s, a, e) \
1060	T_flags_ne_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1061
1062	#define T_ge_int(a, e) T_flags_ge_int(a, e, 0)
1063	#define T_assert_ge_int(a, e) T_flags_ge_int(a, e, T_CHECK_STOP)
1064	#define T_quiet_ge_int(a, e) T_flags_ge_int(a, e, T_CHECK_QUIET)
1065	#define T_step_ge_int(s, a, e) T_flags_ge_int(a, e, T_CHECK_STEP(s))
1066	#define T_step_assert_ge_int(s, a, e) \
1067	T_flags_ge_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1068
1069	#define T_gt_int(a, e) T_flags_gt_int(a, e, 0)
1070	#define T_assert_gt_int(a, e) T_flags_gt_int(a, e, T_CHECK_STOP)
1071	#define T_quiet_gt_int(a, e) T_flags_gt_int(a, e, T_CHECK_QUIET)
1072	#define T_step_gt_int(s, a, e) T_flags_gt_int(a, e, T_CHECK_STEP(s))
1073	#define T_step_assert_gt_int(s, a, e) \
1074	T_flags_gt_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1075
1076	#define T_le_int(a, e) T_flags_le_int(a, e, 0)
1077	#define T_assert_le_int(a, e) T_flags_le_int(a, e, T_CHECK_STOP)
1078	#define T_quiet_le_int(a, e) T_flags_le_int(a, e, T_CHECK_QUIET)
1079	#define T_step_le_int(s, a, e) T_flags_le_int(a, e, T_CHECK_STEP(s))
1080	#define T_step_assert_le_int(s, a, e) \
1081	T_flags_le_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1082
1083	#define T_lt_int(a, e) T_flags_lt_int(a, e, 0)
1084	#define T_assert_lt_int(a, e) T_flags_lt_int(a, e, T_CHECK_STOP)
1085	#define T_quiet_lt_int(a, e) T_flags_lt_int(a, e, T_CHECK_QUIET)
1086	#define T_step_lt_int(s, a, e) T_flags_lt_int(a, e, T_CHECK_STEP(s))
1087	#define T_step_assert_lt_int(s, a, e) \
1088	T_flags_lt_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1089
1090	/** @} */
1091
1092	/**
1093	* @defgroup RTEMSTestFrameworkChecksUInt Unsigned Integer Checks
1094	*
1095	* @ingroup RTEMSTestFramework
1096	*
1097	* @brief Checks for unsigned integers (unsigned int).
1098	*
1099	* @{
1100	*/
1101
1102	#define T_eq_uint(a, e) T_flags_eq_uint(a, e, 0)
1103	#define T_assert_eq_uint(a, e) T_flags_eq_uint(a, e, T_CHECK_STOP)
1104	#define T_quiet_eq_uint(a, e) T_flags_eq_uint(a, e, T_CHECK_QUIET)
1105	#define T_step_eq_uint(s, a, e) T_flags_eq_uint(a, e, T_CHECK_STEP(s))
1106	#define T_step_assert_eq_uint(s, a, e) \
1107	T_flags_eq_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1108
1109	#define T_ne_uint(a, e) T_flags_ne_uint(a, e, 0)
1110	#define T_assert_ne_uint(a, e) T_flags_ne_uint(a, e, T_CHECK_STOP)
1111	#define T_quiet_ne_uint(a, e) T_flags_ne_uint(a, e, T_CHECK_QUIET)
1112	#define T_step_ne_uint(s, a, e) T_flags_ne_uint(a, e, T_CHECK_STEP(s))
1113	#define T_step_assert_ne_uint(s, a, e) \
1114	T_flags_ne_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1115
1116	#define T_ge_uint(a, e) T_flags_ge_uint(a, e, 0)
1117	#define T_assert_ge_uint(a, e) T_flags_ge_uint(a, e, T_CHECK_STOP)
1118	#define T_quiet_ge_uint(a, e) T_flags_ge_uint(a, e, T_CHECK_QUIET)
1119	#define T_step_ge_uint(s, a, e) T_flags_ge_uint(a, e, T_CHECK_STEP(s))
1120	#define T_step_assert_ge_uint(s, a, e) \
1121	T_flags_ge_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1122
1123	#define T_gt_uint(a, e) T_flags_gt_uint(a, e, 0)
1124	#define T_assert_gt_uint(a, e) T_flags_gt_uint(a, e, T_CHECK_STOP)
1125	#define T_quiet_gt_uint(a, e) T_flags_gt_uint(a, e, T_CHECK_QUIET)
1126	#define T_step_gt_uint(s, a, e) T_flags_gt_uint(a, e, T_CHECK_STEP(s))
1127	#define T_step_assert_gt_uint(s, a, e) \
1128	T_flags_gt_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1129
1130	#define T_le_uint(a, e) T_flags_le_uint(a, e, 0)
1131	#define T_assert_le_uint(a, e) T_flags_le_uint(a, e, T_CHECK_STOP)
1132	#define T_quiet_le_uint(a, e) T_flags_le_uint(a, e, T_CHECK_QUIET)
1133	#define T_step_le_uint(s, a, e) T_flags_le_uint(a, e, T_CHECK_STEP(s))
1134	#define T_step_assert_le_uint(s, a, e) \
1135	T_flags_le_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1136
1137	#define T_lt_uint(a, e) T_flags_lt_uint(a, e, 0)
1138	#define T_assert_lt_uint(a, e) T_flags_lt_uint(a, e, T_CHECK_STOP)
1139	#define T_quiet_lt_uint(a, e) T_flags_lt_uint(a, e, T_CHECK_QUIET)
1140	#define T_step_lt_uint(s, a, e) T_flags_lt_uint(a, e, T_CHECK_STEP(s))
1141	#define T_step_assert_lt_uint(s, a, e) \
1142	T_flags_lt_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1143
1144	/** @} */
1145
1146	/**
1147	* @defgroup RTEMSTestFrameworkChecksLong Signed Long Integer Checks
1148	*
1149	* @ingroup RTEMSTestFramework
1150	*
1151	* @brief Checks for signed long integers (long).
1152	*
1153	* @{
1154	*/
1155
1156	#define T_eq_long(a, e) T_flags_eq_long(a, e, 0)
1157	#define T_assert_eq_long(a, e) T_flags_eq_long(a, e, T_CHECK_STOP)
1158	#define T_quiet_eq_long(a, e) T_flags_eq_long(a, e, T_CHECK_QUIET)
1159	#define T_step_eq_long(s, a, e) T_flags_eq_long(a, e, T_CHECK_STEP(s))
1160	#define T_step_assert_eq_long(s, a, e) \
1161	T_flags_eq_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1162
1163	#define T_ne_long(a, e) T_flags_ne_long(a, e, 0)
1164	#define T_assert_ne_long(a, e) T_flags_ne_long(a, e, T_CHECK_STOP)
1165	#define T_quiet_ne_long(a, e) T_flags_ne_long(a, e, T_CHECK_QUIET)
1166	#define T_step_ne_long(s, a, e) T_flags_ne_long(a, e, T_CHECK_STEP(s))
1167	#define T_step_assert_ne_long(s, a, e) \
1168	T_flags_ne_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1169
1170	#define T_ge_long(a, e) T_flags_ge_long(a, e, 0)
1171	#define T_assert_ge_long(a, e) T_flags_ge_long(a, e, T_CHECK_STOP)
1172	#define T_quiet_ge_long(a, e) T_flags_ge_long(a, e, T_CHECK_QUIET)
1173	#define T_step_ge_long(s, a, e) T_flags_ge_long(a, e, T_CHECK_STEP(s))
1174	#define T_step_assert_ge_long(s, a, e) \
1175	T_flags_ge_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1176
1177	#define T_gt_long(a, e) T_flags_gt_long(a, e, 0)
1178	#define T_assert_gt_long(a, e) T_flags_gt_long(a, e, T_CHECK_STOP)
1179	#define T_quiet_gt_long(a, e) T_flags_gt_long(a, e, T_CHECK_QUIET)
1180	#define T_step_gt_long(s, a, e) T_flags_gt_long(a, e, T_CHECK_STEP(s))
1181	#define T_step_assert_gt_long(s, a, e) \
1182	T_flags_gt_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1183
1184	#define T_le_long(a, e) T_flags_le_long(a, e, 0)
1185	#define T_assert_le_long(a, e) T_flags_le_long(a, e, T_CHECK_STOP)
1186	#define T_quiet_le_long(a, e) T_flags_le_long(a, e, T_CHECK_QUIET)
1187	#define T_step_le_long(s, a, e) T_flags_le_long(a, e, T_CHECK_STEP(s))
1188	#define T_step_assert_le_long(s, a, e) \
1189	T_flags_le_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1190
1191	#define T_lt_long(a, e) T_flags_lt_long(a, e, 0)
1192	#define T_assert_lt_long(a, e) T_flags_lt_long(a, e, T_CHECK_STOP)
1193	#define T_quiet_lt_long(a, e) T_flags_lt_long(a, e, T_CHECK_QUIET)
1194	#define T_step_lt_long(s, a, e) T_flags_lt_long(a, e, T_CHECK_STEP(s))
1195	#define T_step_assert_lt_long(s, a, e) \
1196	T_flags_lt_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1197
1198	/** @} */
1199
1200	/**
1201	* @defgroup RTEMSTestFrameworkChecksULong Unsigned Long Integer Checks
1202	*
1203	* @ingroup RTEMSTestFramework
1204	*
1205	* @brief Checks for unsigned long integers (unsigned long).
1206	*
1207	* @{
1208	*/
1209
1210	#define T_eq_ulong(a, e) T_flags_eq_ulong(a, e, 0)
1211	#define T_assert_eq_ulong(a, e) T_flags_eq_ulong(a, e, T_CHECK_STOP)
1212	#define T_quiet_eq_ulong(a, e) T_flags_eq_ulong(a, e, T_CHECK_QUIET)
1213	#define T_step_eq_ulong(s, a, e) T_flags_eq_ulong(a, e, T_CHECK_STEP(s))
1214	#define T_step_assert_eq_ulong(s, a, e) \
1215	T_flags_eq_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1216
1217	#define T_ne_ulong(a, e) T_flags_ne_ulong(a, e, 0)
1218	#define T_assert_ne_ulong(a, e) T_flags_ne_ulong(a, e, T_CHECK_STOP)
1219	#define T_quiet_ne_ulong(a, e) T_flags_ne_ulong(a, e, T_CHECK_QUIET)
1220	#define T_step_ne_ulong(s, a, e) T_flags_ne_ulong(a, e, T_CHECK_STEP(s))
1221	#define T_step_assert_ne_ulong(s, a, e) \
1222	T_flags_ne_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1223
1224	#define T_ge_ulong(a, e) T_flags_ge_ulong(a, e, 0)
1225	#define T_assert_ge_ulong(a, e) T_flags_ge_ulong(a, e, T_CHECK_STOP)
1226	#define T_quiet_ge_ulong(a, e) T_flags_ge_ulong(a, e, T_CHECK_QUIET)
1227	#define T_step_ge_ulong(s, a, e) T_flags_ge_ulong(a, e, T_CHECK_STEP(s))
1228	#define T_step_assert_ge_ulong(s, a, e) \
1229	T_flags_ge_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1230
1231	#define T_gt_ulong(a, e) T_flags_gt_ulong(a, e, 0)
1232	#define T_assert_gt_ulong(a, e) T_flags_gt_ulong(a, e, T_CHECK_STOP)
1233	#define T_quiet_gt_ulong(a, e) T_flags_gt_ulong(a, e, T_CHECK_QUIET)
1234	#define T_step_gt_ulong(s, a, e) T_flags_gt_ulong(a, e, T_CHECK_STEP(s))
1235	#define T_step_assert_gt_ulong(s, a, e) \
1236	T_flags_gt_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1237
1238	#define T_le_ulong(a, e) T_flags_le_ulong(a, e, 0)
1239	#define T_assert_le_ulong(a, e) T_flags_le_ulong(a, e, T_CHECK_STOP)
1240	#define T_quiet_le_ulong(a, e) T_flags_le_ulong(a, e, T_CHECK_QUIET)
1241	#define T_step_le_ulong(s, a, e) T_flags_le_ulong(a, e, T_CHECK_STEP(s))
1242	#define T_step_assert_le_ulong(s, a, e) \
1243	T_flags_le_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1244
1245	#define T_lt_ulong(a, e) T_flags_lt_ulong(a, e, 0)
1246	#define T_assert_lt_ulong(a, e) T_flags_lt_ulong(a, e, T_CHECK_STOP)
1247	#define T_quiet_lt_ulong(a, e) T_flags_lt_ulong(a, e, T_CHECK_QUIET)
1248	#define T_step_lt_ulong(s, a, e) T_flags_lt_ulong(a, e, T_CHECK_STEP(s))
1249	#define T_step_assert_lt_ulong(s, a, e) \
1250	T_flags_lt_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1251
1252	/** @} */
1253
1254	/**
1255	* @defgroup RTEMSTestFrameworkChecksLong Signed Long Long Integer Checks
1256	*
1257	* @ingroup RTEMSTestFramework
1258	*
1259	* @brief Checks for signed long long integers (long long).
1260	*
1261	* @{
1262	*/
1263
1264	#define T_eq_ll(a, e) T_flags_eq_ll(a, e, 0)
1265	#define T_assert_eq_ll(a, e) T_flags_eq_ll(a, e, T_CHECK_STOP)
1266	#define T_quiet_eq_ll(a, e) T_flags_eq_ll(a, e, T_CHECK_QUIET)
1267	#define T_step_eq_ll(s, a, e) T_flags_eq_ll(a, e, T_CHECK_STEP(s))
1268	#define T_step_assert_eq_ll(s, a, e) \
1269	T_flags_eq_ll(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1270
1271	#define T_ne_ll(a, e) T_flags_ne_ll(a, e, 0)
1272	#define T_assert_ne_ll(a, e) T_flags_ne_ll(a, e, T_CHECK_STOP)
1273	#define T_quiet_ne_ll(a, e) T_flags_ne_ll(a, e, T_CHECK_QUIET)
1274	#define T_step_ne_ll(s, a, e) T_flags_ne_ll(a, e, T_CHECK_STEP(s))
1275	#define T_step_assert_ne_ll(s, a, e) \
1276	T_flags_ne_ll(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1277
1278	#define T_ge_ll(a, e) T_flags_ge_ll(a, e, 0)
1279	#define T_assert_ge_ll(a, e) T_flags_ge_ll(a, e, T_CHECK_STOP)
1280	#define T_quiet_ge_ll(a, e) T_flags_ge_ll(a, e, T_CHECK_QUIET)
1281	#define T_step_ge_ll(s, a, e) T_flags_ge_ll(a, e, T_CHECK_STEP(s))
1282	#define T_step_assert_ge_ll(s, a, e) \
1283	T_flags_ge_ll(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1284
1285	#define T_gt_ll(a, e) T_flags_gt_ll(a, e, 0)
1286	#define T_assert_gt_ll(a, e) T_flags_gt_ll(a, e, T_CHECK_STOP)
1287	#define T_quiet_gt_ll(a, e) T_flags_gt_ll(a, e, T_CHECK_QUIET)
1288	#define T_step_gt_ll(s, a, e) T_flags_gt_ll(a, e, T_CHECK_STEP(s))
1289	#define T_step_assert_gt_ll(s, a, e) \
1290	T_flags_gt_ll(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1291
1292	#define T_le_ll(a, e) T_flags_le_ll(a, e, 0)
1293	#define T_assert_le_ll(a, e) T_flags_le_ll(a, e, T_CHECK_STOP)
1294	#define T_quiet_le_ll(a, e) T_flags_le_ll(a, e, T_CHECK_QUIET)
1295	#define T_step_le_ll(s, a, e) T_flags_le_ll(a, e, T_CHECK_STEP(s))
1296	#define T_step_assert_le_ll(s, a, e) \
1297	T_flags_le_ll(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1298
1299	#define T_lt_ll(a, e) T_flags_lt_ll(a, e, 0)
1300	#define T_assert_lt_ll(a, e) T_flags_lt_ll(a, e, T_CHECK_STOP)
1301	#define T_quiet_lt_ll(a, e) T_flags_lt_ll(a, e, T_CHECK_QUIET)
1302	#define T_step_lt_ll(s, a, e) T_flags_lt_ll(a, e, T_CHECK_STEP(s))
1303	#define T_step_assert_lt_ll(s, a, e) \
1304	T_flags_lt_ll(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1305
1306	/** @} */
1307
1308	/**
1309	* @defgroup RTEMSTestFrameworkChecksULongLong Unsigned Long Long Integer Checks
1310	*
1311	* @ingroup RTEMSTestFramework
1312	*
1313	* @brief Checks for unsigned long long integers (unsigned long long).
1314	*
1315	* @{
1316	*/
1317
1318	#define T_eq_ull(a, e) T_flags_eq_ull(a, e, 0)
1319	#define T_assert_eq_ull(a, e) T_flags_eq_ull(a, e, T_CHECK_STOP)
1320	#define T_quiet_eq_ull(a, e) T_flags_eq_ull(a, e, T_CHECK_QUIET)
1321	#define T_step_eq_ull(s, a, e) T_flags_eq_ull(a, e, T_CHECK_STEP(s))
1322	#define T_step_assert_eq_ull(s, a, e) \
1323	T_flags_eq_ull(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1324
1325	#define T_ne_ull(a, e) T_flags_ne_ull(a, e, 0)
1326	#define T_assert_ne_ull(a, e) T_flags_ne_ull(a, e, T_CHECK_STOP)
1327	#define T_quiet_ne_ull(a, e) T_flags_ne_ull(a, e, T_CHECK_QUIET)
1328	#define T_step_ne_ull(s, a, e) T_flags_ne_ull(a, e, T_CHECK_STEP(s))
1329	#define T_step_assert_ne_ull(s, a, e) \
1330	T_flags_ne_ull(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1331
1332	#define T_ge_ull(a, e) T_flags_ge_ull(a, e, 0)
1333	#define T_assert_ge_ull(a, e) T_flags_ge_ull(a, e, T_CHECK_STOP)
1334	#define T_quiet_ge_ull(a, e) T_flags_ge_ull(a, e, T_CHECK_QUIET)
1335	#define T_step_ge_ull(s, a, e) T_flags_ge_ull(a, e, T_CHECK_STEP(s))
1336	#define T_step_assert_ge_ull(s, a, e) \
1337	T_flags_ge_ull(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1338
1339	#define T_gt_ull(a, e) T_flags_gt_ull(a, e, 0)
1340	#define T_assert_gt_ull(a, e) T_flags_gt_ull(a, e, T_CHECK_STOP)
1341	#define T_quiet_gt_ull(a, e) T_flags_gt_ull(a, e, T_CHECK_QUIET)
1342	#define T_step_gt_ull(s, a, e) T_flags_gt_ull(a, e, T_CHECK_STEP(s))
1343	#define T_step_assert_gt_ull(s, a, e) \
1344	T_flags_gt_ull(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1345
1346	#define T_le_ull(a, e) T_flags_le_ull(a, e, 0)
1347	#define T_assert_le_ull(a, e) T_flags_le_ull(a, e, T_CHECK_STOP)
1348	#define T_quiet_le_ull(a, e) T_flags_le_ull(a, e, T_CHECK_QUIET)
1349	#define T_step_le_ull(s, a, e) T_flags_le_ull(a, e, T_CHECK_STEP(s))
1350	#define T_step_assert_le_ull(s, a, e) \
1351	T_flags_le_ull(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1352
1353	#define T_lt_ull(a, e) T_flags_lt_ull(a, e, 0)
1354	#define T_assert_lt_ull(a, e) T_flags_lt_ull(a, e, T_CHECK_STOP)
1355	#define T_quiet_lt_ull(a, e) T_flags_lt_ull(a, e, T_CHECK_QUIET)
1356	#define T_step_lt_ull(s, a, e) T_flags_lt_ull(a, e, T_CHECK_STEP(s))
1357	#define T_step_assert_lt_ull(s, a, e) \
1358	T_flags_lt_ull(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1359
1360	/** @} */
1361
1362	/**
1363	* @defgroup RTEMSTestFrameworkChecksInt8 Signed 8-Bit Integer Checks
1364	*
1365	* @ingroup RTEMSTestFramework
1366	*
1367	* @brief Checks for signed 8-bit integers (int8_t).
1368	*
1369	* @{
1370	*/
1371
1372	#define T_eq_i8(a, e) T_flags_eq_int(a, e, 0)
1373	#define T_assert_eq_i8(a, e) T_flags_eq_int(a, e, T_CHECK_STOP)
1374	#define T_quiet_eq_i8(a, e) T_flags_eq_int(a, e, T_CHECK_QUIET)
1375	#define T_step_eq_i8(s, a, e) T_flags_eq_int(a, e, T_CHECK_STEP(s))
1376	#define T_step_assert_eq_i8(s, a, e) \
1377	T_flags_eq_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1378
1379	#define T_ne_i8(a, e) T_flags_ne_int(a, e, 0)
1380	#define T_assert_ne_i8(a, e) T_flags_ne_int(a, e, T_CHECK_STOP)
1381	#define T_quiet_ne_i8(a, e) T_flags_ne_int(a, e, T_CHECK_QUIET)
1382	#define T_step_ne_i8(s, a, e) T_flags_ne_int(a, e, T_CHECK_STEP(s))
1383	#define T_step_assert_ne_i8(s, a, e) \
1384	T_flags_ne_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1385
1386	#define T_ge_i8(a, e) T_flags_ge_int(a, e, 0)
1387	#define T_assert_ge_i8(a, e) T_flags_ge_int(a, e, T_CHECK_STOP)
1388	#define T_quiet_ge_i8(a, e) T_flags_ge_int(a, e, T_CHECK_QUIET)
1389	#define T_step_ge_i8(s, a, e) T_flags_ge_int(a, e, T_CHECK_STEP(s))
1390	#define T_step_assert_ge_i8(s, a, e) \
1391	T_flags_ge_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1392
1393	#define T_gt_i8(a, e) T_flags_gt_int(a, e, 0)
1394	#define T_assert_gt_i8(a, e) T_flags_gt_int(a, e, T_CHECK_STOP)
1395	#define T_quiet_gt_i8(a, e) T_flags_gt_int(a, e, T_CHECK_QUIET)
1396	#define T_step_gt_i8(s, a, e) T_flags_gt_int(a, e, T_CHECK_STEP(s))
1397	#define T_step_assert_gt_i8(s, a, e) \
1398	T_flags_gt_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1399
1400	#define T_le_i8(a, e) T_flags_le_int(a, e, 0)
1401	#define T_assert_le_i8(a, e) T_flags_le_int(a, e, T_CHECK_STOP)
1402	#define T_quiet_le_i8(a, e) T_flags_le_int(a, e, T_CHECK_QUIET)
1403	#define T_step_le_i8(s, a, e) T_flags_le_int(a, e, T_CHECK_STEP(s))
1404	#define T_step_assert_le_i8(s, a, e) \
1405	T_flags_le_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1406
1407	#define T_lt_i8(a, e) T_flags_lt_int(a, e, 0)
1408	#define T_assert_lt_i8(a, e) T_flags_lt_int(a, e, T_CHECK_STOP)
1409	#define T_quiet_lt_i8(a, e) T_flags_lt_int(a, e, T_CHECK_QUIET)
1410	#define T_step_lt_i8(s, a, e) T_flags_lt_int(a, e, T_CHECK_STEP(s))
1411	#define T_step_assert_lt_i8(s, a, e) \
1412	T_flags_lt_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1413
1414	/** @} */
1415
1416	/**
1417	* @defgroup RTEMSTestFrameworkChecksUInt8 Unsigned 8-Bit Integer Checks
1418	*
1419	* @ingroup RTEMSTestFramework
1420	*
1421	* @brief Checks for unsigned 8-bit integers (uint8_t).
1422	*
1423	* @{
1424	*/
1425
1426	#define T_eq_u8(a, e) T_flags_eq_uint(a, e, 0)
1427	#define T_assert_eq_u8(a, e) T_flags_eq_uint(a, e, T_CHECK_STOP)
1428	#define T_quiet_eq_u8(a, e) T_flags_eq_uint(a, e, T_CHECK_QUIET)
1429	#define T_step_eq_u8(s, a, e) T_flags_eq_uint(a, e, T_CHECK_STEP(s))
1430	#define T_step_assert_eq_u8(s, a, e) \
1431	T_flags_eq_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1432
1433	#define T_ne_u8(a, e) T_flags_ne_uint(a, e, 0)
1434	#define T_assert_ne_u8(a, e) T_flags_ne_uint(a, e, T_CHECK_STOP)
1435	#define T_quiet_ne_u8(a, e) T_flags_ne_uint(a, e, T_CHECK_QUIET)
1436	#define T_step_ne_u8(s, a, e) T_flags_ne_uint(a, e, T_CHECK_STEP(s))
1437	#define T_step_assert_ne_u8(s, a, e) \
1438	T_flags_ne_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1439
1440	#define T_ge_u8(a, e) T_flags_ge_uint(a, e, 0)
1441	#define T_assert_ge_u8(a, e) T_flags_ge_uint(a, e, T_CHECK_STOP)
1442	#define T_quiet_ge_u8(a, e) T_flags_ge_uint(a, e, T_CHECK_QUIET)
1443	#define T_step_ge_u8(s, a, e) T_flags_ge_uint(a, e, T_CHECK_STEP(s))
1444	#define T_step_assert_ge_u8(s, a, e) \
1445	T_flags_ge_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1446
1447	#define T_gt_u8(a, e) T_flags_gt_uint(a, e, 0)
1448	#define T_assert_gt_u8(a, e) T_flags_gt_uint(a, e, T_CHECK_STOP)
1449	#define T_quiet_gt_u8(a, e) T_flags_gt_uint(a, e, T_CHECK_QUIET)
1450	#define T_step_gt_u8(s, a, e) T_flags_gt_uint(a, e, T_CHECK_STEP(s))
1451	#define T_step_assert_gt_u8(s, a, e) \
1452	T_flags_gt_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1453
1454	#define T_le_u8(a, e) T_flags_le_uint(a, e, 0)
1455	#define T_assert_le_u8(a, e) T_flags_le_uint(a, e, T_CHECK_STOP)
1456	#define T_quiet_le_u8(a, e) T_flags_le_uint(a, e, T_CHECK_QUIET)
1457	#define T_step_le_u8(s, a, e) T_flags_le_uint(a, e, T_CHECK_STEP(s))
1458	#define T_step_assert_le_u8(s, a, e) \
1459	T_flags_le_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1460
1461	#define T_lt_u8(a, e) T_flags_lt_uint(a, e, 0)
1462	#define T_assert_lt_u8(a, e) T_flags_lt_uint(a, e, T_CHECK_STOP)
1463	#define T_quiet_lt_u8(a, e) T_flags_lt_uint(a, e, T_CHECK_QUIET)
1464	#define T_step_lt_u8(s, a, e) T_flags_lt_uint(a, e, T_CHECK_STEP(s))
1465	#define T_step_assert_lt_u8(s, a, e) \
1466	T_flags_lt_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1467
1468	/** @} */
1469
1470	/**
1471	* @defgroup RTEMSTestFrameworkChecksInt16 Signed 16-Bit Integer Checks
1472	*
1473	* @ingroup RTEMSTestFramework
1474	*
1475	* @brief Checks for signed 16-bit integers (int16_t).
1476	*
1477	* @{
1478	*/
1479
1480	#define T_eq_i16(a, e) T_flags_eq_int(a, e, 0)
1481	#define T_assert_eq_i16(a, e) T_flags_eq_int(a, e, T_CHECK_STOP)
1482	#define T_quiet_eq_i16(a, e) T_flags_eq_int(a, e, T_CHECK_QUIET)
1483	#define T_step_eq_i16(s, a, e) T_flags_eq_int(a, e, T_CHECK_STEP(s))
1484	#define T_step_assert_eq_i16(s, a, e) \
1485	T_flags_eq_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1486
1487	#define T_ne_i16(a, e) T_flags_ne_int(a, e, 0)
1488	#define T_assert_ne_i16(a, e) T_flags_ne_int(a, e, T_CHECK_STOP)
1489	#define T_quiet_ne_i16(a, e) T_flags_ne_int(a, e, T_CHECK_QUIET)
1490	#define T_step_ne_i16(s, a, e) T_flags_ne_int(a, e, T_CHECK_STEP(s))
1491	#define T_step_assert_ne_i16(s, a, e) \
1492	T_flags_ne_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1493
1494	#define T_ge_i16(a, e) T_flags_ge_int(a, e, 0)
1495	#define T_assert_ge_i16(a, e) T_flags_ge_int(a, e, T_CHECK_STOP)
1496	#define T_quiet_ge_i16(a, e) T_flags_ge_int(a, e, T_CHECK_QUIET)
1497	#define T_step_ge_i16(s, a, e) T_flags_ge_int(a, e, T_CHECK_STEP(s))
1498	#define T_step_assert_ge_i16(s, a, e) \
1499	T_flags_ge_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1500
1501	#define T_gt_i16(a, e) T_flags_gt_int(a, e, 0)
1502	#define T_assert_gt_i16(a, e) T_flags_gt_int(a, e, T_CHECK_STOP)
1503	#define T_quiet_gt_i16(a, e) T_flags_gt_int(a, e, T_CHECK_QUIET)
1504	#define T_step_gt_i16(s, a, e) T_flags_gt_int(a, e, T_CHECK_STEP(s))
1505	#define T_step_assert_gt_i16(s, a, e) \
1506	T_flags_gt_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1507
1508	#define T_le_i16(a, e) T_flags_le_int(a, e, 0)
1509	#define T_assert_le_i16(a, e) T_flags_le_int(a, e, T_CHECK_STOP)
1510	#define T_quiet_le_i16(a, e) T_flags_le_int(a, e, T_CHECK_QUIET)
1511	#define T_step_le_i16(s, a, e) T_flags_le_int(a, e, T_CHECK_STEP(s))
1512	#define T_step_assert_le_i16(s, a, e) \
1513	T_flags_le_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1514
1515	#define T_lt_i16(a, e) T_flags_lt_int(a, e, 0)
1516	#define T_assert_lt_i16(a, e) T_flags_lt_int(a, e, T_CHECK_STOP)
1517	#define T_quiet_lt_i16(a, e) T_flags_lt_int(a, e, T_CHECK_QUIET)
1518	#define T_step_lt_i16(s, a, e) T_flags_lt_int(a, e, T_CHECK_STEP(s))
1519	#define T_step_assert_lt_i16(s, a, e) \
1520	T_flags_lt_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1521
1522	/** @} */
1523
1524	/**
1525	* @defgroup RTEMSTestFrameworkChecksUInt16 Unsigned 16-Bit Integer Checks
1526	*
1527	* @ingroup RTEMSTestFramework
1528	*
1529	* @brief Checks for unsigned 16-bit integers (uint16_t).
1530	*
1531	* @{
1532	*/
1533
1534	#define T_eq_u16(a, e) T_flags_eq_uint(a, e, 0)
1535	#define T_assert_eq_u16(a, e) T_flags_eq_uint(a, e, T_CHECK_STOP)
1536	#define T_quiet_eq_u16(a, e) T_flags_eq_uint(a, e, T_CHECK_QUIET)
1537	#define T_step_eq_u16(s, a, e) T_flags_eq_uint(a, e, T_CHECK_STEP(s))
1538	#define T_step_assert_eq_u16(s, a, e) \
1539	T_flags_eq_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1540
1541	#define T_ne_u16(a, e) T_flags_ne_uint(a, e, 0)
1542	#define T_assert_ne_u16(a, e) T_flags_ne_uint(a, e, T_CHECK_STOP)
1543	#define T_quiet_ne_u16(a, e) T_flags_ne_uint(a, e, T_CHECK_QUIET)
1544	#define T_step_ne_u16(s, a, e) T_flags_ne_uint(a, e, T_CHECK_STEP(s))
1545	#define T_step_assert_ne_u16(s, a, e) \
1546	T_flags_ne_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1547
1548	#define T_ge_u16(a, e) T_flags_ge_uint(a, e, 0)
1549	#define T_assert_ge_u16(a, e) T_flags_ge_uint(a, e, T_CHECK_STOP)
1550	#define T_quiet_ge_u16(a, e) T_flags_ge_uint(a, e, T_CHECK_QUIET)
1551	#define T_step_ge_u16(s, a, e) T_flags_ge_uint(a, e, T_CHECK_STEP(s))
1552	#define T_step_assert_ge_u16(s, a, e) \
1553	T_flags_ge_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1554
1555	#define T_gt_u16(a, e) T_flags_gt_uint(a, e, 0)
1556	#define T_assert_gt_u16(a, e) T_flags_gt_uint(a, e, T_CHECK_STOP)
1557	#define T_quiet_gt_u16(a, e) T_flags_gt_uint(a, e, T_CHECK_QUIET)
1558	#define T_step_gt_u16(s, a, e) T_flags_gt_uint(a, e, T_CHECK_STEP(s))
1559	#define T_step_assert_gt_u16(s, a, e) \
1560	T_flags_gt_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1561
1562	#define T_le_u16(a, e) T_flags_le_uint(a, e, 0)
1563	#define T_assert_le_u16(a, e) T_flags_le_uint(a, e, T_CHECK_STOP)
1564	#define T_quiet_le_u16(a, e) T_flags_le_uint(a, e, T_CHECK_QUIET)
1565	#define T_step_le_u16(s, a, e) T_flags_le_uint(a, e, T_CHECK_STEP(s))
1566	#define T_step_assert_le_u16(s, a, e) \
1567	T_flags_le_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1568
1569	#define T_lt_u16(a, e) T_flags_lt_uint(a, e, 0)
1570	#define T_assert_lt_u16(a, e) T_flags_lt_uint(a, e, T_CHECK_STOP)
1571	#define T_quiet_lt_u16(a, e) T_flags_lt_uint(a, e, T_CHECK_QUIET)
1572	#define T_step_lt_u16(s, a, e) T_flags_lt_uint(a, e, T_CHECK_STEP(s))
1573	#define T_step_assert_lt_u16(s, a, e) \
1574	T_flags_lt_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1575
1576	/** @} */
1577
1578	/**
1579	* @defgroup RTEMSTestFrameworkChecksInt32 Signed 32-Bit Integer Checks
1580	*
1581	* @ingroup RTEMSTestFramework
1582	*
1583	* @brief Checks for signed 32-bit integers (int32_t).
1584	*
1585	* @{
1586	*/
1587
1588	#define T_eq_i32(a, e) T_flags_eq_long(a, e, 0)
1589	#define T_assert_eq_i32(a, e) T_flags_eq_long(a, e, T_CHECK_STOP)
1590	#define T_quiet_eq_i32(a, e) T_flags_eq_long(a, e, T_CHECK_QUIET)
1591	#define T_step_eq_i32(s, a, e) T_flags_eq_long(a, e, T_CHECK_STEP(s))
1592	#define T_step_assert_eq_i32(s, a, e) \
1593	T_flags_eq_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1594
1595	#define T_ne_i32(a, e) T_flags_ne_long(a, e, 0)
1596	#define T_assert_ne_i32(a, e) T_flags_ne_long(a, e, T_CHECK_STOP)
1597	#define T_quiet_ne_i32(a, e) T_flags_ne_long(a, e, T_CHECK_QUIET)
1598	#define T_step_ne_i32(s, a, e) T_flags_ne_long(a, e, T_CHECK_STEP(s))
1599	#define T_step_assert_ne_i32(s, a, e) \
1600	T_flags_ne_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1601
1602	#define T_ge_i32(a, e) T_flags_ge_long(a, e, 0)
1603	#define T_assert_ge_i32(a, e) T_flags_ge_long(a, e, T_CHECK_STOP)
1604	#define T_quiet_ge_i32(a, e) T_flags_ge_long(a, e, T_CHECK_QUIET)
1605	#define T_step_ge_i32(s, a, e) T_flags_ge_long(a, e, T_CHECK_STEP(s))
1606	#define T_step_assert_ge_i32(s, a, e) \
1607	T_flags_ge_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1608
1609	#define T_gt_i32(a, e) T_flags_gt_long(a, e, 0)
1610	#define T_assert_gt_i32(a, e) T_flags_gt_long(a, e, T_CHECK_STOP)
1611	#define T_quiet_gt_i32(a, e) T_flags_gt_long(a, e, T_CHECK_QUIET)
1612	#define T_step_gt_i32(s, a, e) T_flags_gt_long(a, e, T_CHECK_STEP(s))
1613	#define T_step_assert_gt_i32(s, a, e) \
1614	T_flags_gt_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1615
1616	#define T_le_i32(a, e) T_flags_le_long(a, e, 0)
1617	#define T_assert_le_i32(a, e) T_flags_le_long(a, e, T_CHECK_STOP)
1618	#define T_quiet_le_i32(a, e) T_flags_le_long(a, e, T_CHECK_QUIET)
1619	#define T_step_le_i32(s, a, e) T_flags_le_long(a, e, T_CHECK_STEP(s))
1620	#define T_step_assert_le_i32(s, a, e) \
1621	T_flags_le_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1622
1623	#define T_lt_i32(a, e) T_flags_lt_long(a, e, 0)
1624	#define T_assert_lt_i32(a, e) T_flags_lt_long(a, e, T_CHECK_STOP)
1625	#define T_quiet_lt_i32(a, e) T_flags_lt_long(a, e, T_CHECK_QUIET)
1626	#define T_step_lt_i32(s, a, e) T_flags_lt_long(a, e, T_CHECK_STEP(s))
1627	#define T_step_assert_lt_i32(s, a, e) \
1628	T_flags_lt_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1629
1630	/** @} */
1631
1632	/**
1633	* @defgroup RTEMSTestFrameworkChecksUInt32 Unsigned 32-Bit Integer Checks
1634	*
1635	* @ingroup RTEMSTestFramework
1636	*
1637	* @brief Checks for unsigned 32-bit integers (uint32_t).
1638	*
1639	* @{
1640	*/
1641
1642	#define T_eq_u32(a, e) T_flags_eq_ulong(a, e, 0)
1643	#define T_assert_eq_u32(a, e) T_flags_eq_ulong(a, e, T_CHECK_STOP)
1644	#define T_quiet_eq_u32(a, e) T_flags_eq_ulong(a, e, T_CHECK_QUIET)
1645	#define T_step_eq_u32(s, a, e) T_flags_eq_ulong(a, e, T_CHECK_STEP(s))
1646	#define T_step_assert_eq_u32(s, a, e) \
1647	T_flags_eq_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1648
1649	#define T_ne_u32(a, e) T_flags_ne_ulong(a, e, 0)
1650	#define T_assert_ne_u32(a, e) T_flags_ne_ulong(a, e, T_CHECK_STOP)
1651	#define T_quiet_ne_u32(a, e) T_flags_ne_ulong(a, e, T_CHECK_QUIET)
1652	#define T_step_ne_u32(s, a, e) T_flags_ne_ulong(a, e, T_CHECK_STEP(s))
1653	#define T_step_assert_ne_u32(s, a, e) \
1654	T_flags_ne_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1655
1656	#define T_ge_u32(a, e) T_flags_ge_ulong(a, e, 0)
1657	#define T_assert_ge_u32(a, e) T_flags_ge_ulong(a, e, T_CHECK_STOP)
1658	#define T_quiet_ge_u32(a, e) T_flags_ge_ulong(a, e, T_CHECK_QUIET)
1659	#define T_step_ge_u32(s, a, e) T_flags_ge_ulong(a, e, T_CHECK_STEP(s))
1660	#define T_step_assert_ge_u32(s, a, e) \
1661	T_flags_ge_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1662
1663	#define T_gt_u32(a, e) T_flags_gt_ulong(a, e, 0)
1664	#define T_assert_gt_u32(a, e) T_flags_gt_ulong(a, e, T_CHECK_STOP)
1665	#define T_quiet_gt_u32(a, e) T_flags_gt_ulong(a, e, T_CHECK_QUIET)
1666	#define T_step_gt_u32(s, a, e) T_flags_gt_ulong(a, e, T_CHECK_STEP(s))
1667	#define T_step_assert_gt_u32(s, a, e) \
1668	T_flags_gt_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1669
1670	#define T_le_u32(a, e) T_flags_le_ulong(a, e, 0)
1671	#define T_assert_le_u32(a, e) T_flags_le_ulong(a, e, T_CHECK_STOP)
1672	#define T_quiet_le_u32(a, e) T_flags_le_ulong(a, e, T_CHECK_QUIET)
1673	#define T_step_le_u32(s, a, e) T_flags_le_ulong(a, e, T_CHECK_STEP(s))
1674	#define T_step_assert_le_u32(s, a, e) \
1675	T_flags_le_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1676
1677	#define T_lt_u32(a, e) T_flags_lt_ulong(a, e, 0)
1678	#define T_assert_lt_u32(a, e) T_flags_lt_ulong(a, e, T_CHECK_STOP)
1679	#define T_quiet_lt_u32(a, e) T_flags_lt_ulong(a, e, T_CHECK_QUIET)
1680	#define T_step_lt_u32(s, a, e) T_flags_lt_ulong(a, e, T_CHECK_STEP(s))
1681	#define T_step_assert_lt_u32(s, a, e) \
1682	T_flags_lt_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1683
1684	/** @} */
1685
1686	/**
1687	* @defgroup RTEMSTestFrameworkChecksInt64 Signed 64-Bit Integer Checks
1688	*
1689	* @ingroup RTEMSTestFramework
1690	*
1691	* @brief Checks for signed 64-bit integers (int64_t).
1692	*
1693	* @{
1694	*/
1695
1696	#define T_eq_i64(a, e) T_flags_eq_ll(a, e, 0)
1697	#define T_assert_eq_i64(a, e) T_flags_eq_ll(a, e, T_CHECK_STOP)
1698	#define T_quiet_eq_i64(a, e) T_flags_eq_ll(a, e, T_CHECK_QUIET)
1699	#define T_step_eq_i64(s, a, e) T_flags_eq_ll(a, e, T_CHECK_STEP(s))
1700	#define T_step_assert_eq_i64(s, a, e) \
1701	T_flags_eq_ll(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1702
1703	#define T_ne_i64(a, e) T_flags_ne_ll(a, e, 0)
1704	#define T_assert_ne_i64(a, e) T_flags_ne_ll(a, e, T_CHECK_STOP)
1705	#define T_quiet_ne_i64(a, e) T_flags_ne_ll(a, e, T_CHECK_QUIET)
1706	#define T_step_ne_i64(s, a, e) T_flags_ne_ll(a, e, T_CHECK_STEP(s))
1707	#define T_step_assert_ne_i64(s, a, e) \
1708	T_flags_ne_ll(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1709
1710	#define T_ge_i64(a, e) T_flags_ge_ll(a, e, 0)
1711	#define T_assert_ge_i64(a, e) T_flags_ge_ll(a, e, T_CHECK_STOP)
1712	#define T_quiet_ge_i64(a, e) T_flags_ge_ll(a, e, T_CHECK_QUIET)
1713	#define T_step_ge_i64(s, a, e) T_flags_ge_ll(a, e, T_CHECK_STEP(s))
1714	#define T_step_assert_ge_i64(s, a, e) \
1715	T_flags_ge_ll(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1716
1717	#define T_gt_i64(a, e) T_flags_gt_ll(a, e, 0)
1718	#define T_assert_gt_i64(a, e) T_flags_gt_ll(a, e, T_CHECK_STOP)
1719	#define T_quiet_gt_i64(a, e) T_flags_gt_ll(a, e, T_CHECK_QUIET)
1720	#define T_step_gt_i64(s, a, e) T_flags_gt_ll(a, e, T_CHECK_STEP(s))
1721	#define T_step_assert_gt_i64(s, a, e) \
1722	T_flags_gt_ll(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1723
1724	#define T_le_i64(a, e) T_flags_le_ll(a, e, 0)
1725	#define T_assert_le_i64(a, e) T_flags_le_ll(a, e, T_CHECK_STOP)
1726	#define T_quiet_le_i64(a, e) T_flags_le_ll(a, e, T_CHECK_QUIET)
1727	#define T_step_le_i64(s, a, e) T_flags_le_ll(a, e, T_CHECK_STEP(s))
1728	#define T_step_assert_le_i64(s, a, e) \
1729	T_flags_le_ll(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1730
1731	#define T_lt_i64(a, e) T_flags_lt_ll(a, e, 0)
1732	#define T_assert_lt_i64(a, e) T_flags_lt_ll(a, e, T_CHECK_STOP)
1733	#define T_quiet_lt_i64(a, e) T_flags_lt_ll(a, e, T_CHECK_QUIET)
1734	#define T_step_lt_i64(s, a, e) T_flags_lt_ll(a, e, T_CHECK_STEP(s))
1735	#define T_step_assert_lt_i64(s, a, e) \
1736	T_flags_lt_ll(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1737
1738	/** @} */
1739
1740	/**
1741	* @defgroup RTEMSTestFrameworkChecksUInt64 Unsigned 64-Bit Integer Checks
1742	*
1743	* @ingroup RTEMSTestFramework
1744	*
1745	* @brief Checks for unsigned 64-bit integers (uint64_t).
1746	*
1747	* @{
1748	*/
1749
1750	#define T_eq_u64(a, e) T_flags_eq_ull(a, e, 0)
1751	#define T_assert_eq_u64(a, e) T_flags_eq_ull(a, e, T_CHECK_STOP)
1752	#define T_quiet_eq_u64(a, e) T_flags_eq_ull(a, e, T_CHECK_QUIET)
1753	#define T_step_eq_u64(s, a, e) T_flags_eq_ull(a, e, T_CHECK_STEP(s))
1754	#define T_step_assert_eq_u64(s, a, e) \
1755	T_flags_eq_ull(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1756
1757	#define T_ne_u64(a, e) T_flags_ne_ull(a, e, 0)
1758	#define T_assert_ne_u64(a, e) T_flags_ne_ull(a, e, T_CHECK_STOP)
1759	#define T_quiet_ne_u64(a, e) T_flags_ne_ull(a, e, T_CHECK_QUIET)
1760	#define T_step_ne_u64(s, a, e) T_flags_ne_ull(a, e, T_CHECK_STEP(s))
1761	#define T_step_assert_ne_u64(s, a, e) \
1762	T_flags_ne_ull(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1763
1764	#define T_ge_u64(a, e) T_flags_ge_ull(a, e, 0)
1765	#define T_assert_ge_u64(a, e) T_flags_ge_ull(a, e, T_CHECK_STOP)
1766	#define T_quiet_ge_u64(a, e) T_flags_ge_ull(a, e, T_CHECK_QUIET)
1767	#define T_step_ge_u64(s, a, e) T_flags_ge_ull(a, e, T_CHECK_STEP(s))
1768	#define T_step_assert_ge_u64(s, a, e) \
1769	T_flags_ge_ull(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1770
1771	#define T_gt_u64(a, e) T_flags_gt_ull(a, e, 0)
1772	#define T_assert_gt_u64(a, e) T_flags_gt_ull(a, e, T_CHECK_STOP)
1773	#define T_quiet_gt_u64(a, e) T_flags_gt_ull(a, e, T_CHECK_QUIET)
1774	#define T_step_gt_u64(s, a, e) T_flags_gt_ull(a, e, T_CHECK_STEP(s))
1775	#define T_step_assert_gt_u64(s, a, e) \
1776	T_flags_gt_ull(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1777
1778	#define T_le_u64(a, e) T_flags_le_ull(a, e, 0)
1779	#define T_assert_le_u64(a, e) T_flags_le_ull(a, e, T_CHECK_STOP)
1780	#define T_quiet_le_u64(a, e) T_flags_le_ull(a, e, T_CHECK_QUIET)
1781	#define T_step_le_u64(s, a, e) T_flags_le_ull(a, e, T_CHECK_STEP(s))
1782	#define T_step_assert_le_u64(s, a, e) \
1783	T_flags_le_ull(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1784
1785	#define T_lt_u64(a, e) T_flags_lt_ull(a, e, 0)
1786	#define T_assert_lt_u64(a, e) T_flags_lt_ull(a, e, T_CHECK_STOP)
1787	#define T_quiet_lt_u64(a, e) T_flags_lt_ull(a, e, T_CHECK_QUIET)
1788	#define T_step_lt_u64(s, a, e) T_flags_lt_ull(a, e, T_CHECK_STEP(s))
1789	#define T_step_assert_lt_u64(s, a, e) \
1790	T_flags_lt_ull(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1791
1792	/** @} */
1793
1794	/**
1795	* @defgroup RTEMSTestFrameworkChecksIntptr Signed Pointer Value Checks
1796	*
1797	* @ingroup RTEMSTestFramework
1798	*
1799	* @brief Checks for signed pointer values (intptr_t).
1800	*
1801	* @{
1802	*/
1803
1804	#define T_eq_iptr(a, e) T_flags_eq_long(a, e, 0)
1805	#define T_assert_eq_iptr(a, e) T_flags_eq_long(a, e, T_CHECK_STOP)
1806	#define T_quiet_eq_iptr(a, e) T_flags_eq_long(a, e, T_CHECK_QUIET)
1807	#define T_step_eq_iptr(s, a, e) T_flags_eq_long(a, e, T_CHECK_STEP(s))
1808	#define T_step_assert_eq_iptr(s, a, e) \
1809	T_flags_eq_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1810
1811	#define T_ne_iptr(a, e) T_flags_ne_long(a, e, 0)
1812	#define T_assert_ne_iptr(a, e) T_flags_ne_long(a, e, T_CHECK_STOP)
1813	#define T_quiet_ne_iptr(a, e) T_flags_ne_long(a, e, T_CHECK_QUIET)
1814	#define T_step_ne_iptr(s, a, e) T_flags_ne_long(a, e, T_CHECK_STEP(s))
1815	#define T_step_assert_ne_iptr(s, a, e) \
1816	T_flags_ne_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1817
1818	#define T_ge_iptr(a, e) T_flags_ge_long(a, e, 0)
1819	#define T_assert_ge_iptr(a, e) T_flags_ge_long(a, e, T_CHECK_STOP)
1820	#define T_quiet_ge_iptr(a, e) T_flags_ge_long(a, e, T_CHECK_QUIET)
1821	#define T_step_ge_iptr(s, a, e) T_flags_ge_long(a, e, T_CHECK_STEP(s))
1822	#define T_step_assert_ge_iptr(s, a, e) \
1823	T_flags_ge_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1824
1825	#define T_gt_iptr(a, e) T_flags_gt_long(a, e, 0)
1826	#define T_assert_gt_iptr(a, e) T_flags_gt_long(a, e, T_CHECK_STOP)
1827	#define T_quiet_gt_iptr(a, e) T_flags_gt_long(a, e, T_CHECK_QUIET)
1828	#define T_step_gt_iptr(s, a, e) T_flags_gt_long(a, e, T_CHECK_STEP(s))
1829	#define T_step_assert_gt_iptr(s, a, e) \
1830	T_flags_gt_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1831
1832	#define T_le_iptr(a, e) T_flags_le_long(a, e, 0)
1833	#define T_assert_le_iptr(a, e) T_flags_le_long(a, e, T_CHECK_STOP)
1834	#define T_quiet_le_iptr(a, e) T_flags_le_long(a, e, T_CHECK_QUIET)
1835	#define T_step_le_iptr(s, a, e) T_flags_le_long(a, e, T_CHECK_STEP(s))
1836	#define T_step_assert_le_iptr(s, a, e) \
1837	T_flags_le_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1838
1839	#define T_lt_iptr(a, e) T_flags_lt_long(a, e, 0)
1840	#define T_assert_lt_iptr(a, e) T_flags_lt_long(a, e, T_CHECK_STOP)
1841	#define T_quiet_lt_iptr(a, e) T_flags_lt_long(a, e, T_CHECK_QUIET)
1842	#define T_step_lt_iptr(s, a, e) T_flags_lt_long(a, e, T_CHECK_STEP(s))
1843	#define T_step_assert_lt_iptr(s, a, e) \
1844	T_flags_lt_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1845
1846	/** @} */
1847
1848	/**
1849	* @defgroup RTEMSTestFrameworkChecksUIntptr Unsigned Pointer Value Checks
1850	*
1851	* @ingroup RTEMSTestFramework
1852	*
1853	* @brief Checks for unsigned pointer values (uintptr_t).
1854	*
1855	* @{
1856	*/
1857
1858	#define T_eq_uptr(a, e) T_flags_eq_ulong(a, e, 0)
1859	#define T_assert_eq_uptr(a, e) T_flags_eq_ulong(a, e, T_CHECK_STOP)
1860	#define T_quiet_eq_uptr(a, e) T_flags_eq_ulong(a, e, T_CHECK_QUIET)
1861	#define T_step_eq_uptr(s, a, e) T_flags_eq_ulong(a, e, T_CHECK_STEP(s))
1862	#define T_step_assert_eq_uptr(s, a, e) \
1863	T_flags_eq_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1864
1865	#define T_ne_uptr(a, e) T_flags_ne_ulong(a, e, 0)
1866	#define T_assert_ne_uptr(a, e) T_flags_ne_ulong(a, e, T_CHECK_STOP)
1867	#define T_quiet_ne_uptr(a, e) T_flags_ne_ulong(a, e, T_CHECK_QUIET)
1868	#define T_step_ne_uptr(s, a, e) T_flags_ne_ulong(a, e, T_CHECK_STEP(s))
1869	#define T_step_assert_ne_uptr(s, a, e) \
1870	T_flags_ne_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1871
1872	#define T_ge_uptr(a, e) T_flags_ge_ulong(a, e, 0)
1873	#define T_assert_ge_uptr(a, e) T_flags_ge_ulong(a, e, T_CHECK_STOP)
1874	#define T_quiet_ge_uptr(a, e) T_flags_ge_ulong(a, e, T_CHECK_QUIET)
1875	#define T_step_ge_uptr(s, a, e) T_flags_ge_ulong(a, e, T_CHECK_STEP(s))
1876	#define T_step_assert_ge_uptr(s, a, e) \
1877	T_flags_ge_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1878
1879	#define T_gt_uptr(a, e) T_flags_gt_ulong(a, e, 0)
1880	#define T_assert_gt_uptr(a, e) T_flags_gt_ulong(a, e, T_CHECK_STOP)
1881	#define T_quiet_gt_uptr(a, e) T_flags_gt_ulong(a, e, T_CHECK_QUIET)
1882	#define T_step_gt_uptr(s, a, e) T_flags_gt_ulong(a, e, T_CHECK_STEP(s))
1883	#define T_step_assert_gt_uptr(s, a, e) \
1884	T_flags_gt_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1885
1886	#define T_le_uptr(a, e) T_flags_le_ulong(a, e, 0)
1887	#define T_assert_le_uptr(a, e) T_flags_le_ulong(a, e, T_CHECK_STOP)
1888	#define T_quiet_le_uptr(a, e) T_flags_le_ulong(a, e, T_CHECK_QUIET)
1889	#define T_step_le_uptr(s, a, e) T_flags_le_ulong(a, e, T_CHECK_STEP(s))
1890	#define T_step_assert_le_uptr(s, a, e) \
1891	T_flags_le_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1892
1893	#define T_lt_uptr(a, e) T_flags_lt_ulong(a, e, 0)
1894	#define T_assert_lt_uptr(a, e) T_flags_lt_ulong(a, e, T_CHECK_STOP)
1895	#define T_quiet_lt_uptr(a, e) T_flags_lt_ulong(a, e, T_CHECK_QUIET)
1896	#define T_step_lt_uptr(s, a, e) T_flags_lt_ulong(a, e, T_CHECK_STEP(s))
1897	#define T_step_assert_lt_uptr(s, a, e) \
1898	T_flags_lt_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1899
1900	/** @} */
1901
1902	/**
1903	* @defgroup RTEMSTestFrameworkChecksSSZ Signed Size Checks
1904	*
1905	* @ingroup RTEMSTestFramework
1906	*
1907	* @brief Checks for signed sizes (ssize_t).
1908	*
1909	* @{
1910	*/
1911
1912	#define T_eq_ssz(a, e) T_flags_eq_long(a, e, 0)
1913	#define T_assert_eq_ssz(a, e) T_flags_eq_long(a, e, T_CHECK_STOP)
1914	#define T_quiet_eq_ssz(a, e) T_flags_eq_long(a, e, T_CHECK_QUIET)
1915	#define T_step_eq_ssz(s, a, e) T_flags_eq_long(a, e, T_CHECK_STEP(s))
1916	#define T_step_assert_eq_ssz(s, a, e) \
1917	T_flags_eq_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1918
1919	#define T_ne_ssz(a, e) T_flags_ne_long(a, e, 0)
1920	#define T_assert_ne_ssz(a, e) T_flags_ne_long(a, e, T_CHECK_STOP)
1921	#define T_quiet_ne_ssz(a, e) T_flags_ne_long(a, e, T_CHECK_QUIET)
1922	#define T_step_ne_ssz(s, a, e) T_flags_ne_long(a, e, T_CHECK_STEP(s))
1923	#define T_step_assert_ne_ssz(s, a, e) \
1924	T_flags_ne_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1925
1926	#define T_ge_ssz(a, e) T_flags_ge_long(a, e, 0)
1927	#define T_assert_ge_ssz(a, e) T_flags_ge_long(a, e, T_CHECK_STOP)
1928	#define T_quiet_ge_ssz(a, e) T_flags_ge_long(a, e, T_CHECK_QUIET)
1929	#define T_step_ge_ssz(s, a, e) T_flags_ge_long(a, e, T_CHECK_STEP(s))
1930	#define T_step_assert_ge_ssz(s, a, e) \
1931	T_flags_ge_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1932
1933	#define T_gt_ssz(a, e) T_flags_gt_long(a, e, 0)
1934	#define T_assert_gt_ssz(a, e) T_flags_gt_long(a, e, T_CHECK_STOP)
1935	#define T_quiet_gt_ssz(a, e) T_flags_gt_long(a, e, T_CHECK_QUIET)
1936	#define T_step_gt_ssz(s, a, e) T_flags_gt_long(a, e, T_CHECK_STEP(s))
1937	#define T_step_assert_gt_ssz(s, a, e) \
1938	T_flags_gt_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1939
1940	#define T_le_ssz(a, e) T_flags_le_long(a, e, 0)
1941	#define T_assert_le_ssz(a, e) T_flags_le_long(a, e, T_CHECK_STOP)
1942	#define T_quiet_le_ssz(a, e) T_flags_le_long(a, e, T_CHECK_QUIET)
1943	#define T_step_le_ssz(s, a, e) T_flags_le_long(a, e, T_CHECK_STEP(s))
1944	#define T_step_assert_le_ssz(s, a, e) \
1945	T_flags_le_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1946
1947	#define T_lt_ssz(a, e) T_flags_lt_long(a, e, 0)
1948	#define T_assert_lt_ssz(a, e) T_flags_lt_long(a, e, T_CHECK_STOP)
1949	#define T_quiet_lt_ssz(a, e) T_flags_lt_long(a, e, T_CHECK_QUIET)
1950	#define T_step_lt_ssz(s, a, e) T_flags_lt_long(a, e, T_CHECK_STEP(s))
1951	#define T_step_assert_lt_ssz(s, a, e) \
1952	T_flags_lt_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1953
1954	/** @} */
1955
1956	/**
1957	* @defgroup RTEMSTestFrameworkChecksSZ Size Checks
1958	*
1959	* @ingroup RTEMSTestFramework
1960	*
1961	* @brief Checks for sizes (size_t).
1962	*
1963	* @{
1964	*/
1965
1966	#define T_eq_sz(a, e) T_flags_eq_ulong(a, e, 0)
1967	#define T_assert_eq_sz(a, e) T_flags_eq_ulong(a, e, T_CHECK_STOP)
1968	#define T_quiet_eq_sz(a, e) T_flags_eq_ulong(a, e, T_CHECK_QUIET)
1969	#define T_step_eq_sz(s, a, e) T_flags_eq_ulong(a, e, T_CHECK_STEP(s))
1970	#define T_step_assert_eq_sz(s, a, e) \
1971	T_flags_eq_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1972
1973	#define T_ne_sz(a, e) T_flags_ne_ulong(a, e, 0)
1974	#define T_assert_ne_sz(a, e) T_flags_ne_ulong(a, e, T_CHECK_STOP)
1975	#define T_quiet_ne_sz(a, e) T_flags_ne_ulong(a, e, T_CHECK_QUIET)
1976	#define T_step_ne_sz(s, a, e) T_flags_ne_ulong(a, e, T_CHECK_STEP(s))
1977	#define T_step_assert_ne_sz(s, a, e) \
1978	T_flags_ne_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1979
1980	#define T_ge_sz(a, e) T_flags_ge_ulong(a, e, 0)
1981	#define T_assert_ge_sz(a, e) T_flags_ge_ulong(a, e, T_CHECK_STOP)
1982	#define T_quiet_ge_sz(a, e) T_flags_ge_ulong(a, e, T_CHECK_QUIET)
1983	#define T_step_ge_sz(s, a, e) T_flags_ge_ulong(a, e, T_CHECK_STEP(s))
1984	#define T_step_assert_ge_sz(s, a, e) \
1985	T_flags_ge_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1986
1987	#define T_gt_sz(a, e) T_flags_gt_ulong(a, e, 0)
1988	#define T_assert_gt_sz(a, e) T_flags_gt_ulong(a, e, T_CHECK_STOP)
1989	#define T_quiet_gt_sz(a, e) T_flags_gt_ulong(a, e, T_CHECK_QUIET)
1990	#define T_step_gt_sz(s, a, e) T_flags_gt_ulong(a, e, T_CHECK_STEP(s))
1991	#define T_step_assert_gt_sz(s, a, e) \
1992	T_flags_gt_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
1993
1994	#define T_le_sz(a, e) T_flags_le_ulong(a, e, 0)
1995	#define T_assert_le_sz(a, e) T_flags_le_ulong(a, e, T_CHECK_STOP)
1996	#define T_quiet_le_sz(a, e) T_flags_le_ulong(a, e, T_CHECK_QUIET)
1997	#define T_step_le_sz(s, a, e) T_flags_le_ulong(a, e, T_CHECK_STEP(s))
1998	#define T_step_assert_le_sz(s, a, e) \
1999	T_flags_le_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
2000
2001	#define T_lt_sz(a, e) T_flags_lt_ulong(a, e, 0)
2002	#define T_assert_lt_sz(a, e) T_flags_lt_ulong(a, e, T_CHECK_STOP)
2003	#define T_quiet_lt_sz(a, e) T_flags_lt_ulong(a, e, T_CHECK_QUIET)
2004	#define T_step_lt_sz(s, a, e) T_flags_lt_ulong(a, e, T_CHECK_STEP(s))
2005	#define T_step_assert_lt_sz(s, a, e) \
2006	T_flags_lt_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
2007
2008	/** @} */
2009
2010	/**
2011	* @defgroup RTEMSTestFrameworkChecksPSX POSIX Status and Error Number Checks
2012	*
2013	* @ingroup RTEMSTestFramework
2014	*
2015	* @brief Checks for POSIX status and error numbers.
2016	*
2017	* @{
2018	*/
2019
2020	const char *T_strerror(int);
2021
2022	#define T_eno(a, e) T_flags_eno(a, e, 0)
2023	#define T_assert_eno(a, e) T_flags_eno(a, e, T_CHECK_STOP)
2024	#define T_quiet_eno(a, e) T_flags_eno(a, e, T_CHECK_QUIET)
2025	#define T_step_eno(s, a, e) T_flags_eno(a, e, T_CHECK_STEP(s))
2026	#define T_step_assert_eno(s, a, e) \
2027	T_flags_eno(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
2028
2029	#define T_eno_success(a) T_flags_eno_success(a, 0)
2030	#define T_assert_eno_success(a) T_flags_eno_success(a, T_CHECK_STOP)
2031	#define T_quiet_eno_success(a) T_flags_eno_success(a, T_CHECK_QUIET)
2032	#define T_step_eno_success(s, a) T_flags_eno_success(a, T_CHECK_STEP(s))
2033	#define T_step_assert_eno_success(s, a) \
2034	T_flags_eno_success(a, T_CHECK_STEP(s) \| T_CHECK_STOP)
2035
2036	#define T_psx_error(a, eno) T_flags_psx_error(a, eno, 0)
2037	#define T_assert_psx_error(a, eno) T_flags_psx_error(a, eno, T_CHECK_STOP)
2038	#define T_quiet_psx_error(a, eno) T_flags_psx_error(a, eno, T_CHECK_QUIET)
2039	#define T_step_psx_error(s, a, eno) T_flags_psx_error(a, eno, T_CHECK_STEP(s))
2040	#define T_step_assert_psx_error(s, a, eno) \
2041	T_flags_psx_error(a, eno, T_CHECK_STEP(s) \| T_CHECK_STOP)
2042
2043	#define T_psx_success(a) T_flags_psx_success(a, 0)
2044	#define T_assert_psx_success(a) T_flags_psx_success(a, T_CHECK_STOP)
2045	#define T_quiet_psx_success(a) T_flags_psx_success(a, T_CHECK_QUIET)
2046	#define T_step_psx_success(s, a) T_flags_psx_success(a, T_CHECK_STEP(s))
2047	#define T_step_assert_psx_success(s, a) \
2048	T_flags_psx_success(a, T_CHECK_STEP(s) \| T_CHECK_STOP)
2049
2050	/** @} */
2051
2052	#ifdef __rtems__
2053	void T_check_rsc(uint32_t, const T_check_context *, uint32_t);
2054
2055	#define T_flags_rsc(a, e, flags) \
2056	{ \
2057	static const T_check_context T_check_instance = { \
2058	T_FILE_NAME, __LINE__, flags }; \
2059	T_check_rsc(a, &T_check_instance, e); \
2060	}
2061
2062	void T_check_rsc_success(uint32_t, const T_check_context *);
2063
2064	#define T_flags_rsc_success(a, flags) \
2065	{ \
2066	static const T_check_context T_check_instance = { \
2067	T_FILE_NAME, __LINE__, flags }; \
2068	T_check_rsc_success(a, &T_check_instance); \
2069	}
2070
2071	/**
2072	* @defgroup RTEMSTestFrameworkChecksRSC RTEMS Status Code Checks
2073	*
2074	* @ingroup RTEMSTestFramework
2075	*
2076	* @brief Checks for RTEMS status codes (rtems_status_code).
2077	*
2078	* @{
2079	*/
2080
2081	#define T_rsc(a, e) T_flags_rsc(a, e, 0)
2082	#define T_assert_rsc(a, e) T_flags_rsc(a, e, T_CHECK_STOP)
2083	#define T_quiet_rsc(a, e) T_flags_rsc(a, e, T_CHECK_QUIET)
2084	#define T_step_rsc(s, a, e) T_flags_rsc(a, e, T_CHECK_STEP(s))
2085	#define T_step_assert_rsc(s, a, e) \
2086	T_flags_rsc(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)
2087
2088	#define T_rsc_success(a) T_flags_rsc_success(a, 0)
2089	#define T_assert_rsc_success(a) T_flags_rsc_success(a, T_CHECK_STOP)
2090	#define T_quiet_rsc_success(a) T_flags_rsc_success(a, T_CHECK_QUIET)
2091	#define T_step_rsc_success(s, a) T_flags_rsc_success(a, T_CHECK_STEP(s))
2092	#define T_step_assert_rsc_success(s, a) \
2093	T_flags_rsc_success(a, T_CHECK_STEP(s) \| T_CHECK_STOP)
2094
2095	/** @} */
2096	#endif /* __rtems__ */
2097
2098	void T_plan(unsigned int);
2099
2100	#define T_step(s, ...) T_flags_true(true, T_CHECK_STEP(s), __VA_ARGS__)
2101	#define T_step_assert(s, ...) \
2102	T_flags_true(true, T_CHECK_STEP(s) \| T_CHECK_STOP, __VA_ARGS__)
2103
2104	/**
2105	* @defgroup RTEMSTestFrameworkTime Time Services
2106	*
2107	* @ingroup RTEMSTestFramework
2108	*
2109	* @brief Time service functions.
2110	*
2111	* @{
2112	*/
2113
2114	#ifdef __rtems__
2115	typedef CPU_Counter_ticks T_ticks;
2116	#else
2117	typedef unsigned long T_ticks;
2118	#endif
2119
2120	typedef uint64_t T_time;
2121
2122	/* More than enough for sizeof("18446744073.709552765") */
2123	typedef char T_time_string[24];
2124
2125	const char *T_time_to_string_ns(T_time, T_time_string);
2126
2127	const char *T_time_to_string_us(T_time, T_time_string);
2128
2129	const char *T_time_to_string_ms(T_time, T_time_string);
2130
2131	const char *T_time_to_string_s(T_time, T_time_string);
2132
2133	const char *T_ticks_to_string_ns(T_ticks, T_time_string);
2134
2135	const char *T_ticks_to_string_us(T_ticks, T_time_string);
2136
2137	const char *T_ticks_to_string_ms(T_ticks, T_time_string);
2138
2139	const char *T_ticks_to_string_s(T_ticks, T_time_string);
2140
2141	T_time T_ticks_to_time(T_ticks);
2142
2143	T_ticks T_time_to_ticks(T_time);
2144
2145	T_time T_seconds_and_nanoseconds_to_time(uint32_t, uint32_t);
2146
2147	void T_time_to_seconds_and_nanoseconds(T_time, uint32_t , uint32_t );
2148
2149	#ifdef __rtems__
2150	int64_t _Timecounter_Sbinuptime(void);
2151
2152	static inline T_time
2153	T_now(void)
2154	{
2155	return (T_time)_Timecounter_Sbinuptime();
2156	}
2157
2158	static inline T_ticks
2159	T_tick(void)
2160	{
2161	return _CPU_Counter_read();
2162	}
2163	#else
2164	T_time T_now(void);
2165
2166	T_ticks T_tick(void);
2167	#endif
2168
2169	T_time T_now_dummy(void);
2170
2171	T_time T_now_via_tick(void);
2172
2173	T_time T_case_begin_time(void);
2174
2175	/** @} */
2176
2177	void *T_malloc(size_t);
2178
2179	void *T_calloc(size_t, size_t);
2180
2181	void T_zalloc(size_t, void ()(void *));
2182
2183	void T_free(void *);
2184
2185	void T_register(void);
2186
2187	typedef enum {
2188	T_EVENT_RUN_INITIALIZE,
2189	T_EVENT_CASE_EARLY,
2190	T_EVENT_CASE_BEGIN,
2191	T_EVENT_CASE_END,
2192	T_EVENT_CASE_LATE,
2193	T_EVENT_RUN_FINALIZE
2194	} T_event;
2195
2196	typedef void (T_action)(T_event, const char );
2197
2198	typedef void (T_putchar)(int, void );
2199
2200	typedef struct {
2201	const char *name;
2202	T_putchar putchar;
2203	void *putchar_arg;
2204	T_verbosity verbosity;
2205	T_time (*now)(void);
2206	size_t action_count;
2207	const T_action *actions;
2208	} T_config;
2209
2210	void T_putchar_default(int, void *);
2211
2212	int T_main(const T_config *);
2213
2214	bool T_is_runner(void);
2215
2216	void T_run_initialize(const T_config *);
2217
2218	void T_run_all(void);
2219
2220	void T_run_by_name(const char *);
2221
2222	void T_case_begin(const char , const T_fixture );
2223
2224	void T_case_end(void);
2225
2226	bool T_run_finalize(void);
2227
2228	void T_set_putchar(T_putchar, void , T_putchar , void **);
2229
2230	void *T_fixture_context(void);
2231
2232	void T_set_fixture_context(void *);
2233
2234	#ifdef __rtems__
2235	#define T_TEST_CASE_FIXTURE(name, fixture) \
2236	void T_case_body_##name(void); \
2237	T_case_context T_case_instance_##name = { \
2238	#name, \
2239	T_case_body_##name, \
2240	fixture, \
2241	NULL \
2242	}; \
2243	static T_case_context * const T_case_item_##name \
2244	__attribute((__section__(".rtemsroset._T.content.0." #name))) \
2245	__attribute((__used__)) = &T_case_instance_##name; \
2246	void T_case_body_##name(void)
2247	#else /* __rtems__ */
2248	#define T_TEST_CASE_FIXTURE(name, fixture) \
2249	void T_case_body_##name(void); \
2250	T_case_context T_case_instance_##name = { \
2251	#name, \
2252	T_case_body_##name, \
2253	fixture, \
2254	NULL \
2255	}; \
2256	__attribute((__constructor__)) static void \
2257	T_case_register_##name(void) \
2258	{ \
2259	T_case_register(&T_case_instance_##name); \
2260	} \
2261	void T_case_body_##name(void)
2262	#endif /* __rtems__ */
2263
2264	#define T_TEST_CASE(name) T_TEST_CASE_FIXTURE(name, NULL)
2265
2266	void T_report_hash_sha256(T_event, const char *);
2267
2268	void T_check_heap(T_event, const char *);
2269
2270	#ifdef __rtems__
2271	void T_check_file_descriptors(T_event, const char *);
2272
2273	void T_check_rtems_barriers(T_event, const char *);
2274
2275	void T_check_rtems_extensions(T_event, const char *);
2276
2277	void T_check_rtems_message_queues(T_event, const char *);
2278
2279	void T_check_rtems_partitions(T_event, const char *);
2280
2281	void T_check_rtems_periods(T_event, const char *);
2282
2283	void T_check_rtems_regions(T_event, const char *);
2284
2285	void T_check_rtems_semaphores(T_event, const char *);
2286
2287	void T_check_rtems_tasks(T_event, const char *);
2288
2289	void T_check_rtems_timers(T_event, const char *);
2290
2291	void T_check_posix_keys(T_event, const char *);
2292
2293	void T_check_posix_message_queues(T_event, const char *);
2294
2295	void T_check_posix_semaphores(T_event, const char *);
2296
2297	void T_check_posix_shms(T_event, const char *);
2298
2299	void T_check_posix_threads(T_event, const char *);
2300
2301	void T_check_posix_timers(T_event, const char *);
2302	#endif /* __rtems__ */
2303
2304	/**
2305	* @defgroup RTEMSTestFrameworkDestructors Destructors
2306	*
2307	* @ingroup RTEMSTestFramework
2308	*
2309	* @brief Support to run destructors at the end of a test case.
2310	*
2311	* @{
2312	*/
2313
2314	typedef struct T_destructor {
2315	struct {
2316	struct T_destructor *le_next;
2317	struct T_destructor **le_prev;
2318	} node;
2319	void (destroy)(struct T_destructor );
2320	} T_destructor;
2321
2322	void T_add_destructor(T_destructor , void ()(T_destructor *));
2323
2324	void T_remove_destructor(T_destructor *);
2325
2326	/** @} */
2327
2328	/**
2329	* @defgroup RTEMSTestFrameworkMeasureRuntime Runtime Measurements
2330	*
2331	* @ingroup RTEMSTestFramework
2332	*
2333	* @brief Support to measure the runtime of code fragments.
2334	*
2335	* @{
2336	*/
2337
2338	typedef struct T_measure_runtime_context T_measure_runtime_context;
2339
2340	typedef struct {
2341	size_t sample_count;
2342	} T_measure_runtime_config;
2343
2344	typedef struct {
2345	const char *name;
2346	int flags;
2347	void (setup)(void );
2348	void (body)(void );
2349	bool (teardown)(void , T_ticks *, uint32_t, uint32_t, unsigned int);
2350	void *arg;
2351	} T_measure_runtime_request;
2352
2353	#define T_MEASURE_RUNTIME_ALLOW_CLOCK_ISR 0x1
2354
2355	#define T_MEASURE_RUNTIME_REPORT_SAMPLES 0x2
2356
2357	#define T_MEASURE_RUNTIME_DISABLE_VALID_CACHE 0x10
2358
2359	#define T_MEASURE_RUNTIME_DISABLE_HOT_CACHE 0x20
2360
2361	#define T_MEASURE_RUNTIME_DISABLE_DIRTY_CACHE 0x40
2362
2363	#define T_MEASURE_RUNTIME_DISABLE_MINOR_LOAD 0x80
2364
2365	#define T_MEASURE_RUNTIME_DISABLE_MAX_LOAD 0x100
2366
2367	T_measure_runtime_context *T_measure_runtime_create(
2368	const T_measure_runtime_config *);
2369
2370	void T_measure_runtime(T_measure_runtime_context *,
2371	const T_measure_runtime_request *);
2372
2373	/** @} */
2374
2375	#ifdef __cplusplus
2376	}
2377	#endif /* __cplusplus */
2378
2379	#endif /* THE_T_TEST_FRAMEWORK_H */

Note: See TracBrowser for help on using the repository browser.

Download in other formats: