VirtualBox

source: vbox/trunk/src/VBox/Runtime/testcase/tstRTBitOperations.cpp@ 91472

Last change on this file since 91472 was 87229, checked in by vboxsync, 4 years ago

IPRT: Fixed bug in ASMBitFirstSet-generic.cpp and extended tstRTBitOperations.cpp. bugref:9898
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 22.2 KB
Line 
1/* $Id: tstRTBitOperations.cpp 87229 2021-01-12 16:11:02Z vboxsync $ */
2/** @file
3 * IPRT Testcase - Inlined Bit Operations.
4 */
5
6/*
7 * Copyright (C) 2006-2020 Oracle Corporation
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
27
28/*********************************************************************************************************************************
29* Header Files *
30*********************************************************************************************************************************/
31#include <iprt/asm.h>
32
33#include <iprt/initterm.h>
34#include <iprt/stream.h>
35#include <iprt/string.h>
36#include <iprt/test.h>
37
38
39/*
40 * Test 2 - ID allocation using a bitmap.
41 */
42
43#define NIL_TEST2_ID 0
44#define TEST2_ID_LAST ((RT_BIT_32(28) - 1) >> 8)
45
46struct TestMap2
47{
48 uint32_t idNil;
49 uint32_t idLast;
50 uint32_t idChunkPrev;
51 uint32_t bmChunkId[(TEST2_ID_LAST + 1 + 31) / 32];
52};
53
54static uint32_t test2AllocId(struct TestMap2 *p2)
55{
56 /*
57 * Scan sequentially from the last one + 1.
58 */
59 int32_t idChunk = ++p2->idChunkPrev;
60 if ( (uint32_t)idChunk < TEST2_ID_LAST
61 && idChunk > NIL_TEST2_ID)
62 {
63 idChunk = ASMBitNextClear(&p2->bmChunkId[0], TEST2_ID_LAST + 1, idChunk);
64 if (idChunk > NIL_TEST2_ID)
65 {
66 if (ASMAtomicBitTestAndSet(&p2->bmChunkId[0], idChunk))
67 {
68 RTTestFailed(NIL_RTTEST, "line %d: idChunk=%#x", __LINE__, idChunk);
69 return NIL_TEST2_ID;
70 }
71 return p2->idChunkPrev = idChunk;
72 }
73 }
74
75 /*
76 * Ok, scan from the start.
77 */
78 idChunk = ASMBitFirstClear(&p2->bmChunkId[0], TEST2_ID_LAST + 1);
79 if (idChunk <= NIL_TEST2_ID)
80 {
81 RTTestFailed(NIL_RTTEST, "line %d: idChunk=%#x", __LINE__, idChunk);
82 return NIL_TEST2_ID;
83 }
84 if (ASMAtomicBitTestAndSet(&p2->bmChunkId[0], idChunk))
85 {
86 RTTestFailed(NIL_RTTEST, "line %d: idChunk=%#x", __LINE__, idChunk);
87 return NIL_TEST2_ID;
88 }
89
90 return p2->idChunkPrev = idChunk;
91}
92
93
94static void test2(RTTEST hTest)
95{
96 struct TestMap2 *p2 = (struct TestMap2 *)RTTestGuardedAllocTail(hTest, sizeof(TestMap2));
97 p2->idNil = NIL_TEST2_ID;
98 p2->idLast = TEST2_ID_LAST;
99
100 /* Some simple tests first. */
101 RT_ZERO(p2->bmChunkId);
102 RTTEST_CHECK(hTest, ASMBitFirstSet(&p2->bmChunkId[0], TEST2_ID_LAST + 1) == -1);
103 for (uint32_t iBit = 0; iBit <= TEST2_ID_LAST; iBit++)
104 RTTEST_CHECK(hTest, !ASMBitTest(&p2->bmChunkId[0], iBit));
105
106 memset(&p2->bmChunkId[0], 0xff, sizeof(p2->bmChunkId));
107 RTTEST_CHECK(hTest, ASMBitFirstClear(&p2->bmChunkId[0], TEST2_ID_LAST + 1) == -1);
108 for (uint32_t iBit = 0; iBit <= TEST2_ID_LAST; iBit++)
109 RTTEST_CHECK(hTest, ASMBitTest(&p2->bmChunkId[0], iBit));
110
111 /* The real test. */
112 p2->idChunkPrev = 0;
113 RT_ZERO(p2->bmChunkId);
114 ASMBitSet(p2->bmChunkId, NIL_TEST2_ID);
115 uint32_t cLeft = TEST2_ID_LAST;
116 while (cLeft-- > 0)
117 test2AllocId(p2);
118
119 RTTEST_CHECK(hTest, ASMBitFirstClear(&p2->bmChunkId[0], TEST2_ID_LAST + 1) == -1);
120}
121
122
123int main()
124{
125 /*
126 * Init the runtime and stuff.
127 */
128 RTTEST hTest;
129 int rc = RTTestInitAndCreate("tstRTBitOperations", &hTest);
130 if (rc)
131 return rc;
132 RTTestBanner(hTest);
133
134 int i;
135 int j;
136 int k;
137
138 /*
139 * Tests
140 */
141 struct TestMap
142 {
143 uint32_t au32[4];
144 };
145#if 0
146 struct TestMap sTest;
147 struct TestMap *p = &sTest;
148#else
149 struct TestMap *p = (struct TestMap *)RTTestGuardedAllocTail(hTest, sizeof(*p));
150#endif
151#define DUMP() RTTestPrintf(hTest, RTTESTLVL_INFO, "au32={%08x,%08x,%08x,%08x}", p->au32[0], p->au32[1], p->au32[2], p->au32[3])
152#define CHECK(expr) do { if (!(expr)) { RTTestFailed(hTest, "line %d: %s", __LINE__, #expr); DUMP(); } CHECK_GUARD(s); } while (0)
153#define CHECK_BIT(expr, b1) do { if (!(expr)) { RTTestFailed(hTest, "line %d, b1=%d: %s", __LINE__, b1, #expr); } CHECK_GUARD(s); } while (0)
154#define CHECK_BIT2(expr, b1, b2) do { if (!(expr)) { RTTestFailed(hTest, "line %d, b1=%d b2=%d: %s", __LINE__, b1, b2, #expr); } CHECK_GUARD(s); } while (0)
155#define CHECK_BIT3(expr, b1, b2, b3) do { if (!(expr)) { RTTestFailed(hTest, "line %d, b1=%d b2=%d b3=%d: %s", __LINE__, b1, b2, b3, #expr); } CHECK_GUARD(s); } while (0)
156#define CHECK_VAL(a_RetType, a_Fmt, a_ValueExpr, a_Expect) \
157 do { a_RetType rcCheckRet = (a_ValueExpr); \
158 if (RT_LIKELY((rcCheckRet) == (a_Expect))) {} \
159 else RTTestFailed(hTest, "line %d: %s -> " a_Fmt ", expected " a_Fmt "", \
160 __LINE__, #a_ValueExpr, rcCheckRet, a_Expect); \
161 CHECK_GUARD(s); \
162 } while (0)
163
164#define GUARD_MAP(p) do { } while (0)
165#define CHECK_GUARD(p) do { } while (0)
166#define MAP_CLEAR(p) do { RT_ZERO(*(p)); GUARD_MAP(p); } while (0)
167#define MAP_SET(p) do { memset(p, 0xff, sizeof(*(p))); GUARD_MAP(p); } while (0)
168
169 /* self check. */
170 MAP_CLEAR(p);
171 CHECK_GUARD(p);
172
173 /*
174 * Check the primitives first:
175 */
176 CHECK_VAL(unsigned, "%u", ASMBitLastSetU32(0), 0);
177 CHECK(ASMBitLastSetU32(1) == 1);
178 CHECK(ASMBitLastSetU32(0x80000000) == 32);
179 CHECK(ASMBitLastSetU32(0xffffffff) == 32);
180 CHECK(ASMBitLastSetU32(RT_BIT(23) | RT_BIT(11)) == 24);
181 for (i = 0; i < 32; i++)
182 CHECK(ASMBitLastSetU32(1 << i) == (unsigned)i + 1);
183
184 CHECK(ASMBitFirstSetU32(0) == 0);
185 CHECK(ASMBitFirstSetU32(1) == 1);
186 CHECK(ASMBitFirstSetU32(0x80000000) == 32);
187 CHECK(ASMBitFirstSetU32(0xffffffff) == 1);
188 CHECK(ASMBitFirstSetU32(RT_BIT(23) | RT_BIT(11)) == 12);
189 for (i = 0; i < 32; i++)
190 CHECK(ASMBitFirstSetU32(1 << i) == (unsigned)i + 1);
191
192 CHECK(ASMBitLastSetU64(UINT64_C(0)) == 0);
193 CHECK(ASMBitLastSetU64(UINT64_C(1)) == 1);
194 CHECK(ASMBitLastSetU64(UINT64_C(0x80000000)) == 32);
195 CHECK(ASMBitLastSetU64(UINT64_C(0xffffffff)) == 32);
196 CHECK(ASMBitLastSetU64(RT_BIT_64(33) | RT_BIT_64(11)) == 34);
197 for (i = 0; i < 64; i++)
198 CHECK(ASMBitLastSetU64(UINT64_C(1) << i) == (unsigned)i + 1);
199
200 CHECK(ASMBitFirstSetU64(UINT64_C(0)) == 0);
201 CHECK(ASMBitFirstSetU64(UINT64_C(1)) == 1);
202 CHECK(ASMBitFirstSetU64(UINT64_C(0x80000000)) == 32);
203 CHECK(ASMBitFirstSetU64(UINT64_C(0x800000000000)) == 48);
204 CHECK(ASMBitFirstSetU64(UINT64_C(0x8000000000000000)) == 64);
205 CHECK(ASMBitFirstSetU64(UINT64_C(0xffffffff)) == 1);
206 CHECK(ASMBitFirstSetU64(UINT64_C(0xffffffffffffffff)) == 1);
207 CHECK(ASMBitFirstSetU64(RT_BIT_64(33) | RT_BIT_64(11)) == 12);
208 for (i = 0; i < 64; i++)
209 CHECK(ASMBitFirstSetU64(UINT64_C(1) << i) == (unsigned)i + 1);
210
211 CHECK_VAL(unsigned, "%u", ASMBitFirstSetU32(0), 0);
212 CHECK_VAL(unsigned, "%u", ASMBitFirstSetU32(UINT32_C(0x84210000)), 16+1);
213 CHECK_VAL(unsigned, "%u", ASMBitFirstSetU32(UINT32_C(0xffffffff)), 0+1);
214 CHECK_VAL(unsigned, "%u", ASMBitFirstSetU32(UINT32_C(0x80000000)), 31+1);
215
216 CHECK_VAL(unsigned, "%u", ASMBitFirstSetU64(0), 0);
217 CHECK_VAL(unsigned, "%u", ASMBitFirstSetU64(UINT64_C(0xffffeeee84210000)), 16+1);
218 CHECK_VAL(unsigned, "%u", ASMBitFirstSetU64(UINT64_C(0xffffeeee00000000)), 33+1);
219 CHECK_VAL(unsigned, "%u", ASMBitFirstSetU64(UINT64_C(0x8000000000000000)), 63+1);
220 CHECK_VAL(unsigned, "%u", ASMBitFirstSetU64(UINT64_C(0xffffffffffffffff)), 0+1);
221
222 CHECK_VAL(unsigned, "%u", ASMBitLastSetU32(0), 0);
223 CHECK_VAL(unsigned, "%u", ASMBitLastSetU32(UINT32_C(0xffffffff)), 31+1);
224 CHECK_VAL(unsigned, "%u", ASMBitLastSetU32(UINT32_C(0x00000001)), 0+1);
225 CHECK_VAL(unsigned, "%u", ASMBitLastSetU32(UINT32_C(0x0001ffff)), 16+1);
226 CHECK_VAL(unsigned, "%u", ASMBitLastSetU32(UINT32_C(0x01234567)), 24+1);
227
228 CHECK_VAL(unsigned, "%u", ASMBitLastSetU64(0), 0);
229 CHECK_VAL(unsigned, "%u", ASMBitLastSetU64(UINT64_C(0x0000807060504030)), 47+1);
230
231 CHECK_VAL(uint16_t, "%#x", ASMByteSwapU16(UINT16_C(0x1234)), UINT16_C(0x3412));
232
233 CHECK_VAL(uint32_t, "%#x", ASMByteSwapU32(UINT32_C(0x12345678)), UINT32_C(0x78563412));
234
235 CHECK_VAL(uint64_t, "%#llx", ASMByteSwapU64(UINT64_C(0x1122334455667788)), UINT64_C(0x8877665544332211));
236
237 CHECK_VAL(uint32_t, "%#x", ASMRotateLeftU32(UINT32_C(0x12345678), 4), UINT32_C(0x23456781));
238 CHECK_VAL(uint32_t, "%#x", ASMRotateLeftU32(UINT32_C(0x12345678), 16), UINT32_C(0x56781234));
239 CHECK_VAL(uint32_t, "%#x", ASMRotateLeftU32(UINT32_C(0x82868080), 29), UINT32_C(0x1050d010));
240 CHECK_VAL(uint32_t, "%#x", ASMRotateLeftU32(UINT32_C(0xfedcba89), 1), UINT32_C(0xfdb97513));
241
242 CHECK_VAL(uint32_t, "%#x", ASMRotateRightU32(UINT32_C(0x12345678), 4), UINT32_C(0x81234567));
243 CHECK_VAL(uint32_t, "%#x", ASMRotateRightU32(UINT32_C(0x12345678), 16), UINT32_C(0x56781234));
244 CHECK_VAL(uint32_t, "%#x", ASMRotateRightU32(UINT32_C(0x82868080), 29), UINT32_C(0x14340404));
245 CHECK_VAL(uint32_t, "%#x", ASMRotateRightU32(UINT32_C(0xfedcba89), 1), UINT32_C(0xff6e5d44));
246
247 CHECK_VAL(uint64_t, "%#llx", ASMRotateLeftU64(UINT64_C(0x123456789abcdef0), 4), UINT64_C(0x23456789abcdef01));
248 CHECK_VAL(uint64_t, "%#llx", ASMRotateLeftU64(UINT64_C(0x123456789abcdef0), 16), UINT64_C(0x56789abcdef01234));
249 CHECK_VAL(uint64_t, "%#llx", ASMRotateLeftU64(UINT64_C(0x123456789abcdef0), 32), UINT64_C(0x9abcdef012345678));
250 CHECK_VAL(uint64_t, "%#llx", ASMRotateLeftU64(UINT64_C(0x123456789abcdef0), 48), UINT64_C(0xdef0123456789abc));
251 CHECK_VAL(uint64_t, "%#llx", ASMRotateLeftU64(UINT64_C(0x123456789abcdef0), 56), UINT64_C(0xf0123456789abcde));
252 CHECK_VAL(uint64_t, "%#llx", ASMRotateLeftU64(UINT64_C(0x123456789abcdef0), 60), UINT64_C(0x0123456789abcdef));
253 CHECK_VAL(uint64_t, "%#llx", ASMRotateLeftU64(UINT64_C(0x8182838485868788), 63), UINT64_C(0x40c141c242c343c4));
254 CHECK_VAL(uint64_t, "%#llx", ASMRotateLeftU64(UINT64_C(0x8182838485868788), 1), UINT64_C(0x030507090b0d0f11));
255 CHECK_VAL(uint64_t, "%#llx", ASMRotateLeftU64(UINT64_C(0x8182838485868788), 29), UINT64_C(0x90b0d0f110305070));
256
257 CHECK_VAL(uint64_t, "%#llx", ASMRotateRightU64(UINT64_C(0x123456789abcdef0), 4), UINT64_C(0x0123456789abcdef));
258 CHECK_VAL(uint64_t, "%#llx", ASMRotateRightU64(UINT64_C(0x123456789abcdef0), 16), UINT64_C(0xdef0123456789abc));
259 CHECK_VAL(uint64_t, "%#llx", ASMRotateRightU64(UINT64_C(0x123456789abcdef0), 32), UINT64_C(0x9abcdef012345678));
260 CHECK_VAL(uint64_t, "%#llx", ASMRotateRightU64(UINT64_C(0x123456789abcdef0), 48), UINT64_C(0x56789abcdef01234));
261 CHECK_VAL(uint64_t, "%#llx", ASMRotateRightU64(UINT64_C(0x123456789abcdef0), 56), UINT64_C(0x3456789abcdef012));
262 CHECK_VAL(uint64_t, "%#llx", ASMRotateRightU64(UINT64_C(0x123456789abcdef0), 60), UINT64_C(0x23456789abcdef01));
263 CHECK_VAL(uint64_t, "%#llx", ASMRotateRightU64(UINT64_C(0x8182838485868788), 63), UINT64_C(0x030507090b0d0f11));
264 CHECK_VAL(uint64_t, "%#llx", ASMRotateRightU64(UINT64_C(0x8182838485868788), 1), UINT64_C(0x40c141c242c343c4));
265 CHECK_VAL(uint64_t, "%#llx", ASMRotateRightU64(UINT64_C(0x8182838485868788), 29), UINT64_C(0x2c343c440c141c24));
266
267
268 /*
269 * Variable sized bitmaps:
270 */
271
272 /* bit set */
273 MAP_CLEAR(p);
274 ASMBitSet(&p->au32[0], 0);
275 ASMBitSet(&p->au32[0], 31);
276 ASMBitSet(&p->au32[0], 65);
277 CHECK(p->au32[0] == 0x80000001U);
278 CHECK(p->au32[2] == 0x00000002U);
279 CHECK(ASMBitTestAndSet(&p->au32[0], 0) && p->au32[0] == 0x80000001U);
280 CHECK(!ASMBitTestAndSet(&p->au32[0], 16) && p->au32[0] == 0x80010001U);
281 CHECK(ASMBitTestAndSet(&p->au32[0], 16) && p->au32[0] == 0x80010001U);
282 CHECK(!ASMBitTestAndSet(&p->au32[0], 80) && p->au32[2] == 0x00010002U);
283
284 MAP_CLEAR(p);
285 ASMAtomicBitSet(&p->au32[0], 0);
286 ASMAtomicBitSet(&p->au32[0], 30);
287 ASMAtomicBitSet(&p->au32[0], 64);
288 CHECK(p->au32[0] == 0x40000001U);
289 CHECK(p->au32[2] == 0x00000001U);
290 CHECK(ASMAtomicBitTestAndSet(&p->au32[0], 0) && p->au32[0] == 0x40000001U);
291 CHECK(!ASMAtomicBitTestAndSet(&p->au32[0], 16) && p->au32[0] == 0x40010001U);
292 CHECK(ASMAtomicBitTestAndSet(&p->au32[0], 16) && p->au32[0] == 0x40010001U);
293 CHECK(!ASMAtomicBitTestAndSet(&p->au32[0], 80) && p->au32[2] == 0x00010001U);
294
295 /* bit clear */
296 MAP_SET(p);
297 ASMBitClear(&p->au32[0], 0);
298 ASMBitClear(&p->au32[0], 31);
299 ASMBitClear(&p->au32[0], 65);
300 CHECK(p->au32[0] == ~0x80000001U);
301 CHECK(p->au32[2] == ~0x00000002U);
302 CHECK(!ASMBitTestAndClear(&p->au32[0], 0) && p->au32[0] == ~0x80000001U);
303 CHECK(ASMBitTestAndClear(&p->au32[0], 16) && p->au32[0] == ~0x80010001U);
304 CHECK(!ASMBitTestAndClear(&p->au32[0], 16) && p->au32[0] == ~0x80010001U);
305 CHECK(ASMBitTestAndClear(&p->au32[0], 80) && p->au32[2] == ~0x00010002U);
306
307 MAP_SET(p);
308 ASMAtomicBitClear(&p->au32[0], 0);
309 ASMAtomicBitClear(&p->au32[0], 30);
310 ASMAtomicBitClear(&p->au32[0], 64);
311 CHECK(p->au32[0] == ~0x40000001U);
312 CHECK(p->au32[2] == ~0x00000001U);
313 CHECK(!ASMAtomicBitTestAndClear(&p->au32[0], 0) && p->au32[0] == ~0x40000001U);
314 CHECK(ASMAtomicBitTestAndClear(&p->au32[0], 16) && p->au32[0] == ~0x40010001U);
315 CHECK(!ASMAtomicBitTestAndClear(&p->au32[0], 16) && p->au32[0] == ~0x40010001U);
316 CHECK(ASMAtomicBitTestAndClear(&p->au32[0], 80) && p->au32[2] == ~0x00010001U);
317
318 /* toggle */
319 MAP_SET(p);
320 ASMBitToggle(&p->au32[0], 0);
321 ASMBitToggle(&p->au32[0], 31);
322 ASMBitToggle(&p->au32[0], 65);
323 ASMBitToggle(&p->au32[0], 47);
324 ASMBitToggle(&p->au32[0], 47);
325 CHECK(p->au32[0] == ~0x80000001U);
326 CHECK(p->au32[2] == ~0x00000002U);
327 CHECK(!ASMBitTestAndToggle(&p->au32[0], 0) && p->au32[0] == ~0x80000000U);
328 CHECK(ASMBitTestAndToggle(&p->au32[0], 0) && p->au32[0] == ~0x80000001U);
329 CHECK(ASMBitTestAndToggle(&p->au32[0], 16) && p->au32[0] == ~0x80010001U);
330 CHECK(!ASMBitTestAndToggle(&p->au32[0], 16) && p->au32[0] == ~0x80000001U);
331 CHECK(ASMBitTestAndToggle(&p->au32[0], 80) && p->au32[2] == ~0x00010002U);
332
333 MAP_SET(p);
334 ASMAtomicBitToggle(&p->au32[0], 0);
335 ASMAtomicBitToggle(&p->au32[0], 30);
336 ASMAtomicBitToggle(&p->au32[0], 64);
337 ASMAtomicBitToggle(&p->au32[0], 47);
338 ASMAtomicBitToggle(&p->au32[0], 47);
339 CHECK(p->au32[0] == ~0x40000001U);
340 CHECK(p->au32[2] == ~0x00000001U);
341 CHECK(!ASMAtomicBitTestAndToggle(&p->au32[0], 0) && p->au32[0] == ~0x40000000U);
342 CHECK(ASMAtomicBitTestAndToggle(&p->au32[0], 0) && p->au32[0] == ~0x40000001U);
343 CHECK(ASMAtomicBitTestAndToggle(&p->au32[0], 16) && p->au32[0] == ~0x40010001U);
344 CHECK(!ASMAtomicBitTestAndToggle(&p->au32[0], 16) && p->au32[0] == ~0x40000001U);
345 CHECK(ASMAtomicBitTestAndToggle(&p->au32[0], 80) && p->au32[2] == ~0x00010001U);
346
347 /* test bit. */
348 for (i = 0; i < 128; i++)
349 {
350 MAP_SET(p);
351 CHECK_BIT(ASMBitTest(&p->au32[0], i), i);
352 ASMBitToggle(&p->au32[0], i);
353 CHECK_BIT(!ASMBitTest(&p->au32[0], i), i);
354 CHECK_BIT(!ASMBitTestAndToggle(&p->au32[0], i), i);
355 CHECK_BIT(ASMBitTest(&p->au32[0], i), i);
356 CHECK_BIT(ASMBitTestAndToggle(&p->au32[0], i), i);
357 CHECK_BIT(!ASMBitTest(&p->au32[0], i), i);
358
359 MAP_SET(p);
360 CHECK_BIT(ASMBitTest(&p->au32[0], i), i);
361 ASMAtomicBitToggle(&p->au32[0], i);
362 CHECK_BIT(!ASMBitTest(&p->au32[0], i), i);
363 CHECK_BIT(!ASMAtomicBitTestAndToggle(&p->au32[0], i), i);
364 CHECK_BIT(ASMBitTest(&p->au32[0], i), i);
365 CHECK_BIT(ASMAtomicBitTestAndToggle(&p->au32[0], i), i);
366 CHECK_BIT(!ASMBitTest(&p->au32[0], i), i);
367 }
368
369 /* bit searching */
370 MAP_SET(p);
371 CHECK_VAL(int32_t, "%d", ASMBitFirstClear(&p->au32[0], sizeof(p->au32) * 8), -1);
372 CHECK_VAL(int32_t, "%d", ASMBitFirstSet(&p->au32[0], sizeof(p->au32) * 8), 0);
373
374 ASMBitClear(&p->au32[0], 1);
375 CHECK_VAL(int32_t, "%d", ASMBitFirstClear(&p->au32[0], sizeof(p->au32) * 8), 1);
376 CHECK_VAL(int32_t, "%d", ASMBitFirstSet(&p->au32[0], sizeof(p->au32) * 8), 0);
377
378 MAP_SET(p);
379 ASMBitClear(&p->au32[0], 95);
380 CHECK_VAL(int32_t, "%d", ASMBitFirstClear(&p->au32[0], sizeof(p->au32) * 8), 95);
381 CHECK_VAL(int32_t, "%d", ASMBitFirstSet(&p->au32[0], sizeof(p->au32) * 8), 0);
382
383 MAP_SET(p);
384 ASMBitClear(&p->au32[0], 127);
385 CHECK(ASMBitFirstClear(&p->au32[0], sizeof(p->au32) * 8) == 127);
386 CHECK(ASMBitFirstSet(&p->au32[0], sizeof(p->au32) * 8) == 0);
387 CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, 0) == 1);
388 CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, 1) == 2);
389 CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, 2) == 3);
390
391
392 MAP_SET(p);
393 CHECK(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8, 0) == -1);
394 ASMBitClear(&p->au32[0], 32);
395 CHECK(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8, 32) == -1);
396 ASMBitClear(&p->au32[0], 88);
397 CHECK(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8, 57) == 88);
398
399 MAP_SET(p);
400 ASMBitClear(&p->au32[0], 31);
401 ASMBitClear(&p->au32[0], 57);
402 ASMBitClear(&p->au32[0], 88);
403 ASMBitClear(&p->au32[0], 101);
404 ASMBitClear(&p->au32[0], 126);
405 ASMBitClear(&p->au32[0], 127);
406 CHECK(ASMBitFirstClear(&p->au32[0], sizeof(p->au32) * 8) == 31);
407 CHECK(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8, 31) == 57);
408 CHECK(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8, 57) == 88);
409 CHECK(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8, 88) == 101);
410 CHECK(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8, 101) == 126);
411 CHECK(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8, 126) == 127);
412 CHECK(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8, 127) == -1);
413
414 CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, 29) == 30);
415 CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, 30) == 32);
416
417 MAP_CLEAR(p);
418 for (i = 1; i < 128; i++)
419 CHECK_BIT(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8, i - 1) == i, i);
420 for (i = 0; i < 128; i++)
421 {
422 MAP_SET(p);
423 ASMBitClear(&p->au32[0], i);
424 CHECK_BIT(ASMBitFirstClear(&p->au32[0], sizeof(p->au32) * 8) == i, i);
425 for (j = 0; j < i; j++)
426 CHECK_BIT(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8, j) == i, i);
427 for (j = i; j < 128; j++)
428 CHECK_BIT(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8, j) == -1, i);
429 }
430
431 /* clear range. */
432 MAP_SET(p);
433 ASMBitClearRange(&p->au32, 0, 128);
434 CHECK(!p->au32[0] && !p->au32[1] && !p->au32[2] && !p->au32[3]);
435 for (i = 0; i < 128; i++)
436 {
437 for (j = i + 1; j <= 128; j++)
438 {
439 MAP_SET(p);
440 ASMBitClearRange(&p->au32, i, j);
441 for (k = 0; k < i; k++)
442 CHECK_BIT3(ASMBitTest(&p->au32[0], k), i, j, k);
443 for (k = i; k < j; k++)
444 CHECK_BIT3(!ASMBitTest(&p->au32[0], k), i, j, k);
445 for (k = j; k < 128; k++)
446 CHECK_BIT3(ASMBitTest(&p->au32[0], k), i, j, k);
447 }
448 }
449
450 /* set range. */
451 MAP_CLEAR(p);
452 ASMBitSetRange(&p->au32[0], 0, 5);
453 ASMBitSetRange(&p->au32[0], 6, 44);
454 ASMBitSetRange(&p->au32[0], 64, 65);
455 CHECK(p->au32[0] == UINT32_C(0xFFFFFFDF));
456 CHECK(p->au32[1] == UINT32_C(0x00000FFF));
457 CHECK(p->au32[2] == UINT32_C(0x00000001));
458
459 MAP_CLEAR(p);
460 ASMBitSetRange(&p->au32[0], 0, 1);
461 ASMBitSetRange(&p->au32[0], 62, 63);
462 ASMBitSetRange(&p->au32[0], 63, 64);
463 ASMBitSetRange(&p->au32[0], 127, 128);
464 CHECK(p->au32[0] == UINT32_C(0x00000001) && p->au32[1] == UINT32_C(0xC0000000));
465 CHECK(p->au32[2] == UINT32_C(0x00000000) && p->au32[3] == UINT32_C(0x80000000));
466
467 MAP_CLEAR(p);
468 ASMBitSetRange(&p->au32, 0, 128);
469 CHECK(!~p->au32[0] && !~p->au32[1] && !~p->au32[2] && !~p->au32[3]);
470 for (i = 0; i < 128; i++)
471 {
472 for (j = i + 1; j <= 128; j++)
473 {
474 MAP_CLEAR(p);
475 ASMBitSetRange(&p->au32, i, j);
476 for (k = 0; k < i; k++)
477 CHECK_BIT3(!ASMBitTest(&p->au32[0], k), i, j, k);
478 for (k = i; k < j; k++)
479 CHECK_BIT3(ASMBitTest(&p->au32[0], k), i, j, k);
480 for (k = j; k < 128; k++)
481 CHECK_BIT3(!ASMBitTest(&p->au32[0], k), i, j, k);
482 }
483 }
484
485 /* searching for set bits. */
486 MAP_CLEAR(p);
487 CHECK(ASMBitFirstSet(&p->au32[0], sizeof(p->au32) * 8) == -1);
488
489 ASMBitSet(&p->au32[0], 65);
490 CHECK(ASMBitFirstSet(&p->au32[0], sizeof(p->au32) * 8) == 65);
491 CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, 65) == -1);
492 for (i = 0; i < 65; i++)
493 CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, i) == 65);
494 for (i = 65; i < 128; i++)
495 CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, i) == -1);
496
497 ASMBitSet(&p->au32[0], 17);
498 CHECK(ASMBitFirstSet(&p->au32[0], sizeof(p->au32) * 8) == 17);
499 CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, 17) == 65);
500 for (i = 0; i < 16; i++)
501 CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, i) == 17);
502 for (i = 17; i < 65; i++)
503 CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, i) == 65);
504
505 MAP_SET(p);
506 for (i = 1; i < 128; i++)
507 CHECK_BIT(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, i - 1) == i, i);
508 for (i = 0; i < 128; i++)
509 {
510 MAP_CLEAR(p);
511 ASMBitSet(&p->au32[0], i);
512 CHECK_BIT(ASMBitFirstSet(&p->au32[0], sizeof(p->au32) * 8) == i, i);
513 for (j = 0; j < i; j++)
514 CHECK_BIT(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, j) == i, i);
515 for (j = i; j < 128; j++)
516 CHECK_BIT(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, j) == -1, i);
517 }
518
519 /*
520 * Special tests.
521 */
522 test2(hTest);
523
524 /*
525 * Summary
526 */
527 return RTTestSummaryAndDestroy(hTest);
528}
529
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