test.cpp@ 98456

Last change on this file since 98456 was 98103, checked in by vboxsync, 2 years ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 58.8 KB

Line
1	/* $Id: test.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
2	/** @file
3	* IPRT - Testcase Framework.
4	*/
5
6	/*
7	* Copyright (C) 2009-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* The contents of this file may alternatively be used under the terms
26	* of the Common Development and Distribution License Version 1.0
27	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
28	* in the VirtualBox distribution, in which case the provisions of the
29	* CDDL are applicable instead of those of the GPL.
30	*
31	* You may elect to license modified versions of this file under the
32	* terms and conditions of either the GPL or the CDDL or both.
33	*
34	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
35	*/
36
37
38	/*********************************************************************************************************************************
39	* Header Files *
40	*********************************************************************************************************************************/
41	#include <iprt/test.h>
42
43	#include <iprt/asm.h>
44	#include <iprt/critsect.h>
45	#include <iprt/env.h>
46	#include <iprt/err.h>
47	#include <iprt/file.h>
48	#include <iprt/initterm.h>
49	#include <iprt/mem.h>
50	#include <iprt/once.h>
51	#include <iprt/param.h>
52	#include <iprt/pipe.h>
53	#include <iprt/string.h>
54	#include <iprt/stream.h>
55
56	#include "internal/magics.h"
57
58
59	/*********************************************************************************************************************************
60	* Structures and Typedefs *
61	*********************************************************************************************************************************/
62	/**
63	* Guarded memory allocation record.
64	*/
65	typedef struct RTTESTGUARDEDMEM
66	{
67	/** Pointer to the next record. */
68	struct RTTESTGUARDEDMEM *pNext;
69	/** The address we return to the user. */
70	void *pvUser;
71	/** The base address of the allocation. */
72	void *pvAlloc;
73	/** The size of the allocation. */
74	size_t cbAlloc;
75	/** Guards. */
76	struct
77	{
78	/** The guard address. */
79	void *pv;
80	/** The guard size. */
81	size_t cb;
82	} aGuards[2];
83	} RTTESTGUARDEDMEM;
84	/** Pointer to an guarded memory allocation. */
85	typedef RTTESTGUARDEDMEM *PRTTESTGUARDEDMEM;
86
87	/**
88	* Test instance structure.
89	*/
90	typedef struct RTTESTINT
91	{
92	/** Magic. */
93	uint32_t u32Magic;
94	/** The number of errors. */
95	volatile uint32_t cErrors;
96	/** The test name. */
97	const char *pszTest;
98	/** The length of the test name. */
99	size_t cchTest;
100	/** The size of a guard. Multiple of PAGE_SIZE. */
101	uint32_t cbGuard;
102	/** The verbosity level. */
103	RTTESTLVL enmMaxLevel;
104	/** The creation flags. */
105	uint32_t fFlags;
106
107
108	/** Critical section serializing output. */
109	RTCRITSECT OutputLock;
110	/** The output stream. */
111	PRTSTREAM pOutStrm;
112	/** Whether we're currently at a newline. */
113	bool fNewLine;
114
115
116	/** Critical section serializing access to the members following it. */
117	RTCRITSECT Lock;
118
119	/** The list of guarded memory allocations. */
120	PRTTESTGUARDEDMEM pGuardedMem;
121
122	/** The current sub-test. */
123	const char *pszSubTest;
124	/** The length of the sub-test name. */
125	size_t cchSubTest;
126	/** Whether the current subtest should figure as 'SKIPPED'. */
127	bool fSubTestSkipped;
128	/** Whether we've reported the sub-test result or not. */
129	bool fSubTestReported;
130	/** The start error count of the current subtest. */
131	uint32_t cSubTestAtErrors;
132
133	/** The number of sub tests. */
134	uint32_t cSubTests;
135	/** The number of sub tests that failed. */
136	uint32_t cSubTestsFailed;
137
138	/** Error context message. */
139	char *pszErrCtx;
140
141	/** Set if XML output is enabled. */
142	bool fXmlEnabled;
143	/** Set if we omit the top level test in the XML report. */
144	bool fXmlOmitTopTest;
145	/** Set if we've reported the top test (for RTTEST_C_XML_DELAY_TOP_TEST). */
146	bool fXmlTopTestDone;
147	enum {
148	kXmlPos_ValueStart,
149	kXmlPos_Value,
150	kXmlPos_ElementEnd
151	} eXmlState;
152	/** Test pipe for the XML output stream going to the server. */
153	RTPIPE hXmlPipe;
154	/** File where the XML output stream might be directed. */
155	RTFILE hXmlFile;
156	/** The number of XML elements on the stack. */
157	size_t cXmlElements;
158	/** XML element stack. */
159	const char *apszXmlElements[10];
160
161	/** Number of times assertions has been disabled and quieted. */
162	uint32_t volatile cAssertionsDisabledAndQuieted;
163	/** Saved RTAssertSetQuiet return code. */
164	bool fAssertSavedQuiet;
165	/** Saved RTAssertSetMayPanic return code. */
166	bool fAssertSavedMayPanic;
167	} RTTESTINT;
168	/** Pointer to a test instance. */
169	typedef RTTESTINT *PRTTESTINT;
170
171
172	/*********************************************************************************************************************************
173	* Defined Constants And Macros *
174	*********************************************************************************************************************************/
175	/** Validate a test instance. */
176	#define RTTEST_VALID_RETURN(pTest) \
177	do { \
178	AssertPtrReturn(pTest, VERR_INVALID_HANDLE); \
179	AssertReturn(pTest->u32Magic == RTTESTINT_MAGIC, VERR_INVALID_HANDLE); \
180	} while (0)
181
182	/** Gets and validates a test instance.
183	* If the handle is nil, we will try retrieve it from the test TLS entry.
184	*/
185	#define RTTEST_GET_VALID_RETURN(pTest) \
186	do { \
187	if (pTest == NIL_RTTEST) \
188	pTest = (PRTTESTINT)RTTlsGet(g_iTestTls); \
189	AssertPtrReturn(pTest, VERR_INVALID_HANDLE); \
190	AssertReturn(pTest->u32Magic == RTTESTINT_MAGIC, VERR_INVALID_MAGIC); \
191	} while (0)
192
193
194	/** Gets and validates a test instance.
195	* If the handle is nil, we will try retrieve it from the test TLS entry.
196	*/
197	#define RTTEST_GET_VALID_RETURN_RC(pTest, rc) \
198	do { \
199	if (pTest == NIL_RTTEST) \
200	pTest = (PRTTESTINT)RTTlsGet(g_iTestTls); \
201	AssertPtrReturn(pTest, (rc)); \
202	AssertReturn(pTest->u32Magic == RTTESTINT_MAGIC, (rc)); \
203	} while (0)
204
205
206	/*********************************************************************************************************************************
207	* Internal Functions *
208	*********************************************************************************************************************************/
209	static void rtTestGuardedFreeOne(PRTTESTGUARDEDMEM pMem);
210	static int rtTestPrintf(PRTTESTINT pTest, const char *pszFormat, ...);
211	static void rtTestXmlStart(PRTTESTINT pTest, const char *pszTest);
212	static void rtTestXmlElemV(PRTTESTINT pTest, const char pszTag, const char pszAttrFmt, va_list va);
213	static void rtTestXmlElem(PRTTESTINT pTest, const char pszTag, const char pszAttrFmt, ...);
214	static void rtTestXmlElemStartV(PRTTESTINT pTest, const char pszTag, const char pszAttrFmt, va_list va);
215	static void rtTestXmlElemStart(PRTTESTINT pTest, const char pszTag, const char pszAttrFmt, ...);
216	static void rtTestXmlElemEnd(PRTTESTINT pTest, const char *pszTag);
217	static void rtTestXmlEnd(PRTTESTINT pTest);
218
219
220	/*********************************************************************************************************************************
221	* Global Variables *
222	*********************************************************************************************************************************/
223	/** For serializing TLS init. */
224	static RTONCE g_TestInitOnce = RTONCE_INITIALIZER;
225	/** Our TLS entry. */
226	static RTTLS g_iTestTls = NIL_RTTLS;
227
228
229
230	/**
231	* Init TLS index once.
232	*
233	* @returns IPRT status code.
234	* @param pvUser Ignored.
235	*/
236	static DECLCALLBACK(int32_t) rtTestInitOnce(void *pvUser)
237	{
238	NOREF(pvUser);
239	return RTTlsAllocEx(&g_iTestTls, NULL);
240	}
241
242
243	RTR3DECL(int) RTTestCreateEx(const char *pszTest, uint32_t fFlags, RTTESTLVL enmMaxLevel,
244	RTHCINTPTR iNativeTestPipe, const char *pszXmlFile, PRTTEST phTest)
245	{
246	AssertReturn(!(fFlags & ~RTTEST_C_VALID_MASK), VERR_INVALID_PARAMETER);
247	AssertPtrNull(phTest);
248	AssertPtrNull(pszXmlFile);
249	/* RTTESTLVL_INVALID is valid! */
250	AssertReturn(enmMaxLevel >= RTTESTLVL_INVALID && enmMaxLevel < RTTESTLVL_END, VERR_INVALID_PARAMETER);
251
252	/*
253	* Global init.
254	*/
255	int rc = RTOnce(&g_TestInitOnce, rtTestInitOnce, NULL);
256	if (RT_FAILURE(rc))
257	return rc;
258
259	/*
260	* Create the instance.
261	*/
262	PRTTESTINT pTest = (PRTTESTINT)RTMemAllocZ(sizeof(*pTest));
263	if (!pTest)
264	return VERR_NO_MEMORY;
265	pTest->u32Magic = RTTESTINT_MAGIC;
266	pTest->pszTest = RTStrDup(pszTest);
267	pTest->cchTest = strlen(pszTest);
268	pTest->cbGuard = PAGE_SIZE * 7;
269	pTest->enmMaxLevel = enmMaxLevel == RTTESTLVL_INVALID ? RTTESTLVL_INFO : enmMaxLevel;
270	pTest->fFlags = fFlags;
271
272	pTest->pOutStrm = g_pStdOut;
273	pTest->fNewLine = true;
274
275	pTest->pGuardedMem = NULL;
276
277	pTest->pszSubTest = NULL;
278	pTest->cchSubTest = 0;
279	pTest->fSubTestSkipped = false;
280	pTest->fSubTestReported = true;
281	pTest->cSubTestAtErrors = 0;
282	pTest->cSubTests = 0;
283	pTest->cSubTestsFailed = 0;
284
285	pTest->fXmlEnabled = false;
286	pTest->fXmlTopTestDone = false;
287	pTest->eXmlState = RTTESTINT::kXmlPos_ElementEnd;
288	pTest->hXmlPipe = NIL_RTPIPE;
289	pTest->hXmlFile = NIL_RTFILE;
290	pTest->cXmlElements = 0;
291	pTest->cAssertionsDisabledAndQuieted = 0;
292	pTest->fAssertSavedMayPanic = true;
293	pTest->fAssertSavedQuiet = false;
294
295	rc = RTCritSectInit(&pTest->Lock);
296	if (RT_SUCCESS(rc))
297	{
298	rc = RTCritSectInit(&pTest->OutputLock);
299	if (RT_SUCCESS(rc))
300	{
301	/*
302	* Associate it with our TLS entry unless there is already
303	* an instance there.
304	*/
305	if ( !(fFlags & RTTEST_C_NO_TLS)
306	&& !RTTlsGet(g_iTestTls))
307	rc = RTTlsSet(g_iTestTls, pTest);
308	if (RT_SUCCESS(rc))
309	{
310	/*
311	* Output level override?
312	*/
313	char szEnvVal[RTPATH_MAX];
314	if ((fFlags & RTTEST_C_USE_ENV) && enmMaxLevel == RTTESTLVL_INVALID)
315	{
316	rc = RTEnvGetEx(RTENV_DEFAULT, "IPRT_TEST_MAX_LEVEL", szEnvVal, sizeof(szEnvVal), NULL);
317	if (RT_SUCCESS(rc))
318	{
319	char *pszMaxLevel = RTStrStrip(szEnvVal);
320	if (!strcmp(pszMaxLevel, "all"))
321	pTest->enmMaxLevel = RTTESTLVL_DEBUG;
322	if (!strcmp(pszMaxLevel, "quiet"))
323	pTest->enmMaxLevel = RTTESTLVL_FAILURE;
324	else if (!strcmp(pszMaxLevel, "debug"))
325	pTest->enmMaxLevel = RTTESTLVL_DEBUG;
326	else if (!strcmp(pszMaxLevel, "info"))
327	pTest->enmMaxLevel = RTTESTLVL_INFO;
328	else if (!strcmp(pszMaxLevel, "sub_test"))
329	pTest->enmMaxLevel = RTTESTLVL_SUB_TEST;
330	else if (!strcmp(pszMaxLevel, "failure"))
331	pTest->enmMaxLevel = RTTESTLVL_FAILURE;
332	}
333	else if (rc != VERR_ENV_VAR_NOT_FOUND)
334	RTStrmPrintf(g_pStdErr, "%s: test pipe error: RTEnvGetEx(IPRT_TEST_MAX_LEVEL) -> %Rrc\n", pszTest, rc);
335	}
336
337	/*
338	* Any test driver we are connected or should connect to?
339	*/
340	if (!(fFlags & RTTEST_C_NO_XML_REPORTING_PIPE))
341	{
342	if ( (fFlags & RTTEST_C_USE_ENV)
343	&& iNativeTestPipe == -1)
344	{
345	rc = RTEnvGetEx(RTENV_DEFAULT, "IPRT_TEST_PIPE", szEnvVal, sizeof(szEnvVal), NULL);
346	if (RT_SUCCESS(rc))
347	{
348	#if ARCH_BITS == 64
349	rc = RTStrToInt64Full(szEnvVal, 0, &iNativeTestPipe);
350	#else
351	rc = RTStrToInt32Full(szEnvVal, 0, &iNativeTestPipe);
352	#endif
353	if (RT_FAILURE(rc))
354	{
355	RTStrmPrintf(g_pStdErr, "%s: test pipe error: RTStrToInt32Full(\"%s\") -> %Rrc\n",
356	pszTest, szEnvVal, rc);
357	iNativeTestPipe = -1;
358	}
359	}
360	else if (rc != VERR_ENV_VAR_NOT_FOUND)
361	RTStrmPrintf(g_pStdErr, "%s: test pipe error: RTEnvGetEx(IPRT_TEST_PIPE) -> %Rrc\n", pszTest, rc);
362	}
363	if (iNativeTestPipe != -1)
364	{
365	rc = RTPipeFromNative(&pTest->hXmlPipe, iNativeTestPipe, RTPIPE_N_WRITE);
366	if (RT_SUCCESS(rc))
367	pTest->fXmlEnabled = true;
368	else
369	{
370	RTStrmPrintf(g_pStdErr, "%s: test pipe error: RTPipeFromNative(,%p,WRITE) -> %Rrc\n",
371	pszTest, iNativeTestPipe, rc);
372	pTest->hXmlPipe = NIL_RTPIPE;
373	}
374	}
375	}
376
377	/*
378	* Any test file we should write the test report to?
379	*/
380	if (!(fFlags & RTTEST_C_NO_XML_REPORTING_FILE))
381	{
382	if ((fFlags & RTTEST_C_USE_ENV) && pszXmlFile == NULL)
383	{
384	rc = RTEnvGetEx(RTENV_DEFAULT, "IPRT_TEST_FILE", szEnvVal, sizeof(szEnvVal), NULL);
385	if (RT_SUCCESS(rc))
386	pszXmlFile = szEnvVal;
387	else if (rc != VERR_ENV_VAR_NOT_FOUND)
388	RTStrmPrintf(g_pStdErr, "%s: test file error: RTEnvGetEx(IPRT_TEST_MAX_LEVEL) -> %Rrc\n", pszTest, rc);
389	}
390	if (pszXmlFile && *pszXmlFile)
391	{
392	rc = RTFileOpen(&pTest->hXmlFile, pszXmlFile,
393	RTFILE_O_WRITE \| RTFILE_O_DENY_WRITE \| RTFILE_O_OPEN_CREATE \| RTFILE_O_TRUNCATE);
394	if (RT_SUCCESS(rc))
395	pTest->fXmlEnabled = true;
396	else
397	{
398	RTStrmPrintf(g_pStdErr, "%s: test file error: RTFileOpen(,\"%s\",) -> %Rrc\n",
399	pszTest, pszXmlFile, rc);
400	pTest->hXmlFile = NIL_RTFILE;
401	}
402	}
403	}
404
405	/*
406	* What do we report in the XML stream/file.?
407	*/
408	pTest->fXmlOmitTopTest = (fFlags & RTTEST_C_XML_OMIT_TOP_TEST)
409	\|\| ( (fFlags & RTTEST_C_USE_ENV)
410	&& RTEnvExistEx(RTENV_DEFAULT, "IPRT_TEST_OMIT_TOP_TEST"));
411
412	/*
413	* Tell the test driver that we're up to.
414	*/
415	rtTestXmlStart(pTest, pszTest);
416
417	*phTest = pTest;
418	return VINF_SUCCESS;
419	}
420
421	/* bail out. */
422	RTCritSectDelete(&pTest->OutputLock);
423	}
424	RTCritSectDelete(&pTest->Lock);
425	}
426	pTest->u32Magic = 0;
427	RTStrFree((char *)pTest->pszTest);
428	RTMemFree(pTest);
429	return rc;
430	}
431
432
433	RTR3DECL(int) RTTestCreate(const char *pszTest, PRTTEST phTest)
434	{
435	return RTTestCreateEx(pszTest, RTTEST_C_USE_ENV, RTTESTLVL_INVALID, -1 /iNativeTestPipe/, NULL /pszXmlFile/, phTest);
436	}
437
438
439	RTR3DECL(int) RTTestCreateChild(const char *pszTest, PRTTEST phTest)
440	{
441	return RTTestCreateEx(pszTest, RTTEST_C_USE_ENV \| RTTEST_C_NO_XML_REPORTING,
442	RTTESTLVL_INVALID, -1 /iNativeTestPipe/, NULL /pszXmlFile/, phTest);
443	}
444
445
446	RTR3DECL(RTEXITCODE) RTTestInitAndCreate(const char *pszTest, PRTTEST phTest)
447	{
448	int rc = RTR3InitExeNoArguments(0);
449	if (RT_FAILURE(rc))
450	{
451	RTStrmPrintf(g_pStdErr, "%s: fatal error: RTR3InitExeNoArguments failed with rc=%Rrc\n", pszTest, rc);
452	return RTEXITCODE_INIT;
453	}
454
455	rc = RTTestCreate(pszTest, phTest);
456	if (RT_FAILURE(rc))
457	{
458	RTStrmPrintf(g_pStdErr, "%s: fatal error: RTTestCreate failed with rc=%Rrc\n", pszTest, rc);
459	return RTEXITCODE_INIT;
460	}
461	return RTEXITCODE_SUCCESS;
462	}
463
464
465	RTR3DECL(RTEXITCODE) RTTestInitExAndCreate(int cArgs, char **ppapszArgs, uint32_t fRtInit, const char pszTest, PRTTEST phTest)
466	{
467	int rc;
468	if (cArgs <= 0 && ppapszArgs == NULL)
469	rc = RTR3InitExeNoArguments(fRtInit);
470	else
471	rc = RTR3InitExe(cArgs, ppapszArgs, fRtInit);
472	if (RT_FAILURE(rc))
473	{
474	RTStrmPrintf(g_pStdErr, "%s: fatal error: RTR3InitExe(,,%#x) failed with rc=%Rrc\n", pszTest, fRtInit, rc);
475	return RTEXITCODE_INIT;
476	}
477
478	rc = RTTestCreate(pszTest, phTest);
479	if (RT_FAILURE(rc))
480	{
481	RTStrmPrintf(g_pStdErr, "%s: fatal error: RTTestCreate failed with rc=%Rrc\n", pszTest, rc);
482	return RTEXITCODE_INIT;
483	}
484	return RTEXITCODE_SUCCESS;
485	}
486
487
488	/**
489	* Destroys a test instance previously created by RTTestCreate.
490	*
491	* @returns IPRT status code.
492	* @param hTest The test handle. NIL_RTTEST is ignored.
493	*/
494	RTR3DECL(int) RTTestDestroy(RTTEST hTest)
495	{
496	/*
497	* Validate
498	*/
499	if (hTest == NIL_RTTEST)
500	return VINF_SUCCESS;
501	RTTESTINT *pTest = hTest;
502	RTTEST_VALID_RETURN(pTest);
503
504	/*
505	* Make sure we end with a new line and have finished up the XML.
506	*/
507	if (!pTest->fNewLine)
508	rtTestPrintf(pTest, "\n");
509	rtTestXmlEnd(pTest);
510
511	/*
512	* Clean up.
513	*/
514	if ((RTTESTINT *)RTTlsGet(g_iTestTls) == pTest)
515	RTTlsSet(g_iTestTls, NULL);
516
517	ASMAtomicWriteU32(&pTest->u32Magic, ~RTTESTINT_MAGIC);
518	RTCritSectDelete(&pTest->Lock);
519	RTCritSectDelete(&pTest->OutputLock);
520
521	/* free guarded memory. */
522	PRTTESTGUARDEDMEM pMem = pTest->pGuardedMem;
523	pTest->pGuardedMem = NULL;
524	while (pMem)
525	{
526	PRTTESTGUARDEDMEM pFree = pMem;
527	pMem = pMem->pNext;
528	rtTestGuardedFreeOne(pFree);
529	}
530
531	RTStrFree((char *)pTest->pszSubTest);
532	pTest->pszSubTest = NULL;
533	RTStrFree((char *)pTest->pszTest);
534	pTest->pszTest = NULL;
535	RTStrFree(pTest->pszErrCtx);
536	pTest->pszErrCtx = NULL;
537	RTMemFree(pTest);
538	return VINF_SUCCESS;
539	}
540
541
542	/**
543	* Changes the default test instance for the calling thread.
544	*
545	* @returns IPRT status code.
546	*
547	* @param hNewDefaultTest The new default test. NIL_RTTEST is fine.
548	* @param phOldTest Where to store the old test handle. Optional.
549	*/
550	RTR3DECL(int) RTTestSetDefault(RTTEST hNewDefaultTest, PRTTEST phOldTest)
551	{
552	if (phOldTest)
553	*phOldTest = (RTTEST)RTTlsGet(g_iTestTls);
554	return RTTlsSet(g_iTestTls, hNewDefaultTest);
555	}
556
557
558	RTR3DECL(int) RTTestChangeName(RTTEST hTest, const char *pszName)
559	{
560	PRTTESTINT pTest = hTest;
561	RTTEST_GET_VALID_RETURN(pTest);
562	AssertPtrReturn(pszName, VERR_INVALID_POINTER);
563	AssertReturn(*pszName, VERR_INVALID_PARAMETER);
564
565	size_t cchName = strlen(pszName);
566	AssertReturn(cchName < 128, VERR_INVALID_PARAMETER);
567	char *pszDupName = RTStrDup(pszName);
568	if (!pszDupName)
569	return VERR_NO_STR_MEMORY;
570
571	RTCritSectEnter(&pTest->Lock);
572	RTCritSectEnter(&pTest->OutputLock);
573
574	char pszOldName = (char )pTest->pszTest;
575	pTest->pszTest = pszDupName;
576	pTest->cchTest = cchName;
577
578	RTCritSectLeave(&pTest->OutputLock);
579	RTCritSectLeave(&pTest->Lock);
580
581	RTStrFree(pszOldName);
582	return VINF_SUCCESS;
583	}
584
585
586	/**
587	* Allocate a block of guarded memory.
588	*
589	* @returns IPRT status code.
590	* @param hTest The test handle. If NIL_RTTEST we'll use the one
591	* associated with the calling thread.
592	* @param cb The amount of memory to allocate.
593	* @param cbAlign The alignment of the returned block.
594	* @param fHead Head or tail optimized guard.
595	* @param ppvUser Where to return the pointer to the block.
596	*/
597	RTR3DECL(int) RTTestGuardedAlloc(RTTEST hTest, size_t cb, uint32_t cbAlign, bool fHead, void **ppvUser)
598	{
599	PRTTESTINT pTest = hTest;
600	RTTEST_GET_VALID_RETURN(pTest);
601	if (cbAlign == 0)
602	cbAlign = 1;
603	AssertReturn(cbAlign <= PAGE_SIZE, VERR_INVALID_PARAMETER);
604	AssertReturn(cbAlign == (UINT32_C(1) << (ASMBitFirstSetU32(cbAlign) - 1)), VERR_INVALID_PARAMETER);
605
606	/*
607	* Allocate the record and block and initialize them.
608	*/
609	int rc = VERR_NO_MEMORY;
610	PRTTESTGUARDEDMEM pMem = (PRTTESTGUARDEDMEM)RTMemAlloc(sizeof(*pMem));
611	if (RT_LIKELY(pMem))
612	{
613	size_t const cbAligned = RT_ALIGN_Z(cb, PAGE_SIZE);
614	pMem->aGuards[0].cb = pMem->aGuards[1].cb = pTest->cbGuard;
615	pMem->cbAlloc = pMem->aGuards[0].cb + pMem->aGuards[1].cb + cbAligned;
616	pMem->pvAlloc = RTMemPageAlloc(pMem->cbAlloc);
617	if (pMem->pvAlloc)
618	{
619	pMem->aGuards[0].pv = pMem->pvAlloc;
620	pMem->pvUser = (uint8_t *)pMem->pvAlloc + pMem->aGuards[0].cb;
621	pMem->aGuards[1].pv = (uint8_t *)pMem->pvUser + cbAligned;
622	if (!fHead)
623	{
624	size_t off = cb & PAGE_OFFSET_MASK;
625	if (off)
626	{
627	off = PAGE_SIZE - RT_ALIGN_Z(off, cbAlign);
628	pMem->pvUser = (uint8_t *)pMem->pvUser + off;
629	}
630	}
631
632	/*
633	* Set up the guards and link the record.
634	*/
635	ASMMemFill32(pMem->aGuards[0].pv, pMem->aGuards[0].cb, 0xdeadbeef);
636	ASMMemFill32(pMem->aGuards[1].pv, pMem->aGuards[1].cb, 0xdeadbeef);
637	rc = RTMemProtect(pMem->aGuards[0].pv, pMem->aGuards[0].cb, RTMEM_PROT_NONE);
638	if (RT_SUCCESS(rc))
639	{
640	rc = RTMemProtect(pMem->aGuards[1].pv, pMem->aGuards[1].cb, RTMEM_PROT_NONE);
641	if (RT_SUCCESS(rc))
642	{
643	*ppvUser = pMem->pvUser;
644
645	RTCritSectEnter(&pTest->Lock);
646	pMem->pNext = pTest->pGuardedMem;
647	pTest->pGuardedMem = pMem;
648	RTCritSectLeave(&pTest->Lock);
649
650	return VINF_SUCCESS;
651	}
652
653	RTMemProtect(pMem->aGuards[0].pv, pMem->aGuards[0].cb, RTMEM_PROT_WRITE \| RTMEM_PROT_READ);
654	}
655
656	RTMemPageFree(pMem->pvAlloc, pMem->cbAlloc);
657	}
658	RTMemFree(pMem);
659	}
660	return rc;
661	}
662
663
664	/**
665	* Allocates a block of guarded memory where the guarded is immediately after
666	* the user memory.
667	*
668	* @returns Pointer to the allocated memory. NULL on failure.
669	* @param hTest The test handle. If NIL_RTTEST we'll use the one
670	* associated with the calling thread.
671	* @param cb The amount of memory to allocate.
672	*/
673	RTR3DECL(void *) RTTestGuardedAllocTail(RTTEST hTest, size_t cb)
674	{
675	void *pvUser;
676	int rc = RTTestGuardedAlloc(hTest, cb, 1 /* cbAlign /, false / fHead */, &pvUser);
677	if (RT_SUCCESS(rc))
678	return pvUser;
679	return NULL;
680	}
681
682
683	/**
684	* Allocates a block of guarded memory where the guarded is right in front of
685	* the user memory.
686	*
687	* @returns Pointer to the allocated memory. NULL on failure.
688	* @param hTest The test handle. If NIL_RTTEST we'll use the one
689	* associated with the calling thread.
690	* @param cb The amount of memory to allocate.
691	*/
692	RTR3DECL(void *) RTTestGuardedAllocHead(RTTEST hTest, size_t cb)
693	{
694	void *pvUser;
695	int rc = RTTestGuardedAlloc(hTest, cb, 1 /* cbAlign /, true / fHead */, &pvUser);
696	if (RT_SUCCESS(rc))
697	return pvUser;
698	return NULL;
699	}
700
701
702	/**
703	* Frees one block of guarded memory.
704	*
705	* The caller is responsible for unlinking it.
706	*
707	* @param pMem The memory record.
708	*/
709	static void rtTestGuardedFreeOne(PRTTESTGUARDEDMEM pMem)
710	{
711	int rc;
712	rc = RTMemProtect(pMem->aGuards[0].pv, pMem->aGuards[0].cb, RTMEM_PROT_WRITE \| RTMEM_PROT_READ); AssertRC(rc);
713	rc = RTMemProtect(pMem->aGuards[1].pv, pMem->aGuards[1].cb, RTMEM_PROT_WRITE \| RTMEM_PROT_READ); AssertRC(rc);
714	RTMemPageFree(pMem->pvAlloc, pMem->cbAlloc);
715	RTMemFree(pMem);
716	}
717
718
719	/**
720	* Frees a block of guarded memory.
721	*
722	* @returns IPRT status code.
723	* @param hTest The test handle. If NIL_RTTEST we'll use the one
724	* associated with the calling thread.
725	* @param pv The memory. NULL is ignored.
726	*/
727	RTR3DECL(int) RTTestGuardedFree(RTTEST hTest, void *pv)
728	{
729	PRTTESTINT pTest = hTest;
730	RTTEST_GET_VALID_RETURN(pTest);
731	if (!pv)
732	return VINF_SUCCESS;
733
734	/*
735	* Find it.
736	*/
737	int rc = VERR_INVALID_POINTER;
738	PRTTESTGUARDEDMEM pPrev = NULL;
739
740	RTCritSectEnter(&pTest->Lock);
741	for (PRTTESTGUARDEDMEM pMem = pTest->pGuardedMem; pMem; pMem = pMem->pNext)
742	{
743	if (pMem->pvUser == pv)
744	{
745	if (pPrev)
746	pPrev->pNext = pMem->pNext;
747	else
748	pTest->pGuardedMem = pMem->pNext;
749	rtTestGuardedFreeOne(pMem);
750	rc = VINF_SUCCESS;
751	break;
752	}
753	pPrev = pMem;
754	}
755	RTCritSectLeave(&pTest->Lock);
756
757	return rc;
758	}
759
760
761	/**
762	* Outputs the formatted XML.
763	*
764	* @param pTest The test instance.
765	* @param pszFormat The format string.
766	* @param va The format arguments.
767	*/
768	static void rtTestXmlOutputV(PRTTESTINT pTest, const char *pszFormat, va_list va)
769	{
770	if (pTest->fXmlEnabled)
771	{
772	char *pszStr;
773	ssize_t cchStr = RTStrAPrintfV(&pszStr, pszFormat, va);
774	if (pszStr)
775	{
776	if (pTest->hXmlPipe != NIL_RTPIPE)
777	RTPipeWriteBlocking(pTest->hXmlPipe, pszStr, cchStr, NULL);
778	if (pTest->hXmlFile != NIL_RTFILE)
779	RTFileWrite(pTest->hXmlFile, pszStr, cchStr, NULL);
780	RTStrFree(pszStr);
781	}
782	}
783	}
784
785
786	/**
787	* Outputs the formatted XML.
788	*
789	* @param pTest The test instance.
790	* @param pszFormat The format string.
791	* @param ... The format arguments.
792	*/
793	static void rtTestXmlOutput(PRTTESTINT pTest, const char *pszFormat, ...)
794	{
795	va_list va;
796	va_start(va, pszFormat);
797	rtTestXmlOutputV(pTest, pszFormat, va);
798	va_end(va);
799	}
800
801
802	/**
803	* Starts the XML stream.
804	*
805	* @param pTest The test instance.
806	* @param pszTest The test name.
807	*/
808	static void rtTestXmlStart(PRTTESTINT pTest, const char *pszTest)
809	{
810	pTest->cXmlElements = 0;
811	if (pTest->fXmlEnabled)
812	{
813	rtTestXmlOutput(pTest, "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n");
814	pTest->eXmlState = RTTESTINT::kXmlPos_ElementEnd;
815	pTest->fXmlTopTestDone = !(pTest->fFlags & RTTEST_C_XML_DELAY_TOP_TEST) \|\| pTest->fXmlOmitTopTest;
816	if (pTest->fXmlTopTestDone && !pTest->fXmlOmitTopTest)
817	rtTestXmlElemStart(pTest, "Test", "name=%RMas", pszTest);
818	}
819	}
820
821
822	/**
823	* Emit an XML element that doesn't have any value and instead ends immediately.
824	*
825	* The caller must own the instance lock.
826	*
827	* @param pTest The test instance.
828	* @param pszTag The element tag.
829	* @param pszAttrFmt The element attributes as a format string. Use
830	* NULL if none.
831	* @param va Format string arguments.
832	*/
833	static void rtTestXmlElemV(PRTTESTINT pTest, const char pszTag, const char pszAttrFmt, va_list va)
834	{
835	if (pTest->fXmlEnabled)
836	{
837	RTTIMESPEC TimeSpec;
838	RTTIME Time;
839	char szTS[80];
840	RTTimeToString(RTTimeExplode(&Time, RTTimeNow(&TimeSpec)), szTS, sizeof(szTS));
841
842	if (pTest->eXmlState != RTTESTINT::kXmlPos_ElementEnd)
843	rtTestXmlOutput(pTest, "\n");
844
845	if (!pszAttrFmt \|\| !*pszAttrFmt)
846	rtTestXmlOutput(pTest, "%*s<%s timestamp=%RMas/>\n",
847	pTest->cXmlElements * 2, "", pszTag, szTS);
848	else
849	{
850	va_list va2;
851	va_copy(va2, va);
852	rtTestXmlOutput(pTest, "%*s<%s timestamp=%RMas %N/>\n",
853	pTest->cXmlElements * 2, "", pszTag, szTS, pszAttrFmt, &va2);
854	va_end(va2);
855	}
856	pTest->eXmlState = RTTESTINT::kXmlPos_ElementEnd;
857	}
858	}
859
860
861	/**
862	* Wrapper around rtTestXmlElemV.
863	*/
864	static void rtTestXmlElem(PRTTESTINT pTest, const char pszTag, const char pszAttrFmt, ...)
865	{
866	va_list va;
867	va_start(va, pszAttrFmt);
868	rtTestXmlElemV(pTest, pszTag, pszAttrFmt, va);
869	va_end(va);
870	}
871
872
873	/**
874	* Starts a new XML element.
875	*
876	* The caller must own the instance lock.
877	*
878	* @param pTest The test instance.
879	* @param pszTag The element tag.
880	* @param pszAttrFmt The element attributes as a format string. Use
881	* NULL if none.
882	* @param va Format string arguments.
883	*/
884	static void rtTestXmlElemStartV(PRTTESTINT pTest, const char pszTag, const char pszAttrFmt, va_list va)
885	{
886	/* Push it onto the stack. */
887	size_t i = pTest->cXmlElements;
888	AssertReturnVoid(i < RT_ELEMENTS(pTest->apszXmlElements));
889	pTest->apszXmlElements[i] = pszTag;
890	pTest->cXmlElements = i + 1;
891
892	if (pTest->fXmlEnabled)
893	{
894	RTTIMESPEC TimeSpec;
895	RTTIME Time;
896	char szTS[80];
897	RTTimeToString(RTTimeExplode(&Time, RTTimeNow(&TimeSpec)), szTS, sizeof(szTS));
898
899	if (pTest->eXmlState != RTTESTINT::kXmlPos_ElementEnd)
900	rtTestXmlOutput(pTest, "\n");
901
902	if (!pszAttrFmt \|\| !*pszAttrFmt)
903	rtTestXmlOutput(pTest, "%*s<%s timestamp=%RMas>",
904	i * 2, "", pszTag, szTS);
905	else
906	{
907	va_list va2;
908	va_copy(va2, va);
909	rtTestXmlOutput(pTest, "%*s<%s timestamp=%RMas %N>",
910	i * 2, "", pszTag, szTS, pszAttrFmt, &va2);
911	va_end(va2);
912	}
913	pTest->eXmlState = RTTESTINT::kXmlPos_ValueStart;
914	}
915	}
916
917
918	/**
919	* Wrapper around rtTestXmlElemStartV.
920	*/
921	static void rtTestXmlElemStart(PRTTESTINT pTest, const char pszTag, const char pszAttrFmt, ...)
922	{
923	va_list va;
924	va_start(va, pszAttrFmt);
925	rtTestXmlElemStartV(pTest, pszTag, pszAttrFmt, va);
926	va_end(va);
927	}
928
929
930	/**
931	* Ends the current element.
932	*
933	* The caller must own the instance lock.
934	*
935	* @param pTest The test instance.
936	* @param pszTag The tag we're ending (chiefly for sanity
937	* checking).
938	*/
939	static void rtTestXmlElemEnd(PRTTESTINT pTest, const char *pszTag)
940	{
941	/* pop the element */
942	size_t i = pTest->cXmlElements;
943	AssertReturnVoid(i > 0);
944	i--;
945	AssertReturnVoid(!strcmp(pszTag, pTest->apszXmlElements[i]));
946	pTest->cXmlElements = i;
947
948	/* Do the closing. */
949	if (pTest->fXmlEnabled)
950	{
951	if (pTest->eXmlState == RTTESTINT::kXmlPos_ValueStart)
952	rtTestXmlOutput(pTest, "\n%s</%s>\n", i 2, "", pszTag);
953	else if (pTest->eXmlState == RTTESTINT::kXmlPos_ElementEnd)
954	rtTestXmlOutput(pTest, "%s</%s>\n", i 2, "", pszTag);
955	else
956	rtTestXmlOutput(pTest, "</%s>\n", pszTag);
957	pTest->eXmlState = RTTESTINT::kXmlPos_ElementEnd;
958	}
959	}
960
961
962	/**
963	* Ends the XML stream, closing all open elements.
964	*
965	* The caller must own the instance lock.
966	*
967	* @param pTest The test instance.
968	*/
969	static void rtTestXmlEnd(PRTTESTINT pTest)
970	{
971	if (pTest->fXmlEnabled)
972	{
973	/*
974	* Close all the elements and add the final TestEnd one to get a
975	* final timestamp and some certainty that the XML is valid.
976	*/
977	size_t i = pTest->cXmlElements;
978	AssertReturnVoid(i > 0 \|\| pTest->fXmlOmitTopTest \|\| !pTest->fXmlTopTestDone);
979	while (i-- > 1)
980	{
981	const char *pszTag = pTest->apszXmlElements[pTest->cXmlElements];
982	if (pTest->eXmlState == RTTESTINT::kXmlPos_ValueStart)
983	rtTestXmlOutput(pTest, "\n%s</%s>\n", i 2, "", pszTag);
984	else if (pTest->eXmlState == RTTESTINT::kXmlPos_ElementEnd)
985	rtTestXmlOutput(pTest, "%s</%s>\n", i 2, "", pszTag);
986	else
987	rtTestXmlOutput(pTest, "</%s>\n", pszTag);
988	pTest->eXmlState = RTTESTINT::kXmlPos_ElementEnd;
989	}
990
991	if (!pTest->fXmlOmitTopTest && pTest->fXmlTopTestDone)
992	{
993	rtTestXmlElem(pTest, "End", "SubTests=\"%u\" SubTestsFailed=\"%u\" errors=\"%u\"",
994	pTest->cSubTests, pTest->cSubTestsFailed, pTest->cErrors);
995	rtTestXmlOutput(pTest, "</Test>\n");
996	}
997
998	/*
999	* Close the XML outputs.
1000	*/
1001	if (pTest->hXmlPipe != NIL_RTPIPE)
1002	{
1003	RTPipeClose(pTest->hXmlPipe);
1004	pTest->hXmlPipe = NIL_RTPIPE;
1005	}
1006	if (pTest->hXmlFile != NIL_RTFILE)
1007	{
1008	RTFileClose(pTest->hXmlFile);
1009	pTest->hXmlFile = NIL_RTFILE;
1010	}
1011	pTest->fXmlEnabled = false;
1012	pTest->eXmlState = RTTESTINT::kXmlPos_ElementEnd;
1013	}
1014	pTest->cXmlElements = 0;
1015	}
1016
1017	/**
1018	* Output callback.
1019	*
1020	* @returns number of bytes written.
1021	* @param pvArg User argument.
1022	* @param pachChars Pointer to an array of utf-8 characters.
1023	* @param cbChars Number of bytes in the character array pointed to by pachChars.
1024	*/
1025	static DECLCALLBACK(size_t) rtTestPrintfOutput(void pvArg, const char pachChars, size_t cbChars)
1026	{
1027	size_t cch = 0;
1028	PRTTESTINT pTest = (PRTTESTINT)pvArg;
1029	if (cbChars)
1030	{
1031	do
1032	{
1033	/* insert prefix if at a newline. */
1034	if (pTest->fNewLine)
1035	{
1036	RTStrmWrite(pTest->pOutStrm, pTest->pszTest, pTest->cchTest);
1037	RTStrmWrite(pTest->pOutStrm, ": ", 2);
1038	cch += 2 + pTest->cchTest;
1039	}
1040
1041	/* look for newline and write the stuff. */
1042	const char pchEnd = (const char )memchr(pachChars, '\n', cbChars);
1043	if (!pchEnd)
1044	{
1045	pTest->fNewLine = false;
1046	RTStrmWrite(pTest->pOutStrm, pachChars, cbChars);
1047	cch += cbChars;
1048	break;
1049	}
1050
1051	pTest->fNewLine = true;
1052	size_t const cchPart = pchEnd - pachChars + 1;
1053	RTStrmWrite(pTest->pOutStrm, pachChars, cchPart);
1054	cch += cchPart;
1055	pachChars += cchPart;
1056	cbChars -= cchPart;
1057	} while (cbChars);
1058	}
1059	else
1060	RTStrmFlush(pTest->pOutStrm);
1061	return cch;
1062	}
1063
1064
1065	/**
1066	* Internal output worker.
1067	*
1068	* Caller takes the lock.
1069	*
1070	* @returns Number of chars printed.
1071	* @param pTest The test instance.
1072	* @param pszFormat The message.
1073	* @param va The arguments.
1074	*/
1075	static int rtTestPrintfV(PRTTESTINT pTest, const char *pszFormat, va_list va)
1076	{
1077	return (int)RTStrFormatV(rtTestPrintfOutput, pTest, NULL, NULL, pszFormat, va);
1078	}
1079
1080
1081	/**
1082	* Internal output worker.
1083	*
1084	* Caller takes the lock.
1085	*
1086	* @returns Number of chars printed.
1087	* @param pTest The test instance.
1088	* @param pszFormat The message.
1089	* @param ... The arguments.
1090	*/
1091	static int rtTestPrintf(PRTTESTINT pTest, const char *pszFormat, ...)
1092	{
1093	va_list va;
1094
1095	va_start(va, pszFormat);
1096	int cch = rtTestPrintfV(pTest, pszFormat, va);
1097	va_end(va);
1098
1099	return cch;
1100	}
1101
1102
1103	/**
1104	* Test vprintf making sure the output starts on a new line.
1105	*
1106	* @returns Number of chars printed.
1107	* @param hTest The test handle. If NIL_RTTEST we'll use the one
1108	* associated with the calling thread.
1109	* @param enmLevel Message importance level.
1110	* @param pszFormat The message.
1111	* @param va Arguments.
1112	*/
1113	RTR3DECL(int) RTTestPrintfNlV(RTTEST hTest, RTTESTLVL enmLevel, const char *pszFormat, va_list va)
1114	{
1115	PRTTESTINT pTest = hTest;
1116	RTTEST_GET_VALID_RETURN_RC(pTest, -1);
1117
1118	RTCritSectEnter(&pTest->OutputLock);
1119
1120	int cch = 0;
1121	if (enmLevel <= pTest->enmMaxLevel)
1122	{
1123	if (!pTest->fNewLine)
1124	cch += rtTestPrintf(pTest, "\n");
1125	cch += rtTestPrintfV(pTest, pszFormat, va);
1126	}
1127
1128	RTCritSectLeave(&pTest->OutputLock);
1129
1130	return cch;
1131	}
1132
1133
1134	/**
1135	* Test printf making sure the output starts on a new line.
1136	*
1137	* @returns Number of chars printed.
1138	* @param hTest The test handle. If NIL_RTTEST we'll use the one
1139	* associated with the calling thread.
1140	* @param enmLevel Message importance level.
1141	* @param pszFormat The message.
1142	* @param ... Arguments.
1143	*/
1144	RTR3DECL(int) RTTestPrintfNl(RTTEST hTest, RTTESTLVL enmLevel, const char *pszFormat, ...)
1145	{
1146	va_list va;
1147
1148	va_start(va, pszFormat);
1149	int cch = RTTestPrintfNlV(hTest, enmLevel, pszFormat, va);
1150	va_end(va);
1151
1152	return cch;
1153	}
1154
1155
1156	/**
1157	* Test vprintf, makes sure lines are prefixed and so forth.
1158	*
1159	* @returns Number of chars printed.
1160	* @param hTest The test handle. If NIL_RTTEST we'll use the one
1161	* associated with the calling thread.
1162	* @param enmLevel Message importance level.
1163	* @param pszFormat The message.
1164	* @param va Arguments.
1165	*/
1166	RTR3DECL(int) RTTestPrintfV(RTTEST hTest, RTTESTLVL enmLevel, const char *pszFormat, va_list va)
1167	{
1168	PRTTESTINT pTest = hTest;
1169	RTTEST_GET_VALID_RETURN_RC(pTest, -1);
1170
1171	RTCritSectEnter(&pTest->OutputLock);
1172	int cch = 0;
1173	if (enmLevel <= pTest->enmMaxLevel)
1174	cch += rtTestPrintfV(pTest, pszFormat, va);
1175	RTCritSectLeave(&pTest->OutputLock);
1176
1177	return cch;
1178	}
1179
1180
1181	/**
1182	* Test printf, makes sure lines are prefixed and so forth.
1183	*
1184	* @returns Number of chars printed.
1185	* @param hTest The test handle. If NIL_RTTEST we'll use the one
1186	* associated with the calling thread.
1187	* @param enmLevel Message importance level.
1188	* @param pszFormat The message.
1189	* @param ... Arguments.
1190	*/
1191	RTR3DECL(int) RTTestPrintf(RTTEST hTest, RTTESTLVL enmLevel, const char *pszFormat, ...)
1192	{
1193	va_list va;
1194
1195	va_start(va, pszFormat);
1196	int cch = RTTestPrintfV(hTest, enmLevel, pszFormat, va);
1197	va_end(va);
1198
1199	return cch;
1200	}
1201
1202
1203	/**
1204	* Prints the test banner.
1205	*
1206	* @returns Number of chars printed.
1207	* @param hTest The test handle. If NIL_RTTEST we'll use the one
1208	* associated with the calling thread.
1209	*/
1210	RTR3DECL(int) RTTestBanner(RTTEST hTest)
1211	{
1212	return RTTestPrintfNl(hTest, RTTESTLVL_ALWAYS, "TESTING...\n");
1213	}
1214
1215
1216	/**
1217	* Prints the result of a sub-test if necessary.
1218	*
1219	* @returns Number of chars printed.
1220	* @param pTest The test instance.
1221	* @remarks Caller own the test Lock.
1222	*/
1223	static int rtTestSubTestReport(PRTTESTINT pTest)
1224	{
1225	int cch = 0;
1226	if ( !pTest->fSubTestReported
1227	&& pTest->pszSubTest)
1228	{
1229	pTest->fSubTestReported = true;
1230	uint32_t cErrors = ASMAtomicUoReadU32(&pTest->cErrors) - pTest->cSubTestAtErrors;
1231	if (!cErrors)
1232	{
1233	if (!pTest->fSubTestSkipped)
1234	{
1235	rtTestXmlElem(pTest, "Passed", NULL);
1236	rtTestXmlElemEnd(pTest, "Test");
1237	cch += RTTestPrintfNl(pTest, RTTESTLVL_SUB_TEST, "%-60s: PASSED\n", pTest->pszSubTest);
1238	}
1239	else
1240	{
1241	rtTestXmlElem(pTest, "Skipped", NULL);
1242	rtTestXmlElemEnd(pTest, "Test");
1243	cch += RTTestPrintfNl(pTest, RTTESTLVL_SUB_TEST, "%-60s: SKIPPED\n", pTest->pszSubTest);
1244	}
1245	}
1246	else
1247	{
1248	pTest->cSubTestsFailed++;
1249	rtTestXmlElem(pTest, "Failed", "errors=\"%u\"", cErrors);
1250	rtTestXmlElemEnd(pTest, "Test");
1251	cch += RTTestPrintfNl(pTest, RTTESTLVL_SUB_TEST, "%-60s: FAILED (%u errors)\n",
1252	pTest->pszSubTest, cErrors);
1253	}
1254	}
1255	return cch;
1256	}
1257
1258
1259	/**
1260	* RTTestSub and RTTestSubDone worker that cleans up the current (if any)
1261	* sub test.
1262	*
1263	* @returns Number of chars printed.
1264	* @param pTest The test instance.
1265	* @remarks Caller own the test Lock.
1266	*/
1267	static int rtTestSubCleanup(PRTTESTINT pTest)
1268	{
1269	int cch = 0;
1270	if (pTest->pszSubTest)
1271	{
1272	cch += rtTestSubTestReport(pTest);
1273
1274	RTStrFree((char *)pTest->pszSubTest);
1275	pTest->pszSubTest = NULL;
1276	pTest->fSubTestReported = true;
1277	}
1278	RTStrFree(pTest->pszErrCtx);
1279	pTest->pszErrCtx = NULL;
1280	return cch;
1281	}
1282
1283
1284	/**
1285	* Summaries the test, destroys the test instance and return an exit code.
1286	*
1287	* @returns Test program exit code.
1288	* @param hTest The test handle. If NIL_RTTEST we'll use the one
1289	* associated with the calling thread.
1290	*/
1291	RTR3DECL(RTEXITCODE) RTTestSummaryAndDestroy(RTTEST hTest)
1292	{
1293	PRTTESTINT pTest = hTest;
1294	RTTEST_GET_VALID_RETURN_RC(pTest, RTEXITCODE_FAILURE);
1295
1296	RTCritSectEnter(&pTest->Lock);
1297	rtTestSubTestReport(pTest);
1298	RTCritSectLeave(&pTest->Lock);
1299
1300	RTEXITCODE enmExitCode;
1301	if (!pTest->cErrors)
1302	{
1303	RTTestPrintfNl(hTest, RTTESTLVL_ALWAYS, "SUCCESS\n");
1304	enmExitCode = RTEXITCODE_SUCCESS;
1305	}
1306	else
1307	{
1308	RTTestPrintfNl(hTest, RTTESTLVL_ALWAYS, "FAILURE - %u errors\n", pTest->cErrors);
1309	enmExitCode = RTEXITCODE_FAILURE;
1310	}
1311
1312	RTTestDestroy(pTest);
1313	return enmExitCode;
1314	}
1315
1316
1317	RTR3DECL(RTEXITCODE) RTTestSkipAndDestroyV(RTTEST hTest, const char *pszReasonFmt, va_list va)
1318	{
1319	PRTTESTINT pTest = hTest;
1320	RTTEST_GET_VALID_RETURN_RC(pTest, RTEXITCODE_SKIPPED);
1321
1322	RTCritSectEnter(&pTest->Lock);
1323	rtTestSubTestReport(pTest);
1324	RTCritSectLeave(&pTest->Lock);
1325
1326	RTEXITCODE enmExitCode;
1327	if (!pTest->cErrors)
1328	{
1329	if (pszReasonFmt)
1330	RTTestPrintfNlV(hTest, RTTESTLVL_FAILURE, pszReasonFmt, va);
1331	RTTestPrintfNl(hTest, RTTESTLVL_ALWAYS, "SKIPPED\n");
1332	enmExitCode = RTEXITCODE_SKIPPED;
1333	}
1334	else
1335	{
1336	RTTestPrintfNl(hTest, RTTESTLVL_ALWAYS, "FAILURE - %u errors\n", pTest->cErrors);
1337	enmExitCode = RTEXITCODE_FAILURE;
1338	}
1339
1340	RTTestDestroy(pTest);
1341	return enmExitCode;
1342	}
1343
1344
1345	RTR3DECL(RTEXITCODE) RTTestSkipAndDestroy(RTTEST hTest, const char *pszReasonFmt, ...)
1346	{
1347	va_list va;
1348	va_start(va, pszReasonFmt);
1349	RTEXITCODE enmExitCode = RTTestSkipAndDestroyV(hTest, pszReasonFmt, va);
1350	va_end(va);
1351	return enmExitCode;
1352	}
1353
1354
1355	/**
1356	* Starts a sub-test.
1357	*
1358	* This will perform an implicit RTTestSubDone() call if that has not been done
1359	* since the last RTTestSub call.
1360	*
1361	* @returns Number of chars printed.
1362	* @param hTest The test handle. If NIL_RTTEST we'll use the one
1363	* associated with the calling thread.
1364	* @param pszSubTest The sub-test name
1365	*/
1366	RTR3DECL(int) RTTestSub(RTTEST hTest, const char *pszSubTest)
1367	{
1368	PRTTESTINT pTest = hTest;
1369	RTTEST_GET_VALID_RETURN_RC(pTest, -1);
1370
1371	RTCritSectEnter(&pTest->Lock);
1372
1373	/* Cleanup, reporting if necessary previous sub test. */
1374	rtTestSubCleanup(pTest);
1375
1376	/* Start new sub test. */
1377	pTest->cSubTests++;
1378	pTest->cSubTestAtErrors = ASMAtomicUoReadU32(&pTest->cErrors);
1379	pTest->pszSubTest = RTStrDup(pszSubTest);
1380	pTest->cchSubTest = strlen(pszSubTest);
1381	AssertMsg(pTest->cchSubTest < 64 /* See g_kcchMaxTestResultName in testmanager/config.py. */,
1382	("cchSubTest=%u: '%s'\n", pTest->cchSubTest, pTest->pszSubTest));
1383	pTest->fSubTestSkipped = false;
1384	pTest->fSubTestReported = false;
1385
1386	int cch = 0;
1387	if (pTest->enmMaxLevel >= RTTESTLVL_DEBUG)
1388	cch = RTTestPrintfNl(hTest, RTTESTLVL_DEBUG, "debug: Starting sub-test '%s'\n", pszSubTest);
1389
1390	if (!pTest->fXmlTopTestDone)
1391	{
1392	pTest->fXmlTopTestDone = true;
1393	rtTestXmlElemStart(pTest, "Test", "name=%RMas", pTest->pszTest);
1394	}
1395
1396	rtTestXmlElemStart(pTest, "Test", "name=%RMas", pszSubTest);
1397
1398	RTCritSectLeave(&pTest->Lock);
1399
1400	return cch;
1401	}
1402
1403
1404	/**
1405	* Format string version of RTTestSub.
1406	*
1407	* See RTTestSub for details.
1408	*
1409	* @returns Number of chars printed.
1410	* @param hTest The test handle. If NIL_RTTEST we'll use the one
1411	* associated with the calling thread.
1412	* @param pszSubTestFmt The sub-test name format string.
1413	* @param ... Arguments.
1414	*/
1415	RTR3DECL(int) RTTestSubF(RTTEST hTest, const char *pszSubTestFmt, ...)
1416	{
1417	va_list va;
1418	va_start(va, pszSubTestFmt);
1419	int cch = RTTestSubV(hTest, pszSubTestFmt, va);
1420	va_end(va);
1421	return cch;
1422	}
1423
1424
1425	/**
1426	* Format string version of RTTestSub.
1427	*
1428	* See RTTestSub for details.
1429	*
1430	* @returns Number of chars printed.
1431	* @param hTest The test handle. If NIL_RTTEST we'll use the one
1432	* associated with the calling thread.
1433	* @param pszSubTestFmt The sub-test name format string.
1434	* @param ... Arguments.
1435	*/
1436	RTR3DECL(int) RTTestSubV(RTTEST hTest, const char *pszSubTestFmt, va_list va)
1437	{
1438	char *pszSubTest;
1439	RTStrAPrintfV(&pszSubTest, pszSubTestFmt, va);
1440	if (pszSubTest)
1441	{
1442	int cch = RTTestSub(hTest, pszSubTest);
1443	RTStrFree(pszSubTest);
1444	return cch;
1445	}
1446	return 0;
1447	}
1448
1449
1450	/**
1451	* Completes a sub-test.
1452	*
1453	* @returns Number of chars printed.
1454	* @param hTest The test handle. If NIL_RTTEST we'll use the one
1455	* associated with the calling thread.
1456	*/
1457	RTR3DECL(int) RTTestSubDone(RTTEST hTest)
1458	{
1459	PRTTESTINT pTest = hTest;
1460	RTTEST_GET_VALID_RETURN_RC(pTest, VERR_INVALID_HANDLE);
1461
1462	RTCritSectEnter(&pTest->Lock);
1463	int cch = rtTestSubCleanup(pTest);
1464	RTCritSectLeave(&pTest->Lock);
1465
1466	return cch;
1467	}
1468
1469	/**
1470	* Prints an extended PASSED message, optional.
1471	*
1472	* This does not conclude the sub-test, it could be used to report the passing
1473	* of a sub-sub-to-the-power-of-N-test.
1474	*
1475	* @returns IPRT status code.
1476	* @param hTest The test handle. If NIL_RTTEST we'll use the one
1477	* associated with the calling thread.
1478	* @param pszFormat The message. No trailing newline.
1479	* @param va The arguments.
1480	*/
1481	RTR3DECL(int) RTTestPassedV(RTTEST hTest, const char *pszFormat, va_list va)
1482	{
1483	PRTTESTINT pTest = hTest;
1484	AssertPtr(pszFormat);
1485	RTTEST_GET_VALID_RETURN_RC(pTest, VERR_INVALID_HANDLE);
1486
1487	int cch = 0;
1488	if (pTest->enmMaxLevel >= RTTESTLVL_INFO)
1489	{
1490	va_list va2;
1491	va_copy(va2, va);
1492
1493	RTCritSectEnter(&pTest->OutputLock);
1494	cch += rtTestPrintf(pTest, "%N\n", pszFormat, &va2);
1495	RTCritSectLeave(&pTest->OutputLock);
1496
1497	va_end(va2);
1498	}
1499
1500	return cch;
1501	}
1502
1503
1504	/**
1505	* Prints an extended PASSED message, optional.
1506	*
1507	* This does not conclude the sub-test, it could be used to report the passing
1508	* of a sub-sub-to-the-power-of-N-test.
1509	*
1510	* @returns IPRT status code.
1511	* @param hTest The test handle. If NIL_RTTEST we'll use the one
1512	* associated with the calling thread.
1513	* @param pszFormat The message. No trailing newline.
1514	* @param ... The arguments.
1515	*/
1516	RTR3DECL(int) RTTestPassed(RTTEST hTest, const char *pszFormat, ...)
1517	{
1518	va_list va;
1519
1520	va_start(va, pszFormat);
1521	int cch = RTTestPassedV(hTest, pszFormat, va);
1522	va_end(va);
1523
1524	return cch;
1525	}
1526
1527
1528	RTR3DECL(int) RTTestSkippedV(RTTEST hTest, const char *pszFormat, va_list va)
1529	{
1530	PRTTESTINT pTest = hTest;
1531	AssertPtrNull(pszFormat);
1532	RTTEST_GET_VALID_RETURN_RC(pTest, VERR_INVALID_HANDLE);
1533
1534	pTest->fSubTestSkipped = true;
1535
1536	int cch = 0;
1537	if (pszFormat && *pszFormat && pTest->enmMaxLevel >= RTTESTLVL_INFO)
1538	{
1539	va_list va2;
1540	va_copy(va2, va);
1541
1542	RTCritSectEnter(&pTest->OutputLock);
1543	cch += rtTestPrintf(pTest, "%N\n", pszFormat, &va2);
1544	RTCritSectLeave(&pTest->OutputLock);
1545
1546	va_end(va2);
1547	}
1548
1549	return cch;
1550	}
1551
1552
1553	RTR3DECL(int) RTTestSkipped(RTTEST hTest, const char *pszFormat, ...)
1554	{
1555	va_list va;
1556
1557	va_start(va, pszFormat);
1558	int cch = RTTestSkippedV(hTest, pszFormat, va);
1559	va_end(va);
1560
1561	return cch;
1562	}
1563
1564
1565
1566	/**
1567	* Gets the unit name.
1568	*
1569	* @returns Unit name.
1570	* @param enmUnit The unit.
1571	*/
1572	static const char *rtTestUnitName(RTTESTUNIT enmUnit)
1573	{
1574	switch (enmUnit)
1575	{
1576	case RTTESTUNIT_PCT: return "%";
1577	case RTTESTUNIT_BYTES: return "bytes";
1578	case RTTESTUNIT_BYTES_PER_SEC: return "bytes/s";
1579	case RTTESTUNIT_KILOBYTES: return "KB";
1580	case RTTESTUNIT_KILOBYTES_PER_SEC: return "KB/s";
1581	case RTTESTUNIT_MEGABYTES: return "MB";
1582	case RTTESTUNIT_MEGABYTES_PER_SEC: return "MB/s";
1583	case RTTESTUNIT_PACKETS: return "packets";
1584	case RTTESTUNIT_PACKETS_PER_SEC: return "packets/s";
1585	case RTTESTUNIT_FRAMES: return "frames";
1586	case RTTESTUNIT_FRAMES_PER_SEC: return "frames/s";
1587	case RTTESTUNIT_OCCURRENCES: return "occurrences";
1588	case RTTESTUNIT_OCCURRENCES_PER_SEC: return "occurrences/s";
1589	case RTTESTUNIT_ROUND_TRIP: return "roundtrips";
1590	case RTTESTUNIT_CALLS: return "calls";
1591	case RTTESTUNIT_CALLS_PER_SEC: return "calls/s";
1592	case RTTESTUNIT_SECS: return "s";
1593	case RTTESTUNIT_MS: return "ms";
1594	case RTTESTUNIT_NS: return "ns";
1595	case RTTESTUNIT_NS_PER_CALL: return "ns/call";
1596	case RTTESTUNIT_NS_PER_FRAME: return "ns/frame";
1597	case RTTESTUNIT_NS_PER_OCCURRENCE: return "ns/occurrence";
1598	case RTTESTUNIT_NS_PER_PACKET: return "ns/packet";
1599	case RTTESTUNIT_NS_PER_ROUND_TRIP: return "ns/roundtrip";
1600	case RTTESTUNIT_INSTRS: return "ins";
1601	case RTTESTUNIT_INSTRS_PER_SEC: return "ins/sec";
1602	case RTTESTUNIT_NONE: return "";
1603	case RTTESTUNIT_PP1K: return "pp1k";
1604	case RTTESTUNIT_PP10K: return "pp10k";
1605	case RTTESTUNIT_PPM: return "ppm";
1606	case RTTESTUNIT_PPB: return "ppb";
1607	case RTTESTUNIT_TICKS: return "ticks";
1608	case RTTESTUNIT_TICKS_PER_CALL: return "ticks/call";
1609	case RTTESTUNIT_TICKS_PER_OCCURENCE: return "ticks/occ";
1610	case RTTESTUNIT_PAGES: return "pages";
1611	case RTTESTUNIT_PAGES_PER_SEC: return "pages/s";
1612	case RTTESTUNIT_TICKS_PER_PAGE: return "ticks/page";
1613	case RTTESTUNIT_NS_PER_PAGE: return "ns/page";
1614	case RTTESTUNIT_PS: return "ps";
1615	case RTTESTUNIT_PS_PER_CALL: return "ps/call";
1616	case RTTESTUNIT_PS_PER_FRAME: return "ps/frame";
1617	case RTTESTUNIT_PS_PER_OCCURRENCE: return "ps/occurrence";
1618	case RTTESTUNIT_PS_PER_PACKET: return "ps/packet";
1619	case RTTESTUNIT_PS_PER_ROUND_TRIP: return "ps/roundtrip";
1620	case RTTESTUNIT_PS_PER_PAGE: return "ps/page";
1621
1622	/* No default so gcc helps us keep this up to date. */
1623	case RTTESTUNIT_INVALID:
1624	case RTTESTUNIT_END:
1625	break;
1626	}
1627	AssertMsgFailed(("%d\n", enmUnit));
1628	return "unknown";
1629	}
1630
1631
1632	RTR3DECL(int) RTTestValue(RTTEST hTest, const char *pszName, uint64_t u64Value, RTTESTUNIT enmUnit)
1633	{
1634	PRTTESTINT pTest = hTest;
1635	RTTEST_GET_VALID_RETURN(pTest);
1636
1637	Assert(strlen(pszName) < 56 /* See g_kcchMaxTestValueName in testmanager/config.py. */);
1638
1639	const char *pszUnit = rtTestUnitName(enmUnit);
1640
1641	RTCritSectEnter(&pTest->Lock);
1642	rtTestXmlElem(pTest, "Value", "name=%RMas unit=%RMas value=\"%llu\"", pszName, pszUnit, u64Value);
1643	RTCritSectLeave(&pTest->Lock);
1644
1645	RTCritSectEnter(&pTest->OutputLock);
1646	rtTestPrintf(pTest, " %-58s: %'16llu %s\n", pszName, u64Value, pszUnit);
1647	RTCritSectLeave(&pTest->OutputLock);
1648
1649	return VINF_SUCCESS;
1650	}
1651
1652
1653	RTR3DECL(int) RTTestValueF(RTTEST hTest, uint64_t u64Value, RTTESTUNIT enmUnit, const char *pszNameFmt, ...)
1654	{
1655	va_list va;
1656	va_start(va, pszNameFmt);
1657	int rc = RTTestValueV(hTest, u64Value, enmUnit, pszNameFmt, va);
1658	va_end(va);
1659	return rc;
1660	}
1661
1662
1663	RTR3DECL(int) RTTestValueV(RTTEST hTest, uint64_t u64Value, RTTESTUNIT enmUnit, const char *pszNameFmt, va_list va)
1664	{
1665	char *pszName;
1666	RTStrAPrintfV(&pszName, pszNameFmt, va);
1667	if (!pszName)
1668	return VERR_NO_MEMORY;
1669	int rc = RTTestValue(hTest, pszName, u64Value, enmUnit);
1670	RTStrFree(pszName);
1671	return rc;
1672	}
1673
1674
1675	/**
1676	* Increments the error counter.
1677	*
1678	* @returns IPRT status code.
1679	* @param hTest The test handle. If NIL_RTTEST we'll use the one
1680	* associated with the calling thread.
1681	*/
1682	RTR3DECL(int) RTTestErrorInc(RTTEST hTest)
1683	{
1684	PRTTESTINT pTest = hTest;
1685	RTTEST_GET_VALID_RETURN(pTest);
1686
1687	ASMAtomicIncU32(&pTest->cErrors);
1688
1689	return VINF_SUCCESS;
1690	}
1691
1692
1693
1694	/**
1695	* Get the current error count.
1696	*
1697	* @returns The error counter, UINT32_MAX if no valid test handle.
1698	* @param hTest The test handle. If NIL_RTTEST we'll use the one
1699	* associated with the calling thread.
1700	*/
1701	RTR3DECL(uint32_t) RTTestErrorCount(RTTEST hTest)
1702	{
1703	PRTTESTINT pTest = hTest;
1704	RTTEST_GET_VALID_RETURN_RC(pTest, UINT32_MAX);
1705
1706	return ASMAtomicReadU32(&pTest->cErrors);
1707	}
1708
1709
1710	RTR3DECL(uint32_t) RTTestSubErrorCount(RTTEST hTest)
1711	{
1712	PRTTESTINT pTest = hTest;
1713	RTTEST_GET_VALID_RETURN_RC(pTest, UINT32_MAX);
1714
1715	return ASMAtomicReadU32(&pTest->cErrors) - pTest->cSubTestAtErrors;
1716	}
1717
1718
1719	/**
1720	* Increments the error counter and prints a failure message.
1721	*
1722	* @returns IPRT status code.
1723	* @param hTest The test handle. If NIL_RTTEST we'll use the one
1724	* associated with the calling thread.
1725	* @param pszFormat The message. No trailing newline.
1726	* @param va The arguments.
1727	*/
1728	RTR3DECL(int) RTTestFailedV(RTTEST hTest, const char *pszFormat, va_list va)
1729	{
1730	PRTTESTINT pTest = hTest;
1731	RTTEST_GET_VALID_RETURN_RC(pTest, VERR_INVALID_HANDLE);
1732
1733	RTTestErrorInc(pTest);
1734
1735	int cch = 0;
1736	if (pTest->enmMaxLevel >= RTTESTLVL_FAILURE)
1737	{
1738	va_list va2;
1739	va_copy(va2, va);
1740
1741	const char *pszEnd = strchr(pszFormat, '\0');
1742	bool fHasNewLine = pszFormat != pszEnd
1743	&& pszEnd[-1] == '\n';
1744
1745	RTCritSectEnter(&pTest->OutputLock);
1746	cch += rtTestPrintf(pTest, fHasNewLine ? "%N" : "%N\n", pszFormat, &va2);
1747	if (pTest->pszErrCtx)
1748	{
1749	cch += rtTestPrintf(pTest, "context: %s\n", pTest->pszErrCtx);
1750	RTStrFree(pTest->pszErrCtx);
1751	pTest->pszErrCtx = NULL;
1752	}
1753	RTCritSectLeave(&pTest->OutputLock);
1754
1755	va_end(va2);
1756	}
1757
1758	return cch;
1759	}
1760
1761
1762	/**
1763	* Increments the error counter and prints a failure message.
1764	*
1765	* @returns IPRT status code.
1766	* @param hTest The test handle. If NIL_RTTEST we'll use the one
1767	* associated with the calling thread.
1768	* @param pszFormat The message. No trailing newline.
1769	* @param ... The arguments.
1770	*/
1771	RTR3DECL(int) RTTestFailed(RTTEST hTest, const char *pszFormat, ...)
1772	{
1773	va_list va;
1774
1775	va_start(va, pszFormat);
1776	int cch = RTTestFailedV(hTest, pszFormat, va);
1777	va_end(va);
1778
1779	return cch;
1780	}
1781
1782
1783	/**
1784	* Same as RTTestPrintfV with RTTESTLVL_FAILURE.
1785	*
1786	* @returns Number of chars printed.
1787	* @param hTest The test handle. If NIL_RTTEST we'll use the one
1788	* associated with the calling thread.
1789	* @param pszFormat The message.
1790	* @param va Arguments.
1791	*/
1792	RTR3DECL(int) RTTestFailureDetailsV(RTTEST hTest, const char *pszFormat, va_list va)
1793	{
1794	return RTTestPrintfV(hTest, RTTESTLVL_FAILURE, pszFormat, va);
1795	}
1796
1797
1798	/**
1799	* Same as RTTestPrintf with RTTESTLVL_FAILURE.
1800	*
1801	* @returns Number of chars printed.
1802	* @param hTest The test handle. If NIL_RTTEST we'll use the one
1803	* associated with the calling thread.
1804	* @param pszFormat The message.
1805	* @param ... Arguments.
1806	*/
1807	RTR3DECL(int) RTTestFailureDetails(RTTEST hTest, const char *pszFormat, ...)
1808	{
1809	va_list va;
1810	va_start(va, pszFormat);
1811	int cch = RTTestFailureDetailsV(hTest, pszFormat, va);
1812	va_end(va);
1813	return cch;
1814	}
1815
1816
1817	RTR3DECL(int) RTTestErrContextV(RTTEST hTest, const char *pszFormat, va_list va)
1818	{
1819	PRTTESTINT pTest = hTest;
1820	RTTEST_GET_VALID_RETURN(pTest);
1821
1822	RTStrFree(pTest->pszErrCtx);
1823	pTest->pszErrCtx = NULL;
1824
1825	if (pszFormat && *pszFormat)
1826	{
1827	pTest->pszErrCtx = RTStrAPrintf2V(pszFormat, va);
1828	AssertReturn(pTest->pszErrCtx, VERR_NO_STR_MEMORY);
1829	RTStrStripR(pTest->pszErrCtx);
1830	}
1831
1832	return VINF_SUCCESS;
1833	}
1834
1835
1836	RTR3DECL(int) RTTestErrContext(RTTEST hTest, const char *pszFormat, ...)
1837	{
1838	va_list va;
1839	va_start(va, pszFormat);
1840	int rc = RTTestErrContextV(hTest, pszFormat, va);
1841	va_end(va);
1842	return rc;
1843	}
1844
1845
1846	RTR3DECL(int) RTTestDisableAssertions(RTTEST hTest)
1847	{
1848	PRTTESTINT pTest = hTest;
1849	RTTEST_GET_VALID_RETURN(pTest);
1850
1851	uint32_t cTimes = ASMAtomicIncU32(&pTest->cAssertionsDisabledAndQuieted);
1852	if (cTimes >= 2 && cTimes <= 8)
1853	return VINF_SUCCESS;
1854	if (cTimes > 8)
1855	{
1856	RTAssertSetMayPanic(pTest->fAssertSavedMayPanic);
1857	RTAssertSetQuiet(pTest->fAssertSavedQuiet);
1858	Assert(cTimes <= 8);
1859	}
1860	pTest->fAssertSavedMayPanic = RTAssertSetMayPanic(false);
1861	pTest->fAssertSavedQuiet = RTAssertSetQuiet(true);
1862	return VINF_SUCCESS;
1863	}
1864
1865
1866	RTR3DECL(int) RTTestRestoreAssertions(RTTEST hTest)
1867	{
1868	PRTTESTINT pTest = hTest;
1869	RTTEST_GET_VALID_RETURN(pTest);
1870
1871	uint32_t cTimes = ASMAtomicDecU32(&pTest->cAssertionsDisabledAndQuieted);
1872	if (cTimes == 0)
1873	{
1874	RTAssertSetMayPanic(pTest->fAssertSavedMayPanic);
1875	RTAssertSetQuiet(pTest->fAssertSavedQuiet);
1876	}
1877	else
1878	AssertStmt(cTimes < UINT32_MAX / 2, ASMAtomicIncU32(&pTest->cAssertionsDisabledAndQuieted));
1879	return VINF_SUCCESS;
1880	}
1881

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

source: vbox/trunk/src/VBox/Runtime/r3/test.cpp@ 98456

Download in other formats: