Mercurial > hgrepos > Python2 > PyMuPDF

comparison mupdf-source/thirdparty/zint/backend/tests/test_large.c @ 2:b50eed0cc0ef upstream

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
ADD: MuPDF v1.26.7: the MuPDF source as downloaded by a default build of PyMuPDF 1.26.4. The directory name has changed: no version number in the expanded directory now.
author Franz Glasner <fzglas.hg@dom66.de>
date Mon, 15 Sep 2025 11:43:07 +0200
parents
children
comparison
equal deleted inserted replaced
1:1d09e1dec1d9 2:b50eed0cc0ef
1 /*
2 libzint - the open source barcode library
3 Copyright (C) 2020-2024 Robin Stuart <rstuart114@gmail.com>
4
5 Redistribution and use in source and binary forms, with or without
6 modification, are permitted provided that the following conditions
7 are met:
8
9 1. Redistributions of source code must retain the above copyright
10 notice, this list of conditions and the following disclaimer.
11 2. Redistributions in binary form must reproduce the above copyright
12 notice, this list of conditions and the following disclaimer in the
13 documentation and/or other materials provided with the distribution.
14 3. Neither the name of the project nor the names of its contributors
15 may be used to endorse or promote products derived from this software
16 without specific prior written permission.
17
18 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
19 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
22 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24 OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 SUCH DAMAGE.
29 */
30 /* SPDX-License-Identifier: BSD-3-Clause */
31
32 #include <limits.h>
33
34 #include "testcommon.h"
35 #include "../large.h"
36
37 #if defined(__MINGW32__)
38 # if __WORDSIZE == 32
39 # define LX_FMT "I32"
40 # else
41 # define LX_FMT "I64"
42 # endif
43 # if defined(__clang__)
44 # pragma GCC diagnostic ignored "-Wformat-non-iso"
45 # elif defined(__GNUC__) && (__GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
46 # pragma GCC diagnostic ignored "-Wno-pedantic-ms-format"
47 # elif defined(__GNUC__) && __GNUC__ >= 2
48 # pragma GCC diagnostic ignored "-Wformat"
49 # endif
50 #elif (defined(__WORDSIZE) && __WORDSIZE == 32) || (defined(ULONG_MAX) && ULONG_MAX <= 0xFFFFFFFF) \
51 || defined(__APPLE__) || defined(__OpenBSD__)
52 # define LX_FMT "ll"
53 #else
54 # define LX_FMT "l"
55 #endif
56
57 #define LI(l, h) { l, h }
58
59 INTERNAL int clz_u64_test(uint64_t x);
60
61 static void test_clz_u64(const testCtx *const p_ctx) {
62
63 struct item {
64 uint64_t s;
65 int ret;
66 };
67 /* s/\/\*[ 0-9]*\*\//\=printf("\/\*%3d*\/", line(".") - line("'<")): */
68 struct item data[] = {
69 /* 0*/ { 0x0, 64 },
70 /* 1*/ { 0x1, 63 },
71 /* 2*/ { 0x2, 62 },
72 /* 3*/ { 0x3, 62 },
73 /* 4*/ { 0x4, 61 },
74 /* 5*/ { 0x5, 61 },
75 /* 6*/ { 0x6, 61 },
76 /* 7*/ { 0x7, 61 },
77 /* 8*/ { 0x8, 60 },
78 /* 9*/ { 0x9, 60 },
79 /* 10*/ { 0xA, 60 },
80 /* 11*/ { 0xB, 60 },
81 /* 12*/ { 0xC, 60 },
82 /* 13*/ { 0xD, 60 },
83 /* 14*/ { 0xE, 60 },
84 /* 15*/ { 0xF, 60 },
85 /* 16*/ { 0x10, 59 },
86 /* 17*/ { 0x11, 59 },
87 /* 18*/ { 0x12, 59 },
88 /* 19*/ { 0x13, 59 },
89 /* 20*/ { 0x14, 59 },
90 /* 21*/ { 0x15, 59 },
91 /* 22*/ { 0x16, 59 },
92 /* 23*/ { 0x17, 59 },
93 /* 24*/ { 0x18, 59 },
94 /* 25*/ { 0x19, 59 },
95 /* 26*/ { 0x1A, 59 },
96 /* 27*/ { 0x1B, 59 },
97 /* 28*/ { 0x1C, 59 },
98 /* 29*/ { 0x1D, 59 },
99 /* 30*/ { 0x1E, 59 },
100 /* 31*/ { 0x1F, 59 },
101 /* 32*/ { 0x20, 58 },
102 /* 33*/ { 0x21, 58 },
103 /* 34*/ { 0x22, 58 },
104 /* 35*/ { 0x23, 58 },
105 /* 36*/ { 0x2F, 58 },
106 /* 37*/ { 0x40, 57 },
107 /* 38*/ { 0x49, 57 },
108 /* 39*/ { 0x50, 57 },
109 /* 40*/ { 0x5F, 57 },
110 /* 41*/ { 0x60, 57 },
111 /* 42*/ { 0x7F, 57 },
112 /* 43*/ { 0x80, 56 },
113 /* 44*/ { 0x88, 56 },
114 /* 45*/ { 0xA1, 56 },
115 /* 46*/ { 0xFF, 56 },
116 /* 47*/ { 0x100, 55 },
117 /* 48*/ { 0x165, 55 },
118 /* 49*/ { 0x1FF, 55 },
119 /* 50*/ { 0x384, 54 },
120 /* 51*/ { 0x555, 53 },
121 /* 52*/ { 0xBCD, 52 },
122 /* 53*/ { 0x1FFF, 51 },
123 /* 54*/ { 0x2E06, 50 },
124 /* 55*/ { 0x7040, 49 },
125 /* 56*/ { 0x8001, 48 },
126 /* 57*/ { 0xC0FF, 48 },
127 /* 58*/ { 0x1C0FF, 47 },
128 /* 59*/ { 0x2211E, 46 },
129 /* 60*/ { 0x44220, 45 },
130 /* 61*/ { 0x50505, 45 },
131 /* 62*/ { 0x88888, 44 },
132 /* 63*/ { 0x111111, 43 },
133 /* 64*/ { 0x222222, 42 },
134 /* 65*/ { 0x444444, 41 },
135 /* 66*/ { 0xFF00FF, 40 },
136 /* 67*/ { 0x10B8392, 39 },
137 /* 68*/ { 0x2FFFFFF, 38 },
138 /* 69*/ { 0x4040404, 37 },
139 /* 70*/ { 0x7777777, 37 },
140 /* 71*/ { 0xF0F0F0F, 36 },
141 /* 72*/ { 0x194F0311, 35 },
142 /* 73*/ { 0x33333333, 34 },
143 /* 74*/ { 0x55555555, 33 },
144 /* 75*/ { 0xAAAAAAAA, 32 },
145 /* 76*/ { 0x100000000, 31 },
146 /* 77*/ { 0x2FFFFFFFF, 30 },
147 /* 78*/ { 0x304050607, 30 },
148 /* 79*/ { 0x707070707, 29 },
149 /* 80*/ { 0x999999999, 28 },
150 /* 81*/ { 0xEEEEEEEEE, 28 },
151 /* 82*/ { 0x1000000001, 27 },
152 /* 83*/ { 0x2D2D2D2D2D, 26 },
153 /* 84*/ { 0x68034DAE71, 25 },
154 /* 85*/ { 0xF462103784, 24 },
155 /* 86*/ { 0x1CCCCCCCCCC, 23 },
156 /* 87*/ { 0x2F462103784, 22 },
157 /* 88*/ { 0x4F4E4D4C4B4, 21 },
158 /* 89*/ { 0x9FFFFFFFFFF, 20 },
159 /* 90*/ { 0x100000000000, 19 },
160 /* 91*/ { 0x369D03178212, 18 },
161 /* 92*/ { 0x666000666000, 17 },
162 /* 93*/ { 0xFFFFFFFFFFFF, 16 },
163 /* 94*/ { 0x123456789ABCD, 15 },
164 /* 95*/ { 0x3FFFFFFFFFFFF, 14 },
165 /* 96*/ { 0x429C8174831A0, 13 },
166 /* 97*/ { 0xBBBBBBBBBBBBB, 12 },
167 /* 98*/ { 0x11111111111111, 11 },
168 /* 99*/ { 0x24242424242424, 10 },
169 /*100*/ { 0x44444444444444, 9 },
170 /*101*/ { 0x567890ABCDEF01, 9 },
171 /*102*/ { 0xFFFFFFFFFFFFFF, 8 },
172 /*103*/ { 0x100000000000100, 7 },
173 /*104*/ { 0x37F037F047F037F, 6 },
174 /*105*/ { 0x60123456789ABCD, 5 },
175 /*106*/ { 0xDDDDDDDDDDDDDDD, 4 },
176 /*107*/ { 0xFEDCBA987654321, 4 },
177 /*108*/ { 0xFFFFFFFFFFFFFFF, 4 },
178 /*109*/ { 0x1000000000000000, 3 },
179 /*110*/ { 0x1000000000000001, 3 },
180 /*111*/ { 0x2000000000010000, 2 },
181 /*112*/ { 0x3100000000000000, 2 },
182 /*113*/ { 0x4001000000000000, 1 },
183 /*114*/ { 0x5000000100000000, 1 },
184 /*115*/ { 0x6000001000000000, 1 },
185 /*116*/ { 0x7000000001000000, 1 },
186 /*117*/ { 0x8000100000000000, 0 },
187 /*118*/ { 0x9000000000001000, 0 },
188 /*119*/ { 0xA000000000000010, 0 },
189 /*120*/ { 0xB000000000000000, 0 },
190 /*121*/ { 0xC010000000000000, 0 },
191 /*122*/ { 0xD000010000000000, 0 },
192 /*123*/ { 0xE111111111111111, 0 },
193 /*124*/ { 0xF000000000000000, 0 },
194 /*125*/ { 0xFFFFFFFFFFFFFFFF, 0 },
195 };
196 int data_size = ARRAY_SIZE(data);
197 int i, ret;
198
199 testStart("test_clz_u64");
200
201 for (i = 0; i < data_size; i++) {
202
203 if (testContinue(p_ctx, i)) continue;
204
205 ret = clz_u64_test(data[i].s);
206 assert_equal(ret, data[i].ret, "i:%d 0x%" LX_FMT "X ret %d != %d\n", i, data[i].s, ret, data[i].ret);
207 }
208
209 testFinish();
210 }
211
212 static void test_load(const testCtx *const p_ctx) {
213
214 struct item {
215 large_uint t;
216 large_uint s;
217 large_uint expected;
218 };
219 /* s/\/\*[ 0-9]*\*\//\=printf("\/\*%3d*\/", line(".") - line("'<")): */
220 struct item data[] = {
221 /* 0*/ { LI(0, 0), LI(0, 0), LI(0, 0) },
222 /* 1*/ { LI(1, 1), LI(0, 0), LI(0, 0) },
223 /* 2*/ { LI(0, 0), LI(1, 2), LI(1, 2) },
224 /* 3*/ { LI(1, 1), LI(2, 3), LI(2, 3) },
225 };
226 int data_size = ARRAY_SIZE(data);
227 int i;
228
229 char t_dump[35];
230 char expected_dump[35];
231
232 testStart("test_load");
233
234 for (i = 0; i < data_size; i++) {
235
236 if (testContinue(p_ctx, i)) continue;
237
238 large_load(&data[i].t, &data[i].s);
239
240 assert_equalu64(data[i].t.lo, data[i].expected.lo, "i:%d lo 0x%" LX_FMT "X (%s) != expected lo 0x%" LX_FMT "X (%s)\n",
241 i, data[i].t.lo, large_dump(&data[i].t, t_dump), data[i].expected.lo, large_dump(&data[i].expected, expected_dump));
242 assert_equalu64(data[i].t.hi, data[i].expected.hi, "i:%d hi 0x%" LX_FMT "X (%s) != expected hi 0x%" LX_FMT "X (%s)\n",
243 i, data[i].t.hi, large_dump(&data[i].t, t_dump), data[i].expected.hi, large_dump(&data[i].expected, expected_dump));
244 }
245
246 testFinish();
247 }
248
249 static void test_load_str_u64(const testCtx *const p_ctx) {
250
251 struct item {
252 large_uint t;
253 const char *s;
254 int length;
255 large_uint expected;
256 };
257 /* s/\/\*[ 0-9]*\*\//\=printf("\/\*%3d*\/", line(".") - line("'<")): */
258 struct item data[] = {
259 /* 0*/ { LI(0, 0), "0", -1, LI(0, 0) },
260 /* 1*/ { LI(0, 1), "1", -1, LI(1, 0) },
261 /* 2*/ { LI(1, 1), "4294967296", -1, LI(4294967296, 0) },
262 /* 3*/ { LI(1, 1), "18446744073709551615", -1, LI(0xFFFFFFFFFFFFFFFF, 0) },
263 /* 4*/ { LI(1, 1), "18446744073709551616", -1, LI(0, 0) }, /* Overflow 18446744073709551616 == 2^64 == 0 */
264 /* 5*/ { LI(2, 2), "123", 2, LI(12, 0) }, /* Only reads up to length */
265 /* 6*/ { LI(2, 2), "123A1X", -1, LI(123, 0) }, /* Only reads decimal */
266 };
267 int data_size = ARRAY_SIZE(data);
268 int i;
269
270 char t_dump[35];
271 char expected_dump[35];
272
273 testStart("test_load_str_u64");
274
275 for (i = 0; i < data_size; i++) {
276
277 if (testContinue(p_ctx, i)) continue;
278
279 large_load_str_u64(&data[i].t, (unsigned char *) data[i].s, data[i].length == -1 ? (int) strlen(data[i].s) : data[i].length);
280
281 assert_equalu64(data[i].t.lo, data[i].expected.lo, "i:%d lo 0x%" LX_FMT "X (%s) != expected lo 0x%" LX_FMT "X (%s)\n",
282 i, data[i].t.lo, large_dump(&data[i].t, t_dump), data[i].expected.lo, large_dump(&data[i].expected, expected_dump));
283 assert_equalu64(data[i].t.hi, data[i].expected.hi, "i:%d hi 0x%" LX_FMT "X (%s) != expected hi 0x%" LX_FMT "X (%s)\n",
284 i, data[i].t.hi, large_dump(&data[i].t, t_dump), data[i].expected.hi, large_dump(&data[i].expected, expected_dump));
285 }
286
287 testFinish();
288 }
289
290 static void test_add_u64(const testCtx *const p_ctx) {
291
292 struct item {
293 large_uint t;
294 uint64_t s;
295 large_uint expected;
296 };
297 /* s/\/\*[ 0-9]*\*\//\=printf("\/\*%3d*\/", line(".") - line("'<")): */
298 struct item data[] = {
299 /* 0*/ { LI(0, 0), 0, LI(0, 0) },
300 /* 1*/ { LI(1, 0), 0, LI(1, 0) },
301 /* 2*/ { LI(0, 1), 0, LI(0, 1) },
302 /* 3*/ { LI(1, 0), 1, LI(2, 0) },
303 /* 4*/ { LI(1, 1), 0xFFFFFFFFFFFFFFFF, LI(0, 2) },
304 /* 5*/ { LI(1, 1), 2, LI(3, 1) },
305 /* 6*/ { LI(0xFFFFFFFFFFFFFFFF, 1), 1, LI(0, 2) },
306 /* 7*/ { LI(0xFFFFFFFFFFFFFFFE, 100), 4, LI(2, 101) },
307 /* 8*/ { LI(0xFFFFFFFFFFFFFF0E, 0xFFFFFE), 0xFF, LI(0xD, 0xFFFFFF) },
308 /* 9*/ { LI(0xFFFFFFFF00000001, 0xFFFFFFFF), 0xFFFFFFFF, LI(0, 0x100000000) },
309 /* 10*/ { LI(0x0000000000000001, 0xFFFFFFFFFFFFFFFF), 0xFFFFFFFFFFFFFFFF, LI(0, 0) }, /* Overflow */
310 };
311 int data_size = ARRAY_SIZE(data);
312 int i;
313
314 char t_dump[35];
315 char expected_dump[35];
316
317 testStart("test_add_u64");
318
319 for (i = 0; i < data_size; i++) {
320
321 if (testContinue(p_ctx, i)) continue;
322
323 large_add_u64(&data[i].t, data[i].s);
324
325 assert_equalu64(data[i].t.lo, data[i].expected.lo, "i:%d lo 0x%" LX_FMT "X (%s) != expected lo 0x%" LX_FMT "X (%s)\n",
326 i, data[i].t.lo, large_dump(&data[i].t, t_dump), data[i].expected.lo, large_dump(&data[i].expected, expected_dump));
327 assert_equalu64(data[i].t.hi, data[i].expected.hi, "i:%d hi 0x%" LX_FMT "X (%s) != expected hi 0x%" LX_FMT "X (%s)\n",
328 i, data[i].t.hi, large_dump(&data[i].t, t_dump), data[i].expected.hi, large_dump(&data[i].expected, expected_dump));
329 }
330
331 testFinish();
332 }
333
334 static void test_sub_u64(const testCtx *const p_ctx) {
335
336 struct item {
337 large_uint t;
338 uint64_t s;
339 large_uint expected;
340 };
341 /* s/\/\*[ 0-9]*\*\//\=printf("\/\*%3d*\/", line(".") - line("'<")): */
342 struct item data[] = {
343 /* 0*/ { LI(0, 0), 0, LI(0, 0) },
344 /* 1*/ { LI(1, 0), 0, LI(1, 0) },
345 /* 2*/ { LI(0, 1), 0, LI(0, 1) },
346 /* 3*/ { LI(1, 0), 1, LI(0, 0) },
347 /* 4*/ { LI(0xFFFFFFFFFFFFFFFF, 1), 0xFFFFFFFFFFFFFFFF, LI(0, 1) },
348 /* 5*/ { LI(0xFFFFFFFFFFFFFFFE, 1), 0xFFFFFFFFFFFFFFFF, LI(0xFFFFFFFFFFFFFFFF, 0) },
349 /* 6*/ { LI(1, 1), 0xFFFFFFFFFFFFFFFF, LI(2, 0) },
350 /* 7*/ { LI(1, 1), 0xFFFFFFFFFFFFFFFE, LI(3, 0) },
351 /* 8*/ { LI(2, 0xFFFFFFFFFFFFFFFF), 0xFFFFFFFFFFFFFFFF, LI(3, 0xFFFFFFFFFFFFFFFE) },
352 /* 9*/ { LI(2, 0xFFFFFFFFFFFFFFFF), 0xFFFFFFFFFFFFFFFE, LI(4, 0xFFFFFFFFFFFFFFFE) },
353 /* 10*/ { LI(0, 0), 1, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
354 };
355 int data_size = ARRAY_SIZE(data);
356 int i;
357
358 char t_dump[35];
359 char expected_dump[35];
360
361 testStart("test_sub_u64");
362
363 for (i = 0; i < data_size; i++) {
364
365 if (testContinue(p_ctx, i)) continue;
366
367 large_sub_u64(&data[i].t, data[i].s);
368
369 assert_equalu64(data[i].t.lo, data[i].expected.lo, "i:%d lo 0x%" LX_FMT "X (%s) != expected lo 0x%" LX_FMT "X (%s)\n",
370 i, data[i].t.lo, large_dump(&data[i].t, t_dump), data[i].expected.lo, large_dump(&data[i].expected, expected_dump));
371 assert_equalu64(data[i].t.hi, data[i].expected.hi, "i:%d hi 0x%" LX_FMT "X (%s) != expected hi 0x%" LX_FMT "X (%s)\n",
372 i, data[i].t.hi, large_dump(&data[i].t, t_dump), data[i].expected.hi, large_dump(&data[i].expected, expected_dump));
373 }
374
375 testFinish();
376 }
377
378 static void test_mul_u64(const testCtx *const p_ctx) {
379
380 struct item {
381 large_uint t;
382 uint64_t s;
383 large_uint expected;
384 };
385 /* s/\/\*[ 0-9]*\*\//\=printf("\/\*%3d*\/", line(".") - line("'<")): */
386 struct item data[] = {
387 /* 0*/ { LI(0, 0), 0, LI(0, 0) },
388 /* 1*/ { LI(1, 0), 0, LI(0, 0) },
389 /* 2*/ { LI(0, 1), 0, LI(0, 0) },
390 /* 3*/ { LI(1, 0), 1, LI(1, 0) },
391 /* 4*/ { LI(0, 1), 1, LI(0, 1) },
392 /* 5*/ { LI(1, 1), 2, LI(2, 2) },
393 /* 6*/ { LI(3, 0x64), 3, LI(9, 0x12C) },
394 /* 7*/ { LI(0x5555555555555555, 0x5555555555555555), 3, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
395 /* 8*/ { LI(432, 518), 4, LI(1728, 2072) },
396 /* 9*/ { LI(0x4000000000000000, 0), 4, LI(0, 1) },
397 /* 10*/ { LI(0xFFFFFFFFFFFFFFFF, 0x3FFFFFFFFFFFFFFF), 4, LI(0xFFFFFFFFFFFFFFFC, 0xFFFFFFFFFFFFFFFF) },
398 /* 11*/ { LI(0x3333333333333333, 0x111), 5, LI(0xFFFFFFFFFFFFFFFF, 0x555) },
399 /* 12*/ { LI(0x3333333333333334, 0x111), 5, LI(4, 0x556) },
400 /* 13*/ { LI(0x2222222222222222, 0x2222222222222222), 8, LI(0x1111111111111110, 0x1111111111111111) }, /* Overflow */
401 /* 14*/ { LI(432, 518), 10, LI(4320, 5180) },
402 /* 15*/ { LI(0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCC), 20, LI(0xFFFFFFFFFFFFFFF0, 0xFFFFFFFFFFFFFFFF) },
403 /* 16*/ { LI(432, 518), 100, LI(43200, 51800) },
404 /* 17*/ { LI(0x123456789ABCDEF0, 0x123456789ABCDE), 0xE0F, LI(0xEDCBA98765423010, 0xFFEDCBA987653601) },
405 /* 18*/ { LI(0xFFFFFFFFFFFFFFFF, 1), 2, LI(0xFFFFFFFFFFFFFFFE, 3) },
406 /* 19*/ { LI(0xFFFFFFFFFFFFFFFF, 1), 10, LI(0xFFFFFFFFFFFFFFF6, 19) },
407 /* 20*/ { LI(0xFFFFFFFFFFFFFFFF, 1), 0x1234567890ABCDEF, LI(0xEDCBA9876F543211, 0x2468ACF121579BDD) },
408 /* 21*/ { LI(0xFFFFFFFFFFFFFFFF, 0xCF), 0x123456789ABCDEF, LI(0xFEDCBA9876543211, 0xECA8641FDB97522F) },
409 /* 22*/ { LI(0xFFFFFFFFFFFFFFFF, 0x123456), 0x123456789AB, LI(0xFFFFFEDCBA987655, 0x14B66E5D4C2C851C) },
410 /* 23*/ { LI(0xFFFFFFFFFFFFFFFF, 0), 0xFFFFFFFFFFFFFFFF, LI(1, 0xFFFFFFFFFFFFFFFE) },
411 };
412 int data_size = ARRAY_SIZE(data);
413 int i;
414
415 char t_dump[35];
416 char expected_dump[35];
417
418 testStart("test_mul_u64");
419
420 for (i = 0; i < data_size; i++) {
421
422 if (testContinue(p_ctx, i)) continue;
423
424 large_mul_u64(&data[i].t, data[i].s);
425
426 assert_equalu64(data[i].t.lo, data[i].expected.lo, "i:%d lo 0x%" LX_FMT "X (%s) != expected lo 0x%" LX_FMT "X (%s)\n",
427 i, data[i].t.lo, large_dump(&data[i].t, t_dump), data[i].expected.lo, large_dump(&data[i].expected, expected_dump));
428 assert_equalu64(data[i].t.hi, data[i].expected.hi, "i:%d hi 0x%" LX_FMT "X (%s) != expected hi 0x%" LX_FMT "X (%s)\n",
429 i, data[i].t.hi, large_dump(&data[i].t, t_dump), data[i].expected.hi, large_dump(&data[i].expected, expected_dump));
430 }
431
432 testFinish();
433 }
434
435 static void test_div_u64(const testCtx *const p_ctx) {
436
437 uint64_t r;
438 struct item {
439 large_uint t;
440 uint64_t s;
441 uint64_t expected_r;
442 large_uint expected;
443 };
444 /* s/\/\*[ 0-9]*\*\//\=printf("\/\*%3d*\/", line(".") - line("'<")): */
445 struct item data[] = {
446 /* 0*/ { LI(0, 0), 1, 0, LI(0, 0) },
447 /* 1*/ { LI(1, 0), 1, 0, LI(1, 0) },
448 /* 2*/ { LI(4990000, 0), 509999, 400009, LI(9, 0) },
449 /* 3*/ { LI(3, 0), 2, 1, LI(1, 0) }, /* BEGIN divmnu64.c.txt (first 3 errors) */
450 /* 4*/ { LI(3, 0), 3, 0, LI(1, 0) },
451 /* 5*/ { LI(3, 0), 4, 3, LI(0, 0) },
452 /* 6*/ { LI(0, 0), 0xFFFFFFFF, 0, LI(0, 0) },
453 /* 7*/ { LI(0xFFFFFFFF, 0), 1, 0, LI(0xFFFFFFFF, 0) },
454 /* 8*/ { LI(0xFFFFFFFF, 0), 0xFFFFFFFF, 0, LI(1, 0) },
455 /* 9*/ { LI(0xFFFFFFFF, 0), 3, 0, LI(0x55555555, 0) },
456 /* 10*/ { LI(0xFFFFFFFFFFFFFFFF, 0), 1, 0, LI(0xFFFFFFFFFFFFFFFF, 0) },
457 /* 11*/ { LI(0xFFFFFFFFFFFFFFFF, 0), 0xFFFFFFFF, 0, LI(0x100000001, 0) },
458 /* 12*/ { LI(0xFFFFFFFEFFFFFFFF, 0), 0xFFFFFFFF, 0xFFFFFFFE, LI(0xFFFFFFFF, 0) },
459 /* 13*/ { LI(0x0000123400005678, 0), 0x00009ABC, 0x6BD0, LI(0x1E1DBA76, 0) },
460 /* 14*/ { LI(0, 0), 0x100000000, 0, LI(0, 0) },
461 /* 15*/ { LI(0x700000000, 0), 0x300000000, 0x100000000, LI(2, 0) },
462 /* 16*/ { LI(0x700000005, 0), 0x300000000, 0x100000005, LI(2, 0) },
463 /* 17*/ { LI(0x600000000, 0), 0x200000000, 0, LI(3, 0) },
464 /* 18*/ { LI(0x80000000, 0), 0x40000001, 0x3FFFFFFF, LI(1, 0) },
465 /* 19*/ { LI(0x8000000000000000, 0), 0x40000001, 8, LI(0x1FFFFFFF8, 0) },
466 /* 20*/ { LI(0x8000000000000000, 0), 0x4000000000000001, 0x3FFFFFFFFFFFFFFF, LI(1, 0) },
467 /* 21*/ { LI(0x0000BCDE0000789A, 0), 0x0000BCDE0000789A, 0, LI(1, 0) },
468 /* 22*/ { LI(0x0000BCDE0000789B, 0), 0x0000BCDE0000789A, 1, LI(1, 0) },
469 /* 23*/ { LI(0x0000BCDE00007899, 0), 0x0000BCDE0000789A, 0x0000BCDE00007899, LI(0, 0) },
470 /* 24*/ { LI(0x0000FFFF0000FFFF, 0), 0x0000FFFF0000FFFF, 0, LI(1, 0) },
471 /* 25*/ { LI(0x0000FFFF0000FFFF, 0), 0x100000000, 0x0000FFFF, LI(0x0000FFFF, 0) },
472 /* 26*/ { LI(0x00004567000089AB, 0x00000123), 0x100000000, 0x000089AB, LI(0x0000012300004567, 0) },
473 /* 27*/ { LI(0x0000FFFE00000000, 0x00008000), 0x000080000000FFFF, 0x7FFF0000FFFF, LI(0xFFFFFFFF, 0) }, /* END divmnu64.c.txt (last 6 96-bit divisor); shows that first qhat0 can = b + 1 */
474 /* 28*/ { LI(0, 0x80000000FFFE0000), 0x80000000FFFF0000, 0x1FFFE00000000, LI(0xFFFFFFFFFFFE0000, 0) }, /* Shows that first qhat1 can = b + 1 */
475 /* 29*/ { LI(0xFFFE000000000000, 0x80000000), 0x80000000FFFF0000, 0x7FFF0000FFFF0000, LI(0xFFFFFFFF, 0) }, /* First qhat0 = b + 1 */
476 /* 30*/ { LI(0x7FFF800000000000, 0), 0x800000000001, 0x7FFFFFFF0002, LI(0xFFFE, 0) }, /* "add back" examples won't trigger as divisor only 2 digits (in 2**32 base) */
477 /* 31*/ { LI(0, 0x7FFF800000000000), 0x800000000001, 0x1FFFE0000, LI(0xFFFFFFFE00020000, 0xFFFE) },
478 /* 32*/ { LI(0x0000000000000003, 0x80000000), 0x2000000000000001, 0x1FFFFFFC00000004, LI(0x3FFFFFFFF, 0) },
479 /* 33*/ { LI(0x0000000000000003, 0x00008000), 0x2000000000000001, 0x1FFFFFFFFFFC0004, LI(0x3FFFF, 0) },
480 /* 34*/ { LI(0x8000000000000003, 0), 0x2000000000000001, 0x2000000000000000, LI(3, 0) },
481 /* 35*/ { LI(0x0000000000000000, 0x00007FFF00008000), 0x8000000000000001, 0x7FFF0001FFFF0001, LI(0xFFFE0000FFFF, 0) },
482 /* 36*/ { LI(0xFFFFFFFFFFFFFFFF, 0), 0xFFFFFFFFFFFFFFFF, 0, LI(1, 0) },
483 /* 37*/ { LI(0, 1), 1, 0, LI(0, 1) },
484 /* 38*/ { LI(1, 1), 1, 0, LI(1, 1) },
485 /* 39*/ { LI(1, 1), 2, 1, LI(0x8000000000000000, 0) },
486 /* 40*/ { LI(2, 1), 2, 0, LI(0x8000000000000001, 0) },
487 /* 41*/ { LI(3, 1), 3, 1, LI(0x5555555555555556, 0) },
488 /* 42*/ { LI(0, 1), 3, 1, LI(0x5555555555555555, 0) },
489 /* 43*/ { LI(1, 1), 3, 2, LI(0x5555555555555555, 0) },
490 /* 44*/ { LI(0, 7), 3, 1, LI(0x5555555555555555, 2) },
491 /* 45*/ { LI(5, 7), 3, 0, LI(0x5555555555555557, 2) },
492 /* 46*/ { LI(0, 10), 3, 1, LI(0x5555555555555555, 3) },
493 /* 47*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFE), 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFE, LI(0xFFFFFFFF, 0) },
494 /* 48*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 3, 0, LI(0x5555555555555555, 0x5555555555555555) },
495 /* 49*/ { LI(0x0000000100000000, 0), 3, 1, LI(0x55555555, 0) },
496 /* 50*/ { LI(0, 0x0000000100000000), 3, 1, LI(0x5555555555555555, 0x55555555) },
497 /* 51*/ { LI(0x0000000100000000, 0x0000000100000000), 3, 2, LI(0x55555555AAAAAAAA, 0x55555555) },
498 /* 52*/ { LI(0x0000000100000001, 0x0000000100000001), 3, 1, LI(0xAAAAAAAB00000000, 0x55555555) },
499 /* 53*/ { LI(0x7C54A8E022961911, 0x92940F87B13D9529), 0xF09B387392497535, 0x3A5BBDA3D6EBF8D7, LI(0x9BF4CCB73D412892, 0) },
500 /* 54*/ { LI(0x57BC33D2FAB596C9, 0x63F589EB9FB6C96), 0x90B9A0DB6A5F, 0x43555745A6D4, LI(0x957BE34B1882E2B, 0xB0D) },
501 /* 55*/ { LI(0x1000000000000000, 0x1000000000000000), 0x10000000, 0, LI(0x100000000, 0x100000000) },
502 /* 56*/ { LI(0x1000000000000001, 0x1000000000000001), 0x10000000, 1, LI(0x1100000000, 0x100000000) },
503 /* 57*/ { LI(0x1000000000000001, 0x1000000000000001), 0x10000001, 0x1111, LI(0x110FFFFEEF0, 0xFFFFFFF0) },
504 /* 58*/ { LI(0x99999999999999BF, 0x9999999999999999), 0x5555555567, 0x3331D64530, LI(0xCC6D6666667A2699, 0x1CCCCCC) },
505 /* 59*/ { LI(0, 0xFFFFFFFFFFFFFFFF), 0x200000000, 0, LI(0xFFFFFFFF80000000, 0x7FFFFFFF) },
506 /* 60*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 0x200000000, 0x1FFFFFFFF, LI(0xFFFFFFFFFFFFFFFF, 0x7FFFFFFF) },
507 /* 61*/ { LI(0, 0xFFFFFFFFFFFFFFFF), 0x300000000, 0, LI(0x5555555500000000, 0x55555555) },
508 /* 62*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 0x300000000, 0xFFFFFFFF, LI(0x5555555555555555, 0x55555555) },
509 /* 63*/ { LI(0x0000000300000004, 0x0000000100000002), 0x200000003, 0x40000001, LI(0x8000000040000001, 0) },
510 /* 64*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 0x2000000000000000, 0x1FFFFFFFFFFFFFFF, LI(0xFFFFFFFFFFFFFFFF, 7) },
511 /* 65*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 0x3000000000000000, 0xFFFFFFFFFFFFFFF, LI(0x5555555555555555, 5) },
512 /* 66*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 0xFFFFFFFFFFFFFFFF, 0, LI(1, 1) },
513 /* 67*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFEFFFFFFFF), 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFEFFFFFFFF, LI(0xFFFFFFFF00000000, 0) },
514 /* 68*/ { LI(0x00000F70677372AE, 0), 0x453AF5, 0, LI(0x391736, 0) }, /* Divisor 0x453AF5 (4537077) used by RSS14 */
515 /* 69*/ { LI(0x00000F70677372AF, 0), 0x453AF5, 1, LI(0x391736, 0) },
516 /* 70*/ { LI(0x00000F70677372B0, 0), 0x453AF5, 2, LI(0x391736, 0) },
517 /* 71*/ { LI(0x453AF4, 0), 0x453AF5, 0x453AF4, LI(0, 0) },
518 /* 72*/ { LI(0x453AF5, 0), 0x453AF5, 0, LI(1, 0) },
519 /* 73*/ { LI(0x453AF6, 0), 0x453AF5, 1, LI(1, 0) },
520 /* 74*/ { { 0x453AF5 * 10 - 1, 0 }, 0x453AF5, 0x453AF4, LI(9, 0) },
521 /* 75*/ { LI(0x000003A03166E0CE, 0), 0x1EB983, 0x1EB982, LI(0x1E35C4, 0) }, /* Divisor 0x1EB983 (2013571) used by RSS_LTD */
522 /* 76*/ { LI(0x000003A03166E0CF, 0), 0x1EB983, 0, LI(0x1E35C5, 0) },
523 /* 77*/ { LI(0x000003A03166E0D0, 0), 0x1EB983, 1, LI(0x1E35C5, 0) },
524 /* 78*/ { LI(0x93BB793904CAFFFF, 0x13F50B74), 32, 0x1F, LI(0xA49DDBC9C82657FF, 0x9FA85B) }, /* Divisor 32 used by MAILMARK_4S */
525 /* 79*/ { LI(0x93BB793904CB0000, 0x13F50B74), 32, 0, LI(0xA49DDBC9C8265800, 0x9FA85B) },
526 /* 80*/ { LI(0x93BB793904CB0001, 0x13F50B74), 32, 1, LI(0xA49DDBC9C8265800, 0x9FA85B) },
527 /* 81*/ { LI(0x93BB793904CAFFFF, 0x13F50B74), 30, 0x1D, LI(0x8D752EB519C27FFF, 0xAA4D2E) }, /* Divisor 30 used by MAILMARK_4S */
528 /* 82*/ { LI(0x93BB793904CB0000, 0x13F50B74), 30, 0, LI(0x8D752EB519C28000, 0xAA4D2E) },
529 /* 83*/ { LI(0x93BB793904CB0001, 0x13F50B74), 30, 1, LI(0x8D752EB519C28000, 0xAA4D2E) },
530 /* 84*/ { LI(0x4ABC16A2E5C005FF, 0x16907B2A2), 636, 635, LI(0xD70F9761AA390E7F, 0x9151FD) }, /* Divisor 636 used by ONECODE */
531 /* 85*/ { LI(0x4ABC16A2E5C00600, 0x16907B2A2), 636, 0, LI(0xD70F9761AA390E80, 0x9151FD) },
532 /* 86*/ { LI(0x4ABC16A2E5C00601, 0x16907B2A2), 636, 1, LI(0xD70F9761AA390E80, 0x9151FD) },
533 /* 87*/ { LI(0x4ABC16A2E5C00734, 0x16907B2A2), 1365, 1364, LI(0xD93B96FDAE65FA60, 0x43B5AC) }, /* Divisor 1365 used by ONECODE */
534 /* 88*/ { LI(0x4ABC16A2E5C00735, 0x16907B2A2), 1365, 0, LI(0xD93B96FDAE65FA61, 0x43B5AC) },
535 /* 89*/ { LI(0x4ABC16A2E5C00736, 0x16907B2A2), 1365, 1, LI(0xD93B96FDAE65FA61, 0x43B5AC) },
536 };
537 int data_size = ARRAY_SIZE(data);
538 int i;
539
540 char t_dump[35];
541 char expected_dump[35];
542
543 testStart("test_div_u64");
544
545 for (i = 0; i < data_size; i++) {
546
547 if (testContinue(p_ctx, i)) continue;
548
549 r = large_div_u64(&data[i].t, data[i].s);
550
551 assert_equalu64(r, data[i].expected_r, "i:%d r %" LX_FMT "u (0x%" LX_FMT "X) != expected_r %" LX_FMT "u (0x%" LX_FMT "X)\n",
552 i, r, r, data[i].expected_r, data[i].expected_r);
553 assert_equalu64(data[i].t.lo, data[i].expected.lo, "i:%d lo 0x%" LX_FMT "X (%s) != expected lo 0x%" LX_FMT "X (%s)\n",
554 i, data[i].t.lo, large_dump(&data[i].t, t_dump), data[i].expected.lo, large_dump(&data[i].expected, expected_dump));
555 assert_equalu64(data[i].t.hi, data[i].expected.hi, "i:%d hi 0x%" LX_FMT "X (%s) != expected hi 0x%" LX_FMT "X (%s)\n",
556 i, data[i].t.hi, large_dump(&data[i].t, t_dump), data[i].expected.hi, large_dump(&data[i].expected, expected_dump));
557 }
558
559 testFinish();
560 }
561
562 static void test_unset_bit(const testCtx *const p_ctx) {
563
564 struct item {
565 large_uint t;
566 int s;
567 large_uint expected;
568 };
569 /* s/\/\*[ 0-9]*\*\//\=printf("\/\*%3d*\/", line(".") - line("'<")): */
570 struct item data[] = {
571 /* 0*/ { LI(0, 0), 0, LI(0, 0) },
572 /* 1*/ { LI(0, 0xFFFFFFFFFFFFFFFF), 0, LI(0, 0xFFFFFFFFFFFFFFFF) },
573 /* 2*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 0, LI(0xFFFFFFFFFFFFFFFE, 0xFFFFFFFFFFFFFFFF) },
574 /* 3*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 1, LI(0xFFFFFFFFFFFFFFFD, 0xFFFFFFFFFFFFFFFF) },
575 /* 4*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 2, LI(0xFFFFFFFFFFFFFFFB, 0xFFFFFFFFFFFFFFFF) },
576 /* 5*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 3, LI(0xFFFFFFFFFFFFFFF7, 0xFFFFFFFFFFFFFFFF) },
577 /* 6*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 4, LI(0xFFFFFFFFFFFFFFEF, 0xFFFFFFFFFFFFFFFF) },
578 /* 7*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 5, LI(0xFFFFFFFFFFFFFFDF, 0xFFFFFFFFFFFFFFFF) },
579 /* 8*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 6, LI(0xFFFFFFFFFFFFFFBF, 0xFFFFFFFFFFFFFFFF) },
580 /* 9*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 7, LI(0xFFFFFFFFFFFFFF7F, 0xFFFFFFFFFFFFFFFF) },
581 /* 10*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 8, LI(0xFFFFFFFFFFFFFEFF, 0xFFFFFFFFFFFFFFFF) },
582 /* 11*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 9, LI(0xFFFFFFFFFFFFFDFF, 0xFFFFFFFFFFFFFFFF) },
583 /* 12*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 10, LI(0xFFFFFFFFFFFFFBFF, 0xFFFFFFFFFFFFFFFF) },
584 /* 13*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 11, LI(0xFFFFFFFFFFFFF7FF, 0xFFFFFFFFFFFFFFFF) },
585 /* 14*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 12, LI(0xFFFFFFFFFFFFEFFF, 0xFFFFFFFFFFFFFFFF) },
586 /* 15*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 13, LI(0xFFFFFFFFFFFFDFFF, 0xFFFFFFFFFFFFFFFF) },
587 /* 16*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 14, LI(0xFFFFFFFFFFFFBFFF, 0xFFFFFFFFFFFFFFFF) },
588 /* 17*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 15, LI(0xFFFFFFFFFFFF7FFF, 0xFFFFFFFFFFFFFFFF) },
589 /* 18*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 16, LI(0xFFFFFFFFFFFEFFFF, 0xFFFFFFFFFFFFFFFF) },
590 /* 19*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 17, LI(0xFFFFFFFFFFFDFFFF, 0xFFFFFFFFFFFFFFFF) },
591 /* 20*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 18, LI(0xFFFFFFFFFFFBFFFF, 0xFFFFFFFFFFFFFFFF) },
592 /* 21*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 19, LI(0xFFFFFFFFFFF7FFFF, 0xFFFFFFFFFFFFFFFF) },
593 /* 22*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 20, LI(0xFFFFFFFFFFEFFFFF, 0xFFFFFFFFFFFFFFFF) },
594 /* 23*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 21, LI(0xFFFFFFFFFFDFFFFF, 0xFFFFFFFFFFFFFFFF) },
595 /* 24*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 22, LI(0xFFFFFFFFFFBFFFFF, 0xFFFFFFFFFFFFFFFF) },
596 /* 25*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 23, LI(0xFFFFFFFFFF7FFFFF, 0xFFFFFFFFFFFFFFFF) },
597 /* 26*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 24, LI(0xFFFFFFFFFEFFFFFF, 0xFFFFFFFFFFFFFFFF) },
598 /* 27*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 25, LI(0xFFFFFFFFFDFFFFFF, 0xFFFFFFFFFFFFFFFF) },
599 /* 28*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 26, LI(0xFFFFFFFFFBFFFFFF, 0xFFFFFFFFFFFFFFFF) },
600 /* 29*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 27, LI(0xFFFFFFFFF7FFFFFF, 0xFFFFFFFFFFFFFFFF) },
601 /* 30*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 28, LI(0xFFFFFFFFEFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
602 /* 31*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 29, LI(0xFFFFFFFFDFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
603 /* 32*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 30, LI(0xFFFFFFFFBFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
604 /* 33*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 31, LI(0xFFFFFFFF7FFFFFFF, 0xFFFFFFFFFFFFFFFF) },
605 /* 34*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 32, LI(0xFFFFFFFEFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
606 /* 35*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 33, LI(0xFFFFFFFDFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
607 /* 36*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 34, LI(0xFFFFFFFBFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
608 /* 37*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 35, LI(0xFFFFFFF7FFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
609 /* 38*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 36, LI(0xFFFFFFEFFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
610 /* 39*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 37, LI(0xFFFFFFDFFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
611 /* 40*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 38, LI(0xFFFFFFBFFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
612 /* 41*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 39, LI(0xFFFFFF7FFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
613 /* 42*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 40, LI(0xFFFFFEFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
614 /* 43*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 41, LI(0xFFFFFDFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
615 /* 44*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 42, LI(0xFFFFFBFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
616 /* 45*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 43, LI(0xFFFFF7FFFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
617 /* 46*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 44, LI(0xFFFFEFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
618 /* 47*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 45, LI(0xFFFFDFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
619 /* 48*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 46, LI(0xFFFFBFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
620 /* 49*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 47, LI(0xFFFF7FFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
621 /* 50*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 48, LI(0xFFFEFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
622 /* 51*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 49, LI(0xFFFDFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
623 /* 52*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 50, LI(0xFFFBFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
624 /* 53*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 51, LI(0xFFF7FFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
625 /* 54*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 52, LI(0xFFEFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
626 /* 55*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 53, LI(0xFFDFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
627 /* 56*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 54, LI(0xFFBFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
628 /* 57*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 55, LI(0xFF7FFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
629 /* 58*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 56, LI(0xFEFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
630 /* 59*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 57, LI(0xFDFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
631 /* 60*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 58, LI(0xFBFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
632 /* 61*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 59, LI(0xF7FFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
633 /* 62*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 60, LI(0xEFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
634 /* 63*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 61, LI(0xDFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
635 /* 64*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 62, LI(0xBFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
636 /* 65*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 63, LI(0x7FFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
637 /* 66*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 64, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFE) },
638 /* 67*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 65, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFD) },
639 /* 68*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 66, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFB) },
640 /* 69*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 67, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFF7) },
641 /* 70*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 68, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFEF) },
642 /* 71*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 69, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFDF) },
643 /* 72*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 70, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFBF) },
644 /* 73*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 71, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFF7F) },
645 /* 74*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 72, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFEFF) },
646 /* 75*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 73, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFDFF) },
647 /* 76*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 74, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFBFF) },
648 /* 77*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 75, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFF7FF) },
649 /* 78*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 76, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFEFFF) },
650 /* 79*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 77, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFDFFF) },
651 /* 80*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 78, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFBFFF) },
652 /* 81*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 79, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFF7FFF) },
653 /* 82*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 80, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFEFFFF) },
654 /* 83*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 81, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFDFFFF) },
655 /* 84*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 82, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFBFFFF) },
656 /* 85*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 83, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFF7FFFF) },
657 /* 86*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 84, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFEFFFFF) },
658 /* 87*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 85, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFDFFFFF) },
659 /* 88*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 86, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFBFFFFF) },
660 /* 89*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 87, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFF7FFFFF) },
661 /* 90*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 88, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFEFFFFFF) },
662 /* 91*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 89, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFDFFFFFF) },
663 /* 92*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 90, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFBFFFFFF) },
664 /* 93*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 91, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFF7FFFFFF) },
665 /* 94*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 92, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFEFFFFFFF) },
666 /* 95*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 93, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFDFFFFFFF) },
667 /* 96*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 94, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFBFFFFFFF) },
668 /* 97*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 95, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFF7FFFFFFF) },
669 /* 98*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 96, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFEFFFFFFFF) },
670 /* 99*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 97, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFDFFFFFFFF) },
671 /*100*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 98, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFBFFFFFFFF) },
672 /*101*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 99, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFF7FFFFFFFF) },
673 /*102*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 100, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFEFFFFFFFFF) },
674 /*103*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 101, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFDFFFFFFFFF) },
675 /*104*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 102, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFBFFFFFFFFF) },
676 /*105*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 103, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFF7FFFFFFFFF) },
677 /*106*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 104, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFEFFFFFFFFFF) },
678 /*107*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 105, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFDFFFFFFFFFF) },
679 /*108*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 106, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFBFFFFFFFFFF) },
680 /*109*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 107, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFF7FFFFFFFFFF) },
681 /*110*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 108, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFEFFFFFFFFFFF) },
682 /*111*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 109, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFDFFFFFFFFFFF) },
683 /*112*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 110, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFBFFFFFFFFFFF) },
684 /*113*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 111, LI(0xFFFFFFFFFFFFFFFF, 0xFFFF7FFFFFFFFFFF) },
685 /*114*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 112, LI(0xFFFFFFFFFFFFFFFF, 0xFFFEFFFFFFFFFFFF) },
686 /*115*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 113, LI(0xFFFFFFFFFFFFFFFF, 0xFFFDFFFFFFFFFFFF) },
687 /*116*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 114, LI(0xFFFFFFFFFFFFFFFF, 0xFFFBFFFFFFFFFFFF) },
688 /*117*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 115, LI(0xFFFFFFFFFFFFFFFF, 0xFFF7FFFFFFFFFFFF) },
689 /*118*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 116, LI(0xFFFFFFFFFFFFFFFF, 0xFFEFFFFFFFFFFFFF) },
690 /*119*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 117, LI(0xFFFFFFFFFFFFFFFF, 0xFFDFFFFFFFFFFFFF) },
691 /*120*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 118, LI(0xFFFFFFFFFFFFFFFF, 0xFFBFFFFFFFFFFFFF) },
692 /*121*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 119, LI(0xFFFFFFFFFFFFFFFF, 0xFF7FFFFFFFFFFFFF) },
693 /*122*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 120, LI(0xFFFFFFFFFFFFFFFF, 0xFEFFFFFFFFFFFFFF) },
694 /*123*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 121, LI(0xFFFFFFFFFFFFFFFF, 0xFDFFFFFFFFFFFFFF) },
695 /*124*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 122, LI(0xFFFFFFFFFFFFFFFF, 0xFBFFFFFFFFFFFFFF) },
696 /*125*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 123, LI(0xFFFFFFFFFFFFFFFF, 0xF7FFFFFFFFFFFFFF) },
697 /*126*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 124, LI(0xFFFFFFFFFFFFFFFF, 0xEFFFFFFFFFFFFFFF) },
698 /*127*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 125, LI(0xFFFFFFFFFFFFFFFF, 0xDFFFFFFFFFFFFFFF) },
699 /*128*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 126, LI(0xFFFFFFFFFFFFFFFF, 0xBFFFFFFFFFFFFFFF) },
700 /*129*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 127, LI(0xFFFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFF) },
701 /*130*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 128, LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF) },
702 };
703 int data_size = ARRAY_SIZE(data);
704 int i;
705
706 char t_dump[35];
707 char expected_dump[35];
708
709 testStart("test_unset_bit");
710
711 for (i = 0; i < data_size; i++) {
712
713 if (testContinue(p_ctx, i)) continue;
714
715 large_unset_bit(&data[i].t, data[i].s);
716
717 assert_equalu64(data[i].t.lo, data[i].expected.lo, "i:%d lo 0x%" LX_FMT "X (%s) != expected lo 0x%" LX_FMT "X (%s)\n",
718 i, data[i].t.lo, large_dump(&data[i].t, t_dump), data[i].expected.lo, large_dump(&data[i].expected, expected_dump));
719 assert_equalu64(data[i].t.hi, data[i].expected.hi, "i:%d hi 0x%" LX_FMT "X (%s) != expected hi 0x%" LX_FMT "X (%s)\n",
720 i, data[i].t.hi, large_dump(&data[i].t, t_dump), data[i].expected.hi, large_dump(&data[i].expected, expected_dump));
721 }
722
723 testFinish();
724 }
725
726 static void test_uint_array(const testCtx *const p_ctx) {
727
728 struct item {
729 large_uint t;
730 int size;
731 int bits;
732 unsigned int expected[130];
733 };
734 /* s/\/\*[ 0-9]*\*\//\=printf("\/\*%3d*\/", line(".") - line("'<")): */
735 struct item data[] = {
736 /* 0*/ { LI(0, 0), 0, 0, { 0 } },
737 /* 1*/ { LI(1, 1), 16, 0, { 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1 } },
738 /* 2*/ { LI(1, 1), 15, 0, { 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1 } },
739 /* 3*/ { LI(0x1122334455667788, 0x99AABBCCDDEEFF01), 16, 0, { 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x01, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88 } },
740 /* 4*/ { LI(0x1122334455667788, 0x99AABBCCDDEEFF01), 13, 0, { 0xCC, 0xDD, 0xEE, 0xFF, 0x01, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88 } },
741 /* 5*/ { LI(0x1122334455667788, 0x99AABBCCDDEEFF01), 6, 0, { 0x33, 0x44, 0x55, 0x66, 0x77, 0x88 } },
742 /* 6*/ { LI(1, 1), 128, 1, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 } },
743 /* 7*/ { LI(1, 1), 64, 2, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 } },
744 /* 8*/ { LI(1, 1), 43, 3, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 } },
745 /* 9*/ { LI(1, 1), 32, 4, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, } },
746 /* 10*/ { LI(1, 1), 26, 5, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 } },
747 /* 11*/ { LI(0xAAAAAAAAAAAAAAAA, 0), 13, 5, { 0xA, 0x15, 0xA, 0x15, 0xA, 0x15, 0xA, 0x15, 0xA, 0x15, 0xA, 0x15, 0xA } },
748 /* 12*/ { LI(0x5555555555555555, 0), 13, 5, { 0x5, 0xA, 0x15, 0xA, 0x15, 0xA, 0x15, 0xA, 0x15, 0xA, 0x15, 0xA, 0x15 } },
749 /* 13*/ { LI(0x1122334455667788, 0x99AABBCCDDEEFF01), 26, 5, { 0x4, 0x19, 0x15, 0xA, 0x1D, 0x1C, 0x19, 0x17, 0xF, 0xE, 0x1F, 0x1C, 0x0, 0x11, 0x2, 0x8, 0x11, 0x13, 0x8, 0x11, 0xA, 0x16, 0xC, 0x1D, 0x1C, 0x8 } },
750 /* 14*/ { LI(1, 1), 22, 6, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 } },
751 /* 15*/ { LI(1, 1), 19, 7, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 1 } },
752 /* 16*/ { LI(1, 1), 15, 9, { 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 1 } },
753 /* 17*/ { LI(1, 1), 13, 10, { 0, 0, 0, 0, 0, 0, 0x10, 0, 0, 0, 0, 0, 1 } },
754 /* 18*/ { LI(1, 1), 12, 11, { 0, 0, 0, 0, 0, 0, 0x200, 0, 0, 0, 0, 1 } },
755 /* 19*/ { LI(1, 1), 11, 12, { 0, 0, 0, 0, 0, 0x10, 0, 0, 0, 0, 1 } },
756 /* 20*/ { LI(1, 1), 10, 13, { 0, 0, 0, 0, 0, 0x1000, 0, 0, 0, 1 } },
757 /* 21*/ { LI(1, 1), 10, 14, { 0, 0, 0, 0, 0, 0x100, 0, 0, 0, 1 } },
758 /* 22*/ { LI(1, 1), 9, 15, { 0, 0, 0, 0, 0x10, 0, 0, 0, 1 } },
759 /* 23*/ { LI(1, 1), 8, 16, { 0, 0, 0, 1, 0, 0, 0, 1 } },
760 /* 24*/ { LI(1, 1), 8, 17, { 0, 0, 0, 0, 0x2000, 0, 0, 1 } },
761 /* 25*/ { LI(1, 1), 8, 18, { 0, 0, 0, 0, 0x400, 0, 0, 1 } },
762 /* 26*/ { LI(1, 1), 7, 19, { 0, 0, 0, 0x80, 0, 0, 1 } },
763 /* 27*/ { LI(1, 1), 5, 31, { 0, 0, 4, 0, 1 } },
764 /* 28*/ { LI(1, 1), 4, 32, { 0, 1, 0, 1 } },
765 /* 29*/ { LI(1, 1), 4, 33, { 0, 1, 0, 1 } }, /* Bits > 32 ignored and treated as 32 */
766 /* 30*/ { LI(0xF0F0F0F0F0F0F0F0, 0xE0F0F0F0F0F0F0F0), 129, 1, { 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0 } }, /* Leading zeroes */
767 /* 31*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 130, 1, { 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 } }, /* Leading zeroes */
768 /* 32*/ { LI(0xFFFFFFFFFFFFFFFF, 0xEFFFFFFFFFFFFFFF), 127, 1, { 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 } }, /* Truncated */
769 };
770 int data_size = ARRAY_SIZE(data);
771 int i;
772
773 char t_dump[35];
774 char uint_dump[130 * 17 + 1];
775 char uint_expected_dump[130 * 17 + 1];
776 char uchar_dump[130 * 3 + 1];
777 char uchar_expected_dump[130 * 3 + 1];
778
779 unsigned int uint_array[130];
780 unsigned char uchar_array[130];
781 unsigned char uchar_expected_array[130];
782
783 testStart("test_uint_array");
784
785 for (i = 0; i < data_size; i++) {
786
787 if (testContinue(p_ctx, i)) continue;
788
789 memset(uint_array, 0, sizeof(uint_array));
790
791 large_uint_array(&data[i].t, uint_array, data[i].size, data[i].bits);
792
793 assert_zero(memcmp(uint_array, data[i].expected, data[i].size * sizeof(unsigned int)), "i:%d %s uint memcmp != 0\n actual: %s\nexpected: %s\n",
794 i, large_dump(&data[i].t, t_dump), testUtilUIntArrayDump(uint_array, data[i].size, uint_dump, sizeof(uint_dump)),
795 testUtilUIntArrayDump(data[i].expected, data[i].size, uint_expected_dump, sizeof(uint_expected_dump)));
796
797 if (data[i].bits <= 8) {
798 int j;
799 memset(uchar_array, 0, sizeof(uchar_array));
800 for (j = 0; j < data[i].size; j++) {
801 uchar_expected_array[j] = data[i].expected[j];
802 }
803
804 large_uchar_array(&data[i].t, uchar_array, data[i].size, data[i].bits);
805
806 assert_zero(memcmp(uchar_array, uchar_expected_array, data[i].size), "i:%d %s uchar memcmp != 0\n actual: %s\nexpected: %s\n",
807 i, large_dump(&data[i].t, t_dump), testUtilUCharArrayDump(uchar_array, data[i].size, uchar_dump, sizeof(uchar_dump)),
808 testUtilUCharArrayDump(uchar_expected_array, data[i].size, uchar_expected_dump, sizeof(uchar_expected_dump)));
809 }
810 }
811
812 testFinish();
813 }
814
815 static void test_dump(const testCtx *const p_ctx) {
816
817 struct item {
818 large_uint t;
819 char *expected;
820 };
821 /* s/\/\*[ 0-9]*\*\//\=printf("\/\*%3d*\/", line(".") - line("'<")): */
822 struct item data[] = {
823 /* 0*/ { LI(0, 0), "0x0" },
824 /* 1*/ { LI(1, 0), "0x1" },
825 /* 2*/ { LI(0x12, 0), "0x12" },
826 /* 3*/ { LI(0x123, 0), "0x123" },
827 /* 4*/ { LI(0x1234, 0), "0x1234" },
828 /* 5*/ { LI(0x12345, 0), "0x12345" },
829 /* 6*/ { LI(0x123456, 0), "0x123456" },
830 /* 7*/ { LI(0x1234567, 0), "0x1234567" },
831 /* 8*/ { LI(0x12345678, 0), "0x12345678" },
832 /* 9*/ { LI(0x123456789, 0), "0x123456789" },
833 /* 10*/ { LI(0x1234567890, 0), "0x1234567890" },
834 /* 11*/ { LI(0x12345678901, 0), "0x12345678901" },
835 /* 12*/ { LI(0x123456789012, 0), "0x123456789012" },
836 /* 13*/ { LI(0x1234567890123, 0), "0x1234567890123" },
837 /* 14*/ { LI(0x12345678901234, 0), "0x12345678901234" },
838 /* 15*/ { LI(0x123456789012345, 0), "0x123456789012345" },
839 /* 16*/ { LI(0x1234567890123456, 0), "0x1234567890123456" },
840 /* 17*/ { LI(0x1234567890123456, 1), "0x11234567890123456" },
841 /* 18*/ { LI(0x1234567890123456, 0x12), "0x121234567890123456" },
842 /* 19*/ { LI(0x1234567890123456, 0x123), "0x1231234567890123456" },
843 /* 20*/ { LI(0x1234567890123456, 0x1234), "0x12341234567890123456" },
844 /* 21*/ { LI(0x1234567890123456, 0x12345), "0x123451234567890123456" },
845 /* 22*/ { LI(0x1234567890123456, 0x123456), "0x1234561234567890123456" },
846 /* 23*/ { LI(0x1234567890123456, 0x1234567), "0x12345671234567890123456" },
847 /* 24*/ { LI(0x1234567890123456, 0x12345678), "0x123456781234567890123456" },
848 /* 25*/ { LI(0x1234567890123456, 0x123456789), "0x1234567891234567890123456" },
849 /* 26*/ { LI(0x1234567890123456, 0x1234567890), "0x12345678901234567890123456" },
850 /* 27*/ { LI(0x1234567890123456, 0x12345678901), "0x123456789011234567890123456" },
851 /* 28*/ { LI(0x1234567890123456, 0x123456789012), "0x1234567890121234567890123456" },
852 /* 29*/ { LI(0x1234567890123456, 0x1234567890123), "0x12345678901231234567890123456" },
853 /* 30*/ { LI(0x1234567890123456, 0x12345678901234), "0x123456789012341234567890123456" },
854 /* 31*/ { LI(0x1234567890123456, 0x123456789012345), "0x1234567890123451234567890123456" },
855 /* 32*/ { LI(0x1234567890123456, 0x1234567890123456), "0x12345678901234561234567890123456" },
856 /* 33*/ { LI(0, 1), "0x10000000000000000" },
857 /* 34*/ { LI(1, 1), "0x10000000000000001" },
858 /* 35*/ { LI(0, 0xFFFFFFFF), "0xFFFFFFFF0000000000000000" },
859 /* 36*/ { LI(0, 0xFFFFFFF000000000), "0xFFFFFFF0000000000000000000000000" },
860 /* 37*/ { LI(0, 0xFFFFFFFFFFFFFFFF), "0xFFFFFFFFFFFFFFFF0000000000000000" },
861 /* 38*/ { LI(0xFFFFFFFF, 0xFFFFFFFF), "0xFFFFFFFF00000000FFFFFFFF" },
862 /* 39*/ { LI(0xFFFFFFFF, 0xFFFFFFFF00000000), "0xFFFFFFFF0000000000000000FFFFFFFF" },
863 /* 40*/ { LI(0xFFFFFFFF, 0xFFFFFFFFFFFFFFFF), "0xFFFFFFFFFFFFFFFF00000000FFFFFFFF" },
864 /* 41*/ { LI(0xFFFFFFFF00000000, 0xFFFFFFFF), "0xFFFFFFFFFFFFFFFF00000000" },
865 /* 42*/ { LI(0xFFFFFFFF00000000, 0xFFFFFFFF00000000), "0xFFFFFFFF00000000FFFFFFFF00000000" },
866 /* 43*/ { LI(0xFFFFFFFF00000000, 0xFFFFFFFFFFFFFFFF), "0xFFFFFFFFFFFFFFFFFFFFFFFF00000000" },
867 /* 44*/ { LI(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" },
868 };
869 int data_size = ARRAY_SIZE(data);
870 int i;
871
872 char dump[35];
873
874 testStart("test_dump");
875
876 for (i = 0; i < data_size; i++) {
877
878 if (testContinue(p_ctx, i)) continue;
879
880 memset(dump, 0, sizeof(dump));
881
882 large_dump(&data[i].t, dump);
883
884 assert_zero(strcmp(dump, data[i].expected), "i:%d { %" LX_FMT "X, %" LX_FMT "X } strcmp(%s, %s) != 0\n",
885 i, data[i].t.lo, data[i].t.hi, dump, data[i].expected);
886 }
887
888 testFinish();
889 }
890
891 int main(int argc, char *argv[]) {
892
893 testFunction funcs[] = { /* name, func */
894 { "test_clz_u64", test_clz_u64 },
895 { "test_load", test_load },
896 { "test_load_str_u64", test_load_str_u64 },
897 { "test_add_u64", test_add_u64 },
898 { "test_sub_u64", test_sub_u64 },
899 { "test_mul_u64", test_mul_u64 },
900 { "test_div_u64", test_div_u64 },
901 { "test_unset_bit", test_unset_bit },
902 { "test_uint_array", test_uint_array },
903 { "test_dump", test_dump },
904 };
905
906 testRun(argc, argv, funcs, ARRAY_SIZE(funcs));
907
908 testReport();
909
910 return 0;
911 }
912
913 /* vim: set ts=4 sw=4 et : */