tstHandleTable.cpp@ 16684

Last change on this file since 16684 was 11822, checked in by vboxsync, 16 years ago
IPRT: RTR3Init cleanup.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 19.9 KB

Line
1	/* $Id: tstHandleTable.cpp 11822 2008-08-29 14:21:03Z vboxsync $ */
2	/** @file
3	* IPRT Testcase - Handle Tables.
4	*/
5
6	/*
7	* Copyright (C) 2008 Sun Microsystems, Inc.
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*
26	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
27	* Clara, CA 95054 USA or visit http://www.sun.com if you need
28	* additional information or have any questions.
29	*/
30
31	/*******************************************************************************
32	* Header Files *
33	*******************************************************************************/
34	#include <iprt/handletable.h>
35	#include <iprt/stream.h>
36	#include <iprt/initterm.h>
37	#include <iprt/err.h>
38	#include <iprt/getopt.h>
39	#include <iprt/mem.h>
40	#include <iprt/alloca.h>
41	#include <iprt/thread.h>
42	#include <iprt/string.h>
43
44
45	/*******************************************************************************
46	* Global Variables *
47	*******************************************************************************/
48	static unsigned g_cErrors;
49
50	static DECLCALLBACK(void) tstHandleTableTest1Delete(RTHANDLETABLE hHandleTable, uint32_t h, void pvObj, void pvCtx, void *pvUser)
51	{
52	uint32_t pcCalls = (uint32_t )pvUser;
53	(*pcCalls)++;
54	}
55
56	static DECLCALLBACK(int) tstHandleTableTest1Retain(RTHANDLETABLE hHandleTable, void pvObj, void pvCtx, void *pvUser)
57	{
58	uint32_t pcCalls = (uint32_t )pvUser;
59	(*pcCalls)++;
60	return VINF_SUCCESS;
61	}
62
63	static int tstHandleTableTest1(uint32_t uBase, uint32_t cMax, uint32_t cDelta, uint32_t cUnitsPerDot, bool fCallbacks, uint32_t fFlags)
64	{
65	const char *pszWithCtx = fFlags & RTHANDLETABLE_FLAGS_CONTEXT ? "WithCtx" : "";
66	uint32_t cRetainerCalls = 0;
67	int rc;
68
69	RTPrintf("tstHandleTable: TESTING RTHandleTableCreateEx(, 0");
70	if (fFlags & RTHANDLETABLE_FLAGS_LOCKED) RTPrintf(" \| LOCKED");
71	if (fFlags & RTHANDLETABLE_FLAGS_CONTEXT) RTPrintf(" \| CONTEXT");
72	RTPrintf(", %#x, %#x,,)...\n", uBase, cMax);
73
74	RTHANDLETABLE hHT;
75	rc = RTHandleTableCreateEx(&hHT, fFlags, uBase, cMax,
76	fCallbacks ? tstHandleTableTest1Retain : NULL,
77	fCallbacks ? &cRetainerCalls : NULL);
78	if (RT_FAILURE(rc))
79	{
80	RTPrintf("\ntstHandleTable: FAILURE - RTHandleTableCreateEx failed, %Rrc!\n", rc);
81	return 1;
82	}
83
84	/* fill it */
85	RTPrintf("tstHandleTable: TESTING RTHandleTableAlloc%s..", pszWithCtx); RTStrmFlush(g_pStdOut);
86	uint32_t i = uBase;
87	for (;; i++)
88	{
89	uint32_t h;
90	if (fFlags & RTHANDLETABLE_FLAGS_CONTEXT)
91	rc = RTHandleTableAllocWithCtx(hHT, (void )((uintptr_t)&i + (uintptr_t)i 4), NULL, &h);
92	else
93	rc = RTHandleTableAlloc(hHT, (void )((uintptr_t)&i + (uintptr_t)i 4), &h);
94	if (RT_SUCCESS(rc))
95	{
96	if (h != i)
97	{
98	RTPrintf("\ntstHandleTable: FAILURE (%d) - h=%d, expected %d!\n", __LINE__, h, i);
99	g_cErrors++;
100	}
101	}
102	else if (rc == VERR_NO_MORE_HANDLES)
103	{
104	if (i < cMax)
105	{
106	RTPrintf("\ntstHandleTable: FAILURE (%d) - i=%d, expected > 65534!\n", __LINE__, i);
107	g_cErrors++;
108	}
109	break;
110	}
111	else
112	{
113	RTPrintf("\ntstHandleTable: FAILURE (%d) - i=%d, rc=%Rrc!\n", __LINE__, i, rc);
114	g_cErrors++;
115	}
116	if (!(i % cUnitsPerDot))
117	{
118	RTPrintf(".");
119	RTStrmFlush(g_pStdOut);
120	}
121	}
122	uint32_t const c = i;
123	RTPrintf(" c=%#x\n", c);
124	if (fCallbacks && cRetainerCalls != 0)
125	{
126	RTPrintf("tstHandleTable: FAILURE (%d) - cRetainerCalls=%#x expected 0!\n", __LINE__, i, cRetainerCalls);
127	g_cErrors++;
128	}
129
130	/* look up all the entries */
131	RTPrintf("tstHandleTable: TESTING RTHandleTableLookup%s..", pszWithCtx); RTStrmFlush(g_pStdOut);
132	cRetainerCalls = 0;
133	for (i = uBase; i < c; i++)
134	{
135	void pvExpect = (void )((uintptr_t)&i + (uintptr_t)i * 4);
136	void *pvObj;
137	if (fFlags & RTHANDLETABLE_FLAGS_CONTEXT)
138	pvObj = RTHandleTableLookupWithCtx(hHT, i, NULL);
139	else
140	pvObj = RTHandleTableLookup(hHT, i);
141	if (!pvObj)
142	{
143	RTPrintf("\ntstHandleTable: FAILURE (%d) - i=%d, RTHandleTableLookup%s failed!\n", __LINE__, i, pszWithCtx);
144	g_cErrors++;
145	}
146	else if (pvObj != pvExpect)
147	{
148	RTPrintf("\ntstHandleTable: FAILURE (%d) - i=%d, pvObj=%p expected %p\n", __LINE__, i, pvObj, pvExpect);
149	g_cErrors++;
150	}
151	if (!(i % cUnitsPerDot))
152	{
153	RTPrintf(".");
154	RTStrmFlush(g_pStdOut);
155	}
156	}
157	RTPrintf("\n");
158	if (fCallbacks && cRetainerCalls != c - uBase)
159	{
160	RTPrintf("tstHandleTable: FAILURE (%d) - cRetainerCalls=%#x expected %#x!\n", __LINE__, cRetainerCalls, c - uBase);
161	g_cErrors++;
162	}
163
164	/* remove all the entries (in order) */
165	RTPrintf("tstHandleTable: TESTING RTHandleTableFree%s..", pszWithCtx); RTStrmFlush(g_pStdOut);
166	cRetainerCalls = 0;
167	for (i = uBase; i < c; i++)
168	{
169	void pvExpect = (void )((uintptr_t)&i + (uintptr_t)i * 4);
170	void *pvObj;
171	if (fFlags & RTHANDLETABLE_FLAGS_CONTEXT)
172	pvObj = RTHandleTableFreeWithCtx(hHT, i, NULL);
173	else
174	pvObj = RTHandleTableFree(hHT, i);
175	if (!pvObj)
176	{
177	RTPrintf("\ntstHandleTable: FAILURE (%d) - i=%d, RTHandleTableLookup%s failed!\n", __LINE__, i, pszWithCtx);
178	g_cErrors++;
179	}
180	else if (pvObj != pvExpect)
181	{
182	RTPrintf("\ntstHandleTable: FAILURE (%d) - i=%d, pvObj=%p expected %p\n", __LINE__, i, pvObj, pvExpect);
183	g_cErrors++;
184	}
185	else if ( fFlags & RTHANDLETABLE_FLAGS_CONTEXT
186	? RTHandleTableLookupWithCtx(hHT, i, NULL)
187	: RTHandleTableLookup(hHT, i))
188	{
189	RTPrintf("\ntstHandleTable: FAILURE (%d) - i=%d, RTHandleTableLookup%s succeeded after free!\n", __LINE__, i, pszWithCtx);
190	g_cErrors++;
191	}
192	if (!(i % cUnitsPerDot))
193	{
194	RTPrintf(".");
195	RTStrmFlush(g_pStdOut);
196	}
197	}
198	RTPrintf("\n");
199	if (fCallbacks && cRetainerCalls != c - uBase)
200	{
201	RTPrintf("tstHandleTable: FAILURE (%d) - cRetainerCalls=%#x expected %#x!\n", __LINE__, cRetainerCalls, c - uBase);
202	g_cErrors++;
203	}
204
205	/* do a mix of alloc, lookup and free where there is a constant of cDelta handles in the table. */
206	RTPrintf("tstHandleTable: TESTING Alloc,Lookup,Free mix [cDelta=%#x]..", cDelta); RTStrmFlush(g_pStdOut);
207	for (i = uBase; i < c * 2; i++)
208	{
209	/* alloc */
210	uint32_t hExpect = ((i - uBase) % (c - uBase)) + uBase;
211	uint32_t h;
212	if (fFlags & RTHANDLETABLE_FLAGS_CONTEXT)
213	rc = RTHandleTableAllocWithCtx(hHT, (void )((uintptr_t)&i + (uintptr_t)hExpect 4), NULL, &h);
214	else
215	rc = RTHandleTableAlloc(hHT, (void )((uintptr_t)&i + (uintptr_t)hExpect 4), &h);
216	if (RT_FAILURE(rc))
217	{
218	RTPrintf("\ntstHandleTable: FAILURE (%d) - i=%d, RTHandleTableAlloc%s: rc=%Rrc!\n", __LINE__, i, pszWithCtx, rc);
219	g_cErrors++;
220	}
221	else if (h != hExpect)
222	{
223	RTPrintf("\ntstHandleTable: FAILURE (%d) - i=%d, RTHandleTableAlloc%s: h=%u hExpect=%u! - abort sub-test\n", __LINE__, i, pszWithCtx, h, hExpect);
224	g_cErrors++;
225	break;
226	}
227
228	if (i >= cDelta + uBase)
229	{
230	/* lookup */
231	for (uint32_t j = i - cDelta; j <= i; j++)
232	{
233	uint32_t hLookup = ((j - uBase) % (c - uBase)) + uBase;
234	void pvExpect = (void )((uintptr_t)&i + (uintptr_t)hLookup * 4);
235	void *pvObj;
236	if (fFlags & RTHANDLETABLE_FLAGS_CONTEXT)
237	pvObj = RTHandleTableLookupWithCtx(hHT, hLookup, NULL);
238	else
239	pvObj = RTHandleTableLookup(hHT, hLookup);
240	if (pvObj != pvExpect)
241	{
242	RTPrintf("\ntstHandleTable: FAILURE (%d) - i=%d, j=%d, RTHandleTableLookup%s(,%u,): pvObj=%p expected %p!\n",
243	__LINE__, i, j, pszWithCtx, hLookup, pvObj, pvExpect);
244	g_cErrors++;
245	}
246	else if ( (fFlags & RTHANDLETABLE_FLAGS_CONTEXT)
247	&& RTHandleTableLookupWithCtx(hHT, hLookup, &i))
248	{
249	RTPrintf("\ntstHandleTable: FAILURE (%d) - i=%d, j=%d, RTHandleTableLookupWithCtx: succeeded with bad context\n",
250	__LINE__, i, j, pvObj, pvExpect);
251	g_cErrors++;
252	}
253	}
254
255	/* free */
256	uint32_t hFree = ((i - uBase - cDelta) % (c - uBase)) + uBase;
257	void pvExpect = (void )((uintptr_t)&i + (uintptr_t)hFree * 4);
258	void *pvObj;
259	if (fFlags & RTHANDLETABLE_FLAGS_CONTEXT)
260	pvObj = RTHandleTableFreeWithCtx(hHT, hFree, NULL);
261	else
262	pvObj = RTHandleTableFree(hHT, hFree);
263	if (pvObj != pvExpect)
264	{
265	RTPrintf("\ntstHandleTable: FAILURE (%d) - i=%d, RTHandleTableFree%s: pvObj=%p expected %p!\n",
266	__LINE__, i, pszWithCtx, pvObj, pvExpect);
267	g_cErrors++;
268	}
269	else if (fFlags & RTHANDLETABLE_FLAGS_CONTEXT
270	? RTHandleTableLookupWithCtx(hHT, hFree, NULL)
271	\|\| RTHandleTableFreeWithCtx(hHT, hFree, NULL)
272	: RTHandleTableLookup(hHT, hFree)
273	\|\| RTHandleTableFree(hHT, hFree))
274	{
275	RTPrintf("\ntstHandleTable: FAILURE (%d) - i=%d, RTHandleTableLookup/Free%s: succeeded after free\n",
276	__LINE__, i, pszWithCtx);
277	g_cErrors++;
278	}
279	}
280	if (!(i % (cUnitsPerDot * 2)))
281	{
282	RTPrintf(".");
283	RTStrmFlush(g_pStdOut);
284	}
285	}
286	RTPrintf("\n");
287
288	/* finally, destroy the table (note that there are 128 entries in it). */
289	cRetainerCalls = 0;
290	uint32_t cDeleteCalls = 0;
291	rc = RTHandleTableDestroy(hHT,
292	fCallbacks ? tstHandleTableTest1Delete : NULL,
293	fCallbacks ? &cDeleteCalls : NULL);
294	if (RT_FAILURE(rc))
295	{
296	RTPrintf("tstHandleTable: FAILURE (%d) - RTHandleTableDestroy failed, %Rrc!\n", __LINE__, rc);
297	g_cErrors++;
298	}
299
300	return 0;
301	}
302
303
304	typedef struct TSTHTTEST2ARGS
305	{
306	/** The handle table. */
307	RTHANDLETABLE hHT;
308	/** The thread handle. */
309	RTTHREAD hThread;
310	/** Thread index. */
311	uint32_t iThread;
312	/** the max number of handles the thread should allocate. */
313	uint32_t cMax;
314	} TSTHTTEST2ARGS, *PTSTHTTEST2ARGS;
315
316
317	static DECLCALLBACK(int) tstHandleTableTest2Thread(RTTHREAD hThread, void *pvUser)
318	{
319	RTHANDLETABLE const hHT = ((PTSTHTTEST2ARGS)pvUser)->hHT;
320	uint32_t const iThread = ((PTSTHTTEST2ARGS)pvUser)->iThread;
321	uint32_t const cMax = ((PTSTHTTEST2ARGS)pvUser)->cMax;
322	uint32_t pah = (uint32_t )RTMemAllocZ(sizeof(uint32_t) * cMax);
323	if (!pah)
324	{
325	RTPrintf("tstHandleTable: FAILURE (%d) - failed to allocate %zu bytes\n", __LINE__, sizeof(uint32_t) * cMax);
326	return VERR_NO_MEMORY;
327	}
328
329	/*
330	* Allocate our quota.
331	*/
332	for (uint32_t i = 0; i < cMax; i++)
333	{
334	int rc = RTHandleTableAllocWithCtx(hHT, pvUser, hThread, &pah[i]);
335	if (RT_FAILURE(rc))
336	{
337	RTPrintf("tstHandleTable: FAILURE (%d) - t=%d i=%d: RTHandleTableAllocWithCtx failed, rc=%Rrc\n",
338	__LINE__, iThread, i, rc);
339	return rc;
340	}
341	}
342
343	/*
344	* Look them up.
345	*/
346	for (uint32_t i = 0; i < cMax; i++)
347	{
348	void *pvObj = RTHandleTableLookupWithCtx(hHT, pah[i], hThread);
349	if (pvObj != pvUser)
350	{
351	RTPrintf("tstHandleTable: FAILURE (%d) - t=%d i=%d: RTHandleTableLookupWithCtx failed, pvObj=%p\n",
352	__LINE__, iThread, i, pvObj);
353	return VERR_INTERNAL_ERROR;
354	}
355	}
356
357	/*
358	* Free them all.
359	*/
360	for (uint32_t i = 0; i < cMax; i++)
361	{
362	void *pvObj = RTHandleTableFreeWithCtx(hHT, pah[i], hThread);
363	if (pvObj != pvUser)
364	{
365	RTPrintf("tstHandleTable: FAILURE (%d) - t=%d i=%d: RTHandleTableFreeWithCtx failed, pvObj=%p\n",
366	__LINE__, iThread, i, pvObj);
367	return VERR_INTERNAL_ERROR;
368	}
369	}
370
371	RTMemFree(pah);
372	return VINF_SUCCESS;
373	}
374
375	static int tstHandleTableTest2(uint32_t uBase, uint32_t cMax, uint32_t cThreads)
376	{
377	/*
378	* Create the table.
379	*/
380	RTPrintf("tstHandleTable: TESTING %u threads: uBase=%u, cMax=%u\n", cThreads, uBase, cMax);
381	RTHANDLETABLE hHT;
382	int rc = RTHandleTableCreateEx(&hHT, RTHANDLETABLE_FLAGS_LOCKED \| RTHANDLETABLE_FLAGS_CONTEXT, uBase, cMax, NULL, NULL);
383	if (RT_FAILURE(rc))
384	{
385	RTPrintf("tstHandleTable: FAILURE - RTHandleTableCreateEx failed, %Rrc!\n", rc);
386	return 1;
387	}
388	/// @todo there must be a race somewhere in the thread code, I keep hitting a duplicate insert id here...
389	// Or perhaps it just barcelona B2 bugs?
390	RTThreadSleep(50);
391
392	/*
393	* Spawn the threads.
394	*/
395	PTSTHTTEST2ARGS paThread = (PTSTHTTEST2ARGS)alloca(sizeof(paThread) cThreads);
396	for (uint32_t i = 0; i < cThreads; i++)
397	{
398	paThread[i].hHT = hHT;
399	paThread[i].hThread = NIL_RTTHREAD;
400	paThread[i].iThread = i;
401	paThread[i].cMax = cMax / cThreads;
402	}
403	for (uint32_t i = 0; i < cThreads; i++)
404	{
405	char szName[32];
406	RTStrPrintf(szName, sizeof(szName), "TEST2-%x/%x", i, cMax);
407	rc = RTThreadCreate(&paThread[i].hThread, tstHandleTableTest2Thread, &paThread[i], 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, szName);
408	if (RT_FAILURE(rc))
409	{
410	RTPrintf("tstHandleTable: FAILURE - RTThreadCreate failed, %Rrc!\n", rc);
411	g_cErrors++;
412	break;
413	}
414	}
415
416	/*
417	* Wait for them to complete.
418	*/
419	uint32_t cRunning = cThreads;
420	do /** @todo Remove when RTSemEventWait (linux) has been fixed. */
421	{
422	if (cRunning != cThreads)
423	RTThreadSleep(10);
424	cRunning = 0;
425	for (uint32_t i = 0; i < cThreads; i++)
426	if (paThread[i].hThread != NIL_RTTHREAD)
427	{
428	rc = RTThreadWait(paThread[i].hThread, RT_INDEFINITE_WAIT, NULL);
429	if (RT_SUCCESS(rc))
430	paThread[i].hThread = NIL_RTTHREAD;
431	else
432	cRunning++;
433	}
434	} while (cRunning);
435
436	/*
437	* Destroy the handle table.
438	*/
439	rc = RTHandleTableDestroy(hHT, NULL, NULL);
440	if (RT_FAILURE(rc))
441	{
442	RTPrintf("tstHandleTable: FAILURE (%d) - RTHandleTableDestroy failed, %Rrc!\n", __LINE__, rc);
443	g_cErrors++;
444	}
445
446	return 0;
447	}
448
449
450	int main(int argc, char **argv)
451	{
452	/*
453	* Init the runtime and parse the arguments.
454	*/
455	RTR3Init();
456
457	static RTOPTIONDEF const s_aOptions[] =
458	{
459	{ "--base", 'b', RTGETOPT_REQ_UINT32 },
460	{ "--max", 'm', RTGETOPT_REQ_UINT32 },
461	{ "--threads", 't', RTGETOPT_REQ_UINT32 },
462	{ "--help", 'h', RTGETOPT_REQ_NOTHING },
463	{ "--?", '?', RTGETOPT_REQ_NOTHING },
464	};
465
466	uint32_t uBase = 0;
467	uint32_t cMax = 0;
468	uint32_t cThreads = 0;
469
470	int ch;
471	int iArg = 1;
472	RTOPTIONUNION Value;
473	while ((ch = RTGetOpt(argc,argv, &s_aOptions[0], RT_ELEMENTS(s_aOptions), &iArg, &Value)))
474	switch (ch)
475	{
476	case 'b':
477	uBase = Value.u32;
478	break;
479
480	case 'm':
481	cMax = Value.u32;
482	break;
483
484	case 't':
485	cThreads = Value.u32;
486	if (!cThreads)
487	cThreads = 1;
488	break;
489
490	case '?':
491	case 'h':
492	RTPrintf("syntax: tstHandleTable [-b <base>] [-m <max>] [-t <threads>]\n");
493	return 1;
494
495	default:
496	if (RT_SUCCESS(ch))
497	RTPrintf("tstHandleTable: invalid argument (%#x): %s\n", ch, Value.psz);
498	else
499	RTPrintf("tstHandleTable: invalid argument: %Rrc - \n", ch, Value.pDef->pszLong);
500	return 1;
501	}
502	if (iArg < argc)
503	{
504	RTPrintf("tstHandleTable: invalid argument: %s\n", argv[iArg]);
505	return 1;
506	}
507
508	/*
509	* If any argument was specified, run the requested test setup.
510	* Otherwise run a bunch of default tests.
511	*/
512	if (cThreads \|\| cMax \|\| uBase)
513	{
514	if (!cMax)
515	cMax = 65535;
516	if (!cThreads)
517	tstHandleTableTest1(uBase, cMax, 128, cMax / 32, false, RTHANDLETABLE_FLAGS_CONTEXT \| RTHANDLETABLE_FLAGS_LOCKED);
518	else
519	tstHandleTableTest2(uBase, cMax, 128);
520	}
521	else
522	{
523	/*
524	* Do a simple warmup / smoke test first.
525	*/
526	tstHandleTableTest1(1, 65534, 128, 2048, false, 0);
527	tstHandleTableTest1(1, 65534, 128, 2048, false, RTHANDLETABLE_FLAGS_CONTEXT);
528	tstHandleTableTest1(1, 65534, 63, 2048, false, RTHANDLETABLE_FLAGS_LOCKED);
529	tstHandleTableTest1(1, 65534, 63, 2048, false, RTHANDLETABLE_FLAGS_CONTEXT \| RTHANDLETABLE_FLAGS_LOCKED);
530	/* Test that the retain and delete functions work. */
531	tstHandleTableTest1(1, 1024, 256, 256, true, RTHANDLETABLE_FLAGS_LOCKED);
532	tstHandleTableTest1(1, 1024, 256, 256, true, RTHANDLETABLE_FLAGS_CONTEXT \| RTHANDLETABLE_FLAGS_LOCKED);
533	/* check that the base works. */
534	tstHandleTableTest1(0x7ffff000, 65534, 4, 2048, false, RTHANDLETABLE_FLAGS_CONTEXT \| RTHANDLETABLE_FLAGS_LOCKED);
535	tstHandleTableTest1(0xeffff000, 65534, 4, 2048, false, RTHANDLETABLE_FLAGS_CONTEXT \| RTHANDLETABLE_FLAGS_LOCKED);
536	tstHandleTableTest1(0, 4097, 4, 256, false, RTHANDLETABLE_FLAGS_CONTEXT \| RTHANDLETABLE_FLAGS_LOCKED);
537	tstHandleTableTest1(0, 1024, 4, 128, false, RTHANDLETABLE_FLAGS_CONTEXT \| RTHANDLETABLE_FLAGS_LOCKED);
538	/* For testing 1st level expansion / reallocation. */
539	tstHandleTableTest1(1, 102410248, 3, 150000, false, 0);
540	tstHandleTableTest1(1, 102410248, 3, 150000, false, RTHANDLETABLE_FLAGS_CONTEXT);
541
542	/*
543	* Threaded tests.
544	*/
545	tstHandleTableTest2(0x80000000, 32768, 2);
546	tstHandleTableTest2(0x00010000, 2048, 4);
547	tstHandleTableTest2(0x00010000, 3072, 8);
548	tstHandleTableTest2(0x00000000, 102410248, 3);
549	}
550
551	/*
552	* Summary.
553	*/
554	if (!g_cErrors)
555	RTPrintf("tstHandleTable: SUCCESS\n");
556	else
557	RTPrintf("tstHandleTable: FAILURE - %d errors\n", g_cErrors);
558
559	return !!g_cErrors;
560	}

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

source: vbox/trunk/src/VBox/Runtime/testcase/tstHandleTable.cpp@ 16684

Download in other formats: