VirtualBox

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

Last change on this file since 101472 was 98103, checked in by vboxsync, 22 months ago

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