Context Navigation

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

5

Last change on this file since cfcc2cbf was cfcc2cbf, checked in by Sebastian Huber <sebastian.huber@…>, on 01/31/19 at 13:45:31

Add RTEMS Test Framework

Update #3199.

Property mode set to 100644

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

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

Download in other formats: