VirtualBox

source: vbox/trunk/src/VBox/Runtime/testcase/tstBitOperations.cpp@ 11118

Last change on this file since 11118 was 8245, checked in by vboxsync, 17 years ago

rebranding: IPRT files again.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 11.7 KB
Line 
1/* $Id: tstBitOperations.cpp 8245 2008-04-21 17:24:28Z vboxsync $ */
2/** @file
3 * IPRT Testcase - Inlined Bit Operations.
4 */
5
6/*
7 * Copyright (C) 2006-2007 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/*******************************************************************************
33* Header Files *
34*******************************************************************************/
35#include <iprt/asm.h>
36#include <iprt/stream.h>
37#include <iprt/string.h>
38
39
40int main()
41{
42 int rcRet = 0;
43 int i;
44 int j;
45 int k;
46 RTPrintf("tstBitOperations: TESTING\n");
47
48
49 /*
50 * Tests
51 */
52 uint32_t au32[4];
53 #define MAP_CLEAR(a) memset(&a, 0, sizeof(a));
54 #define MAP_SET(a) memset(&a, 0xff, sizeof(a));
55 #define DUMP() RTPrintf("au32={%08x,%08x,%08x,%08x}\n", au32[0], au32[1], au32[2], au32[3])
56 #define CHECK(expr) do { if (!(expr)) { RTPrintf("tstBitOperations: error line %d: %s\n", __LINE__, #expr); DUMP(); rcRet++; } } while (0)
57 #define CHECK_BIT(expr, b1) do { if (!(expr)) { RTPrintf("tstBitOperations: error line %d, b1=%d: %s\n", __LINE__, b1, #expr); rcRet++; } } while (0)
58 #define CHECK_BIT2(expr, b1, b2) do { if (!(expr)) { RTPrintf("tstBitOperations: error line %d, b1=%d b2=%d: %s\n", __LINE__, b1, b2, #expr); rcRet++; } } while (0)
59 #define CHECK_BIT3(expr, b1, b2, b3) do { if (!(expr)) { RTPrintf("tstBitOperations: error line %d, b1=%d b2=%d b3=%d: %s\n", __LINE__, b1, b2, b3, #expr); rcRet++; } } while (0)
60
61 /* set */
62 MAP_CLEAR(au32);
63 ASMBitSet(&au32[0], 0);
64 ASMBitSet(&au32[0], 31);
65 ASMBitSet(&au32[0], 65);
66 CHECK(au32[0] == 0x80000001U);
67 CHECK(au32[2] == 0x00000002U);
68 CHECK(ASMBitTestAndSet(&au32[0], 0) && au32[0] == 0x80000001U);
69 CHECK(!ASMBitTestAndSet(&au32[0], 16) && au32[0] == 0x80010001U);
70 CHECK(ASMBitTestAndSet(&au32[0], 16) && au32[0] == 0x80010001U);
71 CHECK(!ASMBitTestAndSet(&au32[0], 80) && au32[2] == 0x00010002U);
72
73 MAP_CLEAR(au32);
74 ASMAtomicBitSet(&au32[0], 0);
75 ASMAtomicBitSet(&au32[0], 30);
76 ASMAtomicBitSet(&au32[0], 64);
77 CHECK(au32[0] == 0x40000001U);
78 CHECK(au32[2] == 0x00000001U);
79 CHECK(ASMAtomicBitTestAndSet(&au32[0], 0) && au32[0] == 0x40000001U);
80 CHECK(!ASMAtomicBitTestAndSet(&au32[0], 16) && au32[0] == 0x40010001U);
81 CHECK(ASMAtomicBitTestAndSet(&au32[0], 16) && au32[0] == 0x40010001U);
82 CHECK(!ASMAtomicBitTestAndSet(&au32[0], 80) && au32[2] == 0x00010001U);
83
84 /* clear */
85 MAP_SET(au32);
86 ASMBitClear(&au32[0], 0);
87 ASMBitClear(&au32[0], 31);
88 ASMBitClear(&au32[0], 65);
89 CHECK(au32[0] == ~0x80000001U);
90 CHECK(au32[2] == ~0x00000002U);
91 CHECK(!ASMBitTestAndClear(&au32[0], 0) && au32[0] == ~0x80000001U);
92 CHECK(ASMBitTestAndClear(&au32[0], 16) && au32[0] == ~0x80010001U);
93 CHECK(!ASMBitTestAndClear(&au32[0], 16) && au32[0] == ~0x80010001U);
94 CHECK(ASMBitTestAndClear(&au32[0], 80) && au32[2] == ~0x00010002U);
95
96 MAP_SET(au32);
97 ASMAtomicBitClear(&au32[0], 0);
98 ASMAtomicBitClear(&au32[0], 30);
99 ASMAtomicBitClear(&au32[0], 64);
100 CHECK(au32[0] == ~0x40000001U);
101 CHECK(au32[2] == ~0x00000001U);
102 CHECK(!ASMAtomicBitTestAndClear(&au32[0], 0) && au32[0] == ~0x40000001U);
103 CHECK(ASMAtomicBitTestAndClear(&au32[0], 16) && au32[0] == ~0x40010001U);
104 CHECK(!ASMAtomicBitTestAndClear(&au32[0], 16) && au32[0] == ~0x40010001U);
105 CHECK(ASMAtomicBitTestAndClear(&au32[0], 80) && au32[2] == ~0x00010001U);
106
107 /* toggle */
108 MAP_SET(au32);
109 ASMBitToggle(&au32[0], 0);
110 ASMBitToggle(&au32[0], 31);
111 ASMBitToggle(&au32[0], 65);
112 ASMBitToggle(&au32[0], 47);
113 ASMBitToggle(&au32[0], 47);
114 CHECK(au32[0] == ~0x80000001U);
115 CHECK(au32[2] == ~0x00000002U);
116 CHECK(!ASMBitTestAndToggle(&au32[0], 0) && au32[0] == ~0x80000000U);
117 CHECK(ASMBitTestAndToggle(&au32[0], 0) && au32[0] == ~0x80000001U);
118 CHECK(ASMBitTestAndToggle(&au32[0], 16) && au32[0] == ~0x80010001U);
119 CHECK(!ASMBitTestAndToggle(&au32[0], 16) && au32[0] == ~0x80000001U);
120 CHECK(ASMBitTestAndToggle(&au32[0], 80) && au32[2] == ~0x00010002U);
121
122 MAP_SET(au32);
123 ASMAtomicBitToggle(&au32[0], 0);
124 ASMAtomicBitToggle(&au32[0], 30);
125 ASMAtomicBitToggle(&au32[0], 64);
126 ASMAtomicBitToggle(&au32[0], 47);
127 ASMAtomicBitToggle(&au32[0], 47);
128 CHECK(au32[0] == ~0x40000001U);
129 CHECK(au32[2] == ~0x00000001U);
130 CHECK(!ASMAtomicBitTestAndToggle(&au32[0], 0) && au32[0] == ~0x40000000U);
131 CHECK(ASMAtomicBitTestAndToggle(&au32[0], 0) && au32[0] == ~0x40000001U);
132 CHECK(ASMAtomicBitTestAndToggle(&au32[0], 16) && au32[0] == ~0x40010001U);
133 CHECK(!ASMAtomicBitTestAndToggle(&au32[0], 16) && au32[0] == ~0x40000001U);
134 CHECK(ASMAtomicBitTestAndToggle(&au32[0], 80) && au32[2] == ~0x00010001U);
135
136 /* test bit. */
137 for (i = 0; i < 128; i++)
138 {
139 MAP_SET(au32);
140 CHECK_BIT(ASMBitTest(&au32[0], i), i);
141 ASMBitToggle(&au32[0], i);
142 CHECK_BIT(!ASMBitTest(&au32[0], i), i);
143 CHECK_BIT(!ASMBitTestAndToggle(&au32[0], i), i);
144 CHECK_BIT(ASMBitTest(&au32[0], i), i);
145 CHECK_BIT(ASMBitTestAndToggle(&au32[0], i), i);
146 CHECK_BIT(!ASMBitTest(&au32[0], i), i);
147
148 MAP_SET(au32);
149 CHECK_BIT(ASMBitTest(&au32[0], i), i);
150 ASMAtomicBitToggle(&au32[0], i);
151 CHECK_BIT(!ASMBitTest(&au32[0], i), i);
152 CHECK_BIT(!ASMAtomicBitTestAndToggle(&au32[0], i), i);
153 CHECK_BIT(ASMBitTest(&au32[0], i), i);
154 CHECK_BIT(ASMAtomicBitTestAndToggle(&au32[0], i), i);
155 CHECK_BIT(!ASMBitTest(&au32[0], i), i);
156
157 }
158
159 /* bit searching */
160 MAP_SET(au32);
161 CHECK(ASMBitFirstClear(&au32[0], sizeof(au32) * 8) == -1);
162 CHECK(ASMBitFirstSet(&au32[0], sizeof(au32) * 8) == 0);
163
164 ASMBitClear(&au32[0], 1);
165 CHECK(ASMBitFirstClear(&au32[0], sizeof(au32) * 8) == 1);
166 CHECK(ASMBitFirstSet(&au32[0], sizeof(au32) * 8) == 0);
167
168 MAP_SET(au32);
169 ASMBitClear(&au32[0], 95);
170 CHECK(ASMBitFirstClear(&au32[0], sizeof(au32) * 8) == 95);
171 CHECK(ASMBitFirstSet(&au32[0], sizeof(au32) * 8) == 0);
172
173 MAP_SET(au32);
174 ASMBitClear(&au32[0], 127);
175 CHECK(ASMBitFirstClear(&au32[0], sizeof(au32) * 8) == 127);
176 CHECK(ASMBitFirstSet(&au32[0], sizeof(au32) * 8) == 0);
177 CHECK(ASMBitNextSet(&au32[0], sizeof(au32) * 8, 0) == 1);
178 CHECK(ASMBitNextSet(&au32[0], sizeof(au32) * 8, 1) == 2);
179 CHECK(ASMBitNextSet(&au32[0], sizeof(au32) * 8, 2) == 3);
180
181
182 MAP_SET(au32);
183 CHECK(ASMBitNextClear(&au32[0], sizeof(au32) * 8, 0) == -1);
184 ASMBitClear(&au32[0], 32);
185 CHECK(ASMBitNextClear(&au32[0], sizeof(au32) * 8, 32) == -1);
186 ASMBitClear(&au32[0], 88);
187 CHECK(ASMBitNextClear(&au32[0], sizeof(au32) * 8, 57) == 88);
188
189 MAP_SET(au32);
190 ASMBitClear(&au32[0], 31);
191 ASMBitClear(&au32[0], 57);
192 ASMBitClear(&au32[0], 88);
193 ASMBitClear(&au32[0], 101);
194 ASMBitClear(&au32[0], 126);
195 ASMBitClear(&au32[0], 127);
196 CHECK(ASMBitFirstClear(&au32[0], sizeof(au32) * 8) == 31);
197 CHECK(ASMBitNextClear(&au32[0], sizeof(au32) * 8, 31) == 57);
198 CHECK(ASMBitNextClear(&au32[0], sizeof(au32) * 8, 57) == 88);
199 CHECK(ASMBitNextClear(&au32[0], sizeof(au32) * 8, 88) == 101);
200 CHECK(ASMBitNextClear(&au32[0], sizeof(au32) * 8, 101) == 126);
201 CHECK(ASMBitNextClear(&au32[0], sizeof(au32) * 8, 126) == 127);
202 CHECK(ASMBitNextClear(&au32[0], sizeof(au32) * 8, 127) == -1);
203
204 CHECK(ASMBitNextSet(&au32[0], sizeof(au32) * 8, 29) == 30);
205 CHECK(ASMBitNextSet(&au32[0], sizeof(au32) * 8, 30) == 32);
206
207 MAP_CLEAR(au32);
208 for (i = 1; i < 128; i++)
209 CHECK_BIT(ASMBitNextClear(&au32[0], sizeof(au32) * 8, i - 1) == i, i);
210 for (i = 0; i < 128; i++)
211 {
212 MAP_SET(au32);
213 ASMBitClear(&au32[0], i);
214 CHECK_BIT(ASMBitFirstClear(&au32[0], sizeof(au32) * 8) == i, i);
215 for (j = 0; j < i; j++)
216 CHECK_BIT(ASMBitNextClear(&au32[0], sizeof(au32) * 8, j) == i, i);
217 for (j = i; j < 128; j++)
218 CHECK_BIT(ASMBitNextClear(&au32[0], sizeof(au32) * 8, j) == -1, i);
219 }
220
221 /* clear range. */
222 MAP_SET(au32);
223 ASMBitClearRange(&au32, 0, 128);
224 CHECK(!au32[0] && !au32[1] && !au32[2] && !au32[3]);
225 for (i = 0; i < 128; i++)
226 {
227 for (j = i + 1; j <= 128; j++)
228 {
229 MAP_SET(au32);
230 ASMBitClearRange(&au32, i, j);
231 for (k = 0; k < i; k++)
232 CHECK_BIT3(ASMBitTest(&au32[0], k), i, j, k);
233 for (k = i; k < j; k++)
234 CHECK_BIT3(!ASMBitTest(&au32[0], k), i, j, k);
235 for (k = j; k < 128; k++)
236 CHECK_BIT3(ASMBitTest(&au32[0], k), i, j, k);
237 }
238 }
239
240 /* searching for set bits. */
241 MAP_CLEAR(au32);
242 CHECK(ASMBitFirstSet(&au32[0], sizeof(au32) * 8) == -1);
243
244 ASMBitSet(&au32[0], 65);
245 CHECK(ASMBitFirstSet(&au32[0], sizeof(au32) * 8) == 65);
246 CHECK(ASMBitNextSet(&au32[0], sizeof(au32) * 8, 65) == -1);
247 for (i = 0; i < 65; i++)
248 CHECK(ASMBitNextSet(&au32[0], sizeof(au32) * 8, i) == 65);
249 for (i = 65; i < 128; i++)
250 CHECK(ASMBitNextSet(&au32[0], sizeof(au32) * 8, i) == -1);
251
252 ASMBitSet(&au32[0], 17);
253 CHECK(ASMBitFirstSet(&au32[0], sizeof(au32) * 8) == 17);
254 CHECK(ASMBitNextSet(&au32[0], sizeof(au32) * 8, 17) == 65);
255 for (i = 0; i < 16; i++)
256 CHECK(ASMBitNextSet(&au32[0], sizeof(au32) * 8, i) == 17);
257 for (i = 17; i < 65; i++)
258 CHECK(ASMBitNextSet(&au32[0], sizeof(au32) * 8, i) == 65);
259
260 MAP_SET(au32);
261 for (i = 1; i < 128; i++)
262 CHECK_BIT(ASMBitNextSet(&au32[0], sizeof(au32) * 8, i - 1) == i, i);
263 for (i = 0; i < 128; i++)
264 {
265 MAP_CLEAR(au32);
266 ASMBitSet(&au32[0], i);
267 CHECK_BIT(ASMBitFirstSet(&au32[0], sizeof(au32) * 8) == i, i);
268 for (j = 0; j < i; j++)
269 CHECK_BIT(ASMBitNextSet(&au32[0], sizeof(au32) * 8, j) == i, i);
270 for (j = i; j < 128; j++)
271 CHECK_BIT(ASMBitNextSet(&au32[0], sizeof(au32) * 8, j) == -1, i);
272 }
273
274
275 CHECK(ASMBitLastSetU32(0) == 0);
276 CHECK(ASMBitLastSetU32(1) == 1);
277 CHECK(ASMBitLastSetU32(0x80000000) == 32);
278 CHECK(ASMBitLastSetU32(0xffffffff) == 32);
279 CHECK(ASMBitLastSetU32(RT_BIT(23) | RT_BIT(11)) == 24);
280 for (i = 0; i < 32; i++)
281 CHECK(ASMBitLastSetU32(1 << i) == (unsigned)i + 1);
282
283 CHECK(ASMBitFirstSetU32(0) == 0);
284 CHECK(ASMBitFirstSetU32(1) == 1);
285 CHECK(ASMBitFirstSetU32(0x80000000) == 32);
286 CHECK(ASMBitFirstSetU32(0xffffffff) == 1);
287 CHECK(ASMBitFirstSetU32(RT_BIT(23) | RT_BIT(11)) == 12);
288 for (i = 0; i < 32; i++)
289 CHECK(ASMBitFirstSetU32(1 << i) == (unsigned)i + 1);
290
291 /*
292 * Summary
293 */
294 if (!rcRet)
295 RTPrintf("tstBitOperations: SUCCESS\n");
296 else
297 RTPrintf("tstBitOperations: FAILURE - %d errors\n", rcRet);
298 return rcRet;
299}
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