VirtualBox

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

Last change on this file since 3672 was 2981, checked in by vboxsync, 17 years ago

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