VirtualBox

source: vbox/trunk/src/VBox/Runtime/testcase/tstMemAutoPtr.cpp@ 23299

Last change on this file since 23299 was 11822, checked in by vboxsync, 16 years ago

IPRT: RTR3Init cleanup.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 8.7 KB
Line 
1/* $Id: tstMemAutoPtr.cpp 11822 2008-08-29 14:21:03Z vboxsync $ */
2/** @file
3 * IPRT - Testcase the RTMemAutoPtr template.
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/mem.h>
35#include <iprt/stream.h>
36#include <iprt/initterm.h>
37#include <iprt/string.h>
38#include <iprt/rand.h>
39
40
41/*******************************************************************************
42* Structures and Typedefs *
43*******************************************************************************/
44typedef struct TSTMEMAUTOPTRSTRUCT
45{
46 uint32_t a;
47 uint32_t b;
48 uint32_t c;
49} TSTMEMAUTOPTRSTRUCT;
50
51
52/*******************************************************************************
53* Global Variables *
54*******************************************************************************/
55#ifndef TST_MEM_AUTO_PTR_ONLY_DISAS
56static unsigned g_cErrors = 0;
57static unsigned g_cFrees;
58#endif
59
60
61/*
62 * Feel free to inspect with gdb / objdump / whatever / g++ -fverbose-asm in
63 * a release build and compare with tstMemAutoPtrDisas1PureC.
64 */
65extern "C" int tstMemAutoPtrDisas1(void **ppv)
66{
67 RTMemAutoPtr<TSTMEMAUTOPTRSTRUCT> Handle(1);
68 if (!Handle)
69 {
70 Handle->a = RTRandU32();
71 if (Handle->a < UINT32_MAX / 2)
72 {
73 *ppv = Handle.release();
74 return VINF_SUCCESS;
75 }
76 }
77 return VERR_TRY_AGAIN;
78}
79
80/*
81 * For comparing to tstMemAutoPtrDisas1.
82 */
83extern "C" int tstMemAutoPtrDisas1PureC(void **ppv)
84{
85 TSTMEMAUTOPTRSTRUCT *pHandle = (TSTMEMAUTOPTRSTRUCT *)RTMemRealloc(NULL, sizeof(*pHandle));
86 if (pHandle)
87 {
88 pHandle->a = RTRandU32();
89 if (pHandle->a < UINT32_MAX / 2)
90 {
91 *ppv = pHandle;
92 return VINF_SUCCESS;
93 }
94 RTMemFree(pHandle);
95 }
96 return VERR_TRY_AGAIN;
97}
98
99
100#ifndef TST_MEM_AUTO_PTR_ONLY_DISAS
101
102template <class T>
103void tstMemAutoPtrDestructorCounter(T *aMem)
104{
105 if (aMem == NULL)
106 {
107 RTPrintf("tstMemAutoPtr(%d): Destructor called with NILL handle!\n");
108 g_cErrors++;
109 }
110 else if (!VALID_PTR(aMem))
111 {
112 RTPrintf("tstMemAutoPtr(%d): Destructor called with a bad handle %p\n", aMem);
113 g_cErrors++;
114 }
115 RTMemEfFree(aMem);
116 g_cFrees++;
117}
118
119
120void *tstMemAutoPtrAllocatorNoZero(void *pvOld, size_t cbNew)
121{
122 void *pvNew = RTMemRealloc(pvOld, cbNew);
123 if (pvNew)
124 memset(pvNew, 0xfe, cbNew);
125 return pvNew;
126}
127
128
129int main()
130{
131 RTR3Init();
132 RTPrintf("tstMemAutoPtr: TESTING...\n");
133
134#define CHECK_EXPR(expr) \
135 do { bool const f = !!(expr); if (!f) { RTPrintf("tstMemAutoPtr(%d): %s!\n", __LINE__, #expr); g_cErrors++; } } while (0)
136
137 /*
138 * Some simple stuff.
139 */
140 {
141 RTMemAutoPtr<char> NilObj;
142 CHECK_EXPR(!NilObj);
143 CHECK_EXPR(NilObj.get() == NULL);
144 CHECK_EXPR(NilObj.release() == NULL);
145 NilObj.reset();
146 }
147
148 {
149 RTMemAutoPtr<char> Alloc(10);
150 CHECK_EXPR(Alloc.get() != NULL);
151 char *pch = Alloc.release();
152 CHECK_EXPR(pch != NULL);
153 CHECK_EXPR(Alloc.get() == NULL);
154
155 RTMemAutoPtr<char> Manage(pch);
156 CHECK_EXPR(Manage.get() == pch);
157 CHECK_EXPR(&Manage[0] == pch);
158 CHECK_EXPR(&Manage[1] == &pch[1]);
159 CHECK_EXPR(&Manage[9] == &pch[9]);
160 }
161
162 /*
163 * Use the electric fence memory API to check alternative template
164 * arguments and also check some subscript / reference limit thing.
165 */
166 {
167 RTMemAutoPtr<char, RTMemEfAutoFree<char>, RTMemEfRealloc> Electric(10);
168 CHECK_EXPR(Electric.get() != NULL);
169 Electric[0] = '0';
170 CHECK_EXPR(Electric[0] == '0');
171 CHECK_EXPR(*Electric == '0');
172 //CHECK_EXPR(Electric == '0');
173 Electric[9] = '1';
174 CHECK_EXPR(Electric[9] == '1');
175 /* Electric[10] = '2'; - this will crash (of course) */
176 }
177
178 /*
179 * Check that memory is actually free when it should be and isn't when it shouldn't.
180 * Use the electric heap to get some extra checks.
181 */
182 g_cFrees = 0;
183 {
184 RTMemAutoPtr<char, tstMemAutoPtrDestructorCounter, RTMemEfRealloc> FreeIt(128);
185 FreeIt[127] = '0';
186 }
187 CHECK_EXPR(g_cFrees == 1);
188
189 g_cFrees = 0;
190 {
191 RTMemAutoPtr<char, tstMemAutoPtrDestructorCounter, RTMemEfRealloc> FreeIt2(128);
192 FreeIt2[127] = '1';
193 FreeIt2.reset();
194 FreeIt2.alloc(128);
195 FreeIt2[127] = '2';
196 FreeIt2.reset(FreeIt2.get()); /* this one is weird, but it's how things works... */
197 }
198 CHECK_EXPR(g_cFrees == 2);
199
200 g_cFrees = 0;
201 {
202 RTMemAutoPtr<char, tstMemAutoPtrDestructorCounter, RTMemEfRealloc> DontFreeIt(256);
203 DontFreeIt[255] = '0';
204 RTMemEfFree(DontFreeIt.release());
205 }
206 CHECK_EXPR(g_cFrees == 0);
207
208 g_cFrees = 0;
209 {
210 RTMemAutoPtr<char, tstMemAutoPtrDestructorCounter, RTMemEfRealloc> FreeIt3(128);
211 FreeIt3[127] = '0';
212 CHECK_EXPR(FreeIt3.realloc(128));
213 FreeIt3[127] = '0';
214 CHECK_EXPR(FreeIt3.realloc(256));
215 FreeIt3[255] = '0';
216 CHECK_EXPR(FreeIt3.realloc(64));
217 FreeIt3[63] = '0';
218 CHECK_EXPR(FreeIt3.realloc(32));
219 FreeIt3[31] = '0';
220 }
221 CHECK_EXPR(g_cFrees == 1);
222
223 g_cFrees = 0;
224 {
225 RTMemAutoPtr<char, tstMemAutoPtrDestructorCounter, RTMemEfRealloc> FreeIt4;
226 CHECK_EXPR(FreeIt4.alloc(123));
227 CHECK_EXPR(FreeIt4.realloc(543));
228 FreeIt4 = (char *)NULL;
229 CHECK_EXPR(FreeIt4.get() == NULL);
230 }
231 CHECK_EXPR(g_cFrees == 1);
232
233 /*
234 * Check the ->, [] and * (unary) operators with some useful struct.
235 */
236 {
237 RTMemAutoPtr<TSTMEMAUTOPTRSTRUCT> Struct1(1);
238 Struct1->a = 0x11223344;
239 Struct1->b = 0x55667788;
240 Struct1->c = 0x99aabbcc;
241 CHECK_EXPR(Struct1->a == 0x11223344);
242 CHECK_EXPR(Struct1->b == 0x55667788);
243 CHECK_EXPR(Struct1->c == 0x99aabbcc);
244
245 Struct1[0].a = 0x11223344;
246 Struct1[0].b = 0x55667788;
247 Struct1[0].c = 0x99aabbcc;
248 CHECK_EXPR(Struct1[0].a == 0x11223344);
249 CHECK_EXPR(Struct1[0].b == 0x55667788);
250 CHECK_EXPR(Struct1[0].c == 0x99aabbcc);
251
252 (*Struct1).a = 0x11223344;
253 (*Struct1).b = 0x55667788;
254 (*Struct1).c = 0x99aabbcc;
255 CHECK_EXPR((*Struct1).a == 0x11223344);
256 CHECK_EXPR((*Struct1).b == 0x55667788);
257 CHECK_EXPR((*Struct1).c == 0x99aabbcc);
258
259 /* since at it... */
260 Struct1.get()->a = 0x11223344;
261 Struct1.get()->b = 0x55667788;
262 Struct1.get()->c = 0x99aabbcc;
263 CHECK_EXPR(Struct1.get()->a == 0x11223344);
264 CHECK_EXPR(Struct1.get()->b == 0x55667788);
265 CHECK_EXPR(Struct1.get()->c == 0x99aabbcc);
266 }
267
268 /*
269 * Check the zeroing of memory.
270 */
271 {
272 RTMemAutoPtr<uint64_t, RTMemAutoDestructor<uint64_t>, tstMemAutoPtrAllocatorNoZero> Zeroed1(1, true);
273 CHECK_EXPR(*Zeroed1 == 0);
274 }
275
276 {
277 RTMemAutoPtr<uint64_t, RTMemAutoDestructor<uint64_t>, tstMemAutoPtrAllocatorNoZero> Zeroed2;
278 Zeroed2.alloc(5, true);
279 CHECK_EXPR(Zeroed2[0] == 0);
280 CHECK_EXPR(Zeroed2[1] == 0);
281 CHECK_EXPR(Zeroed2[2] == 0);
282 CHECK_EXPR(Zeroed2[3] == 0);
283 CHECK_EXPR(Zeroed2[4] == 0);
284 }
285
286 /*
287 * Summary.
288 */
289 if (!g_cErrors)
290 RTPrintf("tstMemAutoPtr: SUCCESS\n");
291 else
292 RTPrintf("tstMemAutoPtr: FAILED - %d errors\n", g_cErrors);
293 return !!g_cErrors;
294}
295#endif /* TST_MEM_AUTO_PTR_ONLY_DISAS */
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette