projects / babeltrace.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Re-organize sources
[babeltrace.git] / tests / lib / test_bitfield.c
CommitLineData
6dc2ca62
MD		 1/*
2 * test-bitfield.c
3 *
d79865b9 4 * BabelTrace - bitfield test program
6dc2ca62 5 *
0675eb8c 6 * Copyright 2010-2019 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
6dc2ca62
MD		 7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
9cb421e5 10 * the Free Software Foundation; under version 2 of the License.
6dc2ca62
MD		 11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20 */
21
578e048b 22#include "compat/bitfield.h"
47e0f2e2
MD		 23#include <time.h>
24#include <stdlib.h>
6dc2ca62
MD		 25#include <stdio.h>
26
1833a3d1 27#include <tap/tap.h>
9e8e57d0 28
6dc2ca62
MD		 29unsigned int glob;
30
31/*
32 * This function is only declared to show the size of a bitfield write in
33 * objdump.
34 */
35void fct(void)
36{
47e0f2e2 37 bt_bitfield_write(&glob, unsigned int, 12, 15, 0x12345678);
6dc2ca62
MD		 38}
39
40/* Test array size, in bytes */
41#define TEST_LEN 128
42#define NR_TESTS 10
0675eb8c
MD		 43#define SIGNED_INT_READ_TEST_DESC_FMT_STR "Writing and reading back 0x%X, signed int dest, varying read unit size"
44#define SIGNED_INT_WRITE_TEST_DESC_FMT_STR "Writing and reading back 0x%X, signed int source, varying write unit size"
45#define SIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR "Writing and reading back 0x%llX, signed long long dest, varying read unit size"
46#define SIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR "Writing and reading back 0x%llX, signed long long source, varying write unit size"
47#define UNSIGNED_INT_READ_TEST_DESC_FMT_STR "Writing and reading back 0x%X, unsigned int dest, varying read unit size"
48#define UNSIGNED_INT_WRITE_TEST_DESC_FMT_STR "Writing and reading back 0x%X, unsigned int source, varying write unit size"
49#define UNSIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR "Writing and reading back 0x%llX, unsigned long long dest, varying read unit size"
50#define UNSIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR "Writing and reading back 0x%llX, unsigned long long source, varying write unit size"
9e8e57d0
JG		 51#define DIAG_FMT_STR "Failed reading value written \"%s\"-wise, with start=%i" \
52 " and length=%i. Read %llX"
6dc2ca62 53
0675eb8c
MD		 54static
55unsigned int fls_u64(uint64_t x)
6dc2ca62 56{
0675eb8c 57 unsigned int r = 64;
6dc2ca62 58
0675eb8c
MD		 59 if (!x)
60 return 0;
6dc2ca62 61
0675eb8c
MD		 62 if (!(x & 0xFFFFFFFF00000000ULL)) {
63 x <<= 32;
64 r -= 32;
65 }
66 if (!(x & 0xFFFF000000000000ULL)) {
67 x <<= 16;
68 r -= 16;
69 }
70 if (!(x & 0xFF00000000000000ULL)) {
71 x <<= 8;
72 r -= 8;
73 }
74 if (!(x & 0xF000000000000000ULL)) {
75 x <<= 4;
76 r -= 4;
77 }
78 if (!(x & 0xC000000000000000ULL)) {
79 x <<= 2;
80 r -= 2;
81 }
82 if (!(x & 0x8000000000000000ULL)) {
83 x <<= 1;
84 r -= 1;
85 }
86 return r;
6dc2ca62
MD		 87}
88
0675eb8c
MD		 89static
90unsigned int fls_u32(uint32_t x)
6dc2ca62 91{
0675eb8c 92 unsigned int r = 32;
6dc2ca62
MD		 93
94 if (!x)
95 return 0;
96 if (!(x & 0xFFFF0000U)) {
97 x <<= 16;
98 r -= 16;
99 }
100 if (!(x & 0xFF000000U)) {
101 x <<= 8;
102 r -= 8;
103 }
104 if (!(x & 0xF0000000U)) {
105 x <<= 4;
106 r -= 4;
107 }
108 if (!(x & 0xC0000000U)) {
109 x <<= 2;
110 r -= 2;
111 }
112 if (!(x & 0x80000000U)) {
113 x <<= 1;
114 r -= 1;
115 }
116 return r;
117}
118
47e0f2e2
MD		 119#define print_byte_array(c, len) \
120do { \
121 unsigned long i; \
122 \
123 for (i = 0; i < (len); i++) { \
124 printf("0x%X", (c)[i]); \
125 if (i != (len) - 1) \
126 printf(" "); \
127 } \
128 printf("\n"); \
129} while (0)
130
131#define init_byte_array(c, len, val) \
132do { \
133 unsigned long i; \
134 \
135 for (i = 0; i < (len); i++) \
136 (c)[i] = (val); \
137} while (0)
6dc2ca62 138
9e8e57d0 139#define check_result(ref, val, buffer, typename, start, len, \
0675eb8c 140 desc_fmt_str) \
9e8e57d0
JG		 141({ \
142 if ((val) != (ref)) { \
143 fail(desc_fmt_str, ref); \
144 diag(DIAG_FMT_STR, #typename, start, len, val); \
145 printf("# "); \
146 print_byte_array(buffer, TEST_LEN); \
147 } \
148 (val) != (ref); \
149})
150
0675eb8c 151void run_test_unsigned_write(unsigned int src_ui, unsigned long long src_ull)
6dc2ca62 152{
0675eb8c 153 unsigned int nrbits_ui, nrbits_ull;
6dc2ca62
MD		 154 union {
155 unsigned char c[TEST_LEN];
156 unsigned short s[TEST_LEN/sizeof(unsigned short)];
157 unsigned int i[TEST_LEN/sizeof(unsigned int)];
158 unsigned long l[TEST_LEN/sizeof(unsigned long)];
159 unsigned long long ll[TEST_LEN/sizeof(unsigned long long)];
160 } target;
380d60b1 161 unsigned long long readval;
6dc2ca62 162 unsigned int s, l;
6dc2ca62 163
09650ea1 164 /* The number of bits needed to represent 0 is 0. */
0675eb8c 165 nrbits_ui = fls_u32(src_ui);
6dc2ca62 166
0675eb8c 167 /* Write from unsigned integer src input. */
6dc2ca62 168 for (s = 0; s < CHAR_BIT * TEST_LEN; s++) {
09650ea1 169 for (l = nrbits_ui; l <= (CHAR_BIT * TEST_LEN) - s; l++) {
6dc2ca62 170 init_byte_array(target.c, TEST_LEN, 0xFF);
0675eb8c 171 bt_bitfield_write(target.c, unsigned char, s, l, src_ui);
47e0f2e2 172 bt_bitfield_read(target.c, unsigned char, s, l, &readval);
0675eb8c
MD		 173 if (check_result(src_ui, readval, target.c, unsigned char,
174 s, l, UNSIGNED_INT_WRITE_TEST_DESC_FMT_STR)) {
9e8e57d0 175 return;
6dc2ca62
MD		 176 }
177
178 init_byte_array(target.c, TEST_LEN, 0xFF);
0675eb8c 179 bt_bitfield_write(target.s, unsigned short, s, l, src_ui);
47e0f2e2 180 bt_bitfield_read(target.c, unsigned char, s, l, &readval);
0675eb8c
MD		 181 if (check_result(src_ui, readval, target.c, unsigned short,
182 s, l, UNSIGNED_INT_WRITE_TEST_DESC_FMT_STR)) {
9e8e57d0 183 return;
6dc2ca62
MD		 184 }
185
186 init_byte_array(target.c, TEST_LEN, 0xFF);
0675eb8c 187 bt_bitfield_write(target.i, unsigned int, s, l, src_ui);
47e0f2e2 188 bt_bitfield_read(target.c, unsigned char, s, l, &readval);
0675eb8c
MD		 189 if (check_result(src_ui, readval, target.c, unsigned int,
190 s, l, UNSIGNED_INT_WRITE_TEST_DESC_FMT_STR)) {
9e8e57d0 191 return;
6dc2ca62
MD		 192 }
193
194 init_byte_array(target.c, TEST_LEN, 0xFF);
0675eb8c 195 bt_bitfield_write(target.l, unsigned long, s, l, src_ui);
47e0f2e2 196 bt_bitfield_read(target.c, unsigned char, s, l, &readval);
0675eb8c
MD		 197 if (check_result(src_ui, readval, target.c, unsigned long,
198 s, l, UNSIGNED_INT_WRITE_TEST_DESC_FMT_STR)) {
9e8e57d0 199 return;
6dc2ca62
MD		 200 }
201
202 init_byte_array(target.c, TEST_LEN, 0xFF);
0675eb8c 203 bt_bitfield_write(target.ll, unsigned long long, s, l, src_ui);
47e0f2e2 204 bt_bitfield_read(target.c, unsigned char, s, l, &readval);
0675eb8c
MD		 205 if (check_result(src_ui, readval, target.c, unsigned long long,
206 s, l, UNSIGNED_INT_WRITE_TEST_DESC_FMT_STR)) {
9e8e57d0 207 return;
6dc2ca62
MD		 208 }
209 }
210 }
0675eb8c
MD		 211 pass(UNSIGNED_INT_WRITE_TEST_DESC_FMT_STR, src_ui);
212
09650ea1 213 /* The number of bits needed to represent 0 is 0. */
0675eb8c
MD		 214 nrbits_ull = fls_u64(src_ull);
215
216 /* Write from unsigned long long src input. */
217 for (s = 0; s < CHAR_BIT * TEST_LEN; s++) {
09650ea1 218 for (l = nrbits_ull; l <= (CHAR_BIT * TEST_LEN) - s; l++) {
0675eb8c
MD		 219 init_byte_array(target.c, TEST_LEN, 0xFF);
220 bt_bitfield_write(target.c, unsigned char, s, l, src_ull);
221 bt_bitfield_read(target.c, unsigned char, s, l, &readval);
222 if (check_result(src_ull, readval, target.c, unsigned char,
223 s, l, UNSIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR)) {
224 return;
225 }
9e8e57d0 226
0675eb8c
MD		 227 init_byte_array(target.c, TEST_LEN, 0xFF);
228 bt_bitfield_write(target.s, unsigned short, s, l, src_ull);
229 bt_bitfield_read(target.c, unsigned char, s, l, &readval);
230 if (check_result(src_ull, readval, target.c, unsigned short,
231 s, l, UNSIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR)) {
232 return;
233 }
234
235 init_byte_array(target.c, TEST_LEN, 0xFF);
236 bt_bitfield_write(target.i, unsigned int, s, l, src_ull);
237 bt_bitfield_read(target.c, unsigned char, s, l, &readval);
238 if (check_result(src_ull, readval, target.c, unsigned int,
239 s, l, UNSIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR)) {
240 return;
241 }
242
243 init_byte_array(target.c, TEST_LEN, 0xFF);
244 bt_bitfield_write(target.l, unsigned long, s, l, src_ull);
245 bt_bitfield_read(target.c, unsigned char, s, l, &readval);
246 if (check_result(src_ull, readval, target.c, unsigned long,
247 s, l, UNSIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR)) {
248 return;
249 }
250
251 init_byte_array(target.c, TEST_LEN, 0xFF);
252 bt_bitfield_write(target.ll, unsigned long long, s, l, src_ull);
253 bt_bitfield_read(target.c, unsigned char, s, l, &readval);
254 if (check_result(src_ull, readval, target.c, unsigned long long,
255 s, l, UNSIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR)) {
256 return;
257 }
258 }
259 }
260 pass(UNSIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR, src_ull);
6dc2ca62
MD		 261}
262
0675eb8c 263void run_test_unsigned_read(unsigned int src_ui, unsigned long long src_ull)
6dc2ca62 264{
0675eb8c
MD		 265 unsigned int nrbits_ui, nrbits_ull, readval_ui;
266 union {
267 unsigned char c[TEST_LEN];
268 unsigned short s[TEST_LEN/sizeof(unsigned short)];
269 unsigned int i[TEST_LEN/sizeof(unsigned int)];
270 unsigned long l[TEST_LEN/sizeof(unsigned long)];
271 unsigned long long ll[TEST_LEN/sizeof(unsigned long long)];
272 } target;
273 unsigned long long readval_ull;
274 unsigned int s, l;
275
09650ea1 276 /* The number of bits needed to represent 0 is 0. */
0675eb8c
MD		 277 nrbits_ui = fls_u32(src_ui);
278
279 /* Read to unsigned integer readval output. */
280 for (s = 0; s < CHAR_BIT * TEST_LEN; s++) {
09650ea1 281 for (l = nrbits_ui; l <= (CHAR_BIT * TEST_LEN) - s; l++) {
0675eb8c
MD		 282 init_byte_array(target.c, TEST_LEN, 0xFF);
283 bt_bitfield_write(target.c, unsigned char, s, l, src_ui);
284 bt_bitfield_read(target.c, unsigned char, s, l, &readval_ui);
285 if (check_result(src_ui, readval_ui, target.c, unsigned char,
286 s, l, UNSIGNED_INT_READ_TEST_DESC_FMT_STR)) {
287 return;
288 }
289
290 init_byte_array(target.c, TEST_LEN, 0xFF);
056d0f40
MD		 291 bt_bitfield_write(target.c, unsigned char, s, l, src_ui);
292 bt_bitfield_read(target.s, unsigned short, s, l, &readval_ui);
0675eb8c
MD		 293 if (check_result(src_ui, readval_ui, target.c, unsigned short,
294 s, l, UNSIGNED_INT_READ_TEST_DESC_FMT_STR)) {
295 return;
296 }
297
298 init_byte_array(target.c, TEST_LEN, 0xFF);
056d0f40
MD		 299 bt_bitfield_write(target.c, unsigned char, s, l, src_ui);
300 bt_bitfield_read(target.i, unsigned int, s, l, &readval_ui);
0675eb8c
MD		 301 if (check_result(src_ui, readval_ui, target.c, unsigned int,
302 s, l, UNSIGNED_INT_READ_TEST_DESC_FMT_STR)) {
303 return;
304 }
305
306 init_byte_array(target.c, TEST_LEN, 0xFF);
056d0f40
MD		 307 bt_bitfield_write(target.c, unsigned char, s, l, src_ui);
308 bt_bitfield_read(target.l, unsigned long, s, l, &readval_ui);
0675eb8c
MD		 309 if (check_result(src_ui, readval_ui, target.c, unsigned long,
310 s, l, UNSIGNED_INT_READ_TEST_DESC_FMT_STR)) {
311 return;
312 }
313
314 init_byte_array(target.c, TEST_LEN, 0xFF);
056d0f40
MD		 315 bt_bitfield_write(target.c, unsigned char, s, l, src_ui);
316 bt_bitfield_read(target.ll, unsigned long long, s, l, &readval_ui);
0675eb8c
MD		 317 if (check_result(src_ui, readval_ui, target.c, unsigned long long,
318 s, l, UNSIGNED_INT_READ_TEST_DESC_FMT_STR)) {
319 return;
320 }
321 }
322 }
323 pass(UNSIGNED_INT_READ_TEST_DESC_FMT_STR, src_ui);
324
09650ea1 325 /* The number of bits needed to represent 0 is 0. */
0675eb8c
MD		 326 nrbits_ull = fls_u64(src_ull);
327
328 /* Read to unsigned long long readval output. */
329 for (s = 0; s < CHAR_BIT * TEST_LEN; s++) {
09650ea1 330 for (l = nrbits_ull; l <= (CHAR_BIT * TEST_LEN) - s; l++) {
0675eb8c
MD		 331 init_byte_array(target.c, TEST_LEN, 0xFF);
332 bt_bitfield_write(target.c, unsigned char, s, l, src_ull);
333 bt_bitfield_read(target.c, unsigned char, s, l, &readval_ull);
334 if (check_result(src_ull, readval_ull, target.c, unsigned char,
335 s, l, UNSIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR)) {
336 return;
337 }
338
339 init_byte_array(target.c, TEST_LEN, 0xFF);
056d0f40
MD		 340 bt_bitfield_write(target.c, unsigned char, s, l, src_ull);
341 bt_bitfield_read(target.s, unsigned short, s, l, &readval_ull);
0675eb8c
MD		 342 if (check_result(src_ull, readval_ull, target.c, unsigned short,
343 s, l, UNSIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR)) {
344 return;
345 }
346
347 init_byte_array(target.c, TEST_LEN, 0xFF);
056d0f40
MD		 348 bt_bitfield_write(target.c, unsigned char, s, l, src_ull);
349 bt_bitfield_read(target.i, unsigned int, s, l, &readval_ull);
0675eb8c
MD		 350 if (check_result(src_ull, readval_ull, target.c, unsigned int,
351 s, l, UNSIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR)) {
352 return;
353 }
354
355 init_byte_array(target.c, TEST_LEN, 0xFF);
056d0f40
MD		 356 bt_bitfield_write(target.c, unsigned char, s, l, src_ull);
357 bt_bitfield_read(target.l, unsigned long, s, l, &readval_ull);
0675eb8c
MD		 358 if (check_result(src_ull, readval_ull, target.c, unsigned long,
359 s, l, UNSIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR)) {
360 return;
361 }
362
363 init_byte_array(target.c, TEST_LEN, 0xFF);
056d0f40
MD		 364 bt_bitfield_write(target.c, unsigned char, s, l, src_ull);
365 bt_bitfield_read(target.ll, unsigned long long, s, l, &readval_ull);
0675eb8c
MD		 366 if (check_result(src_ull, readval_ull, target.c, unsigned long long,
367 s, l, UNSIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR)) {
368 return;
369 }
370 }
371 }
372 pass(UNSIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR, src_ull);
373}
374
375void run_test_unsigned(unsigned int src_ui, unsigned long long src_ull)
376{
377 run_test_unsigned_write(src_ui, src_ull);
378 run_test_unsigned_read(src_ui, src_ull);
379}
380
381void run_test_signed_write(int src_i, long long src_ll)
382{
3622ef51 383 unsigned int nrbits_i, nrbits_ll;
6dc2ca62 384 union {
47e0f2e2 385 signed char c[TEST_LEN];
6dc2ca62
MD		 386 short s[TEST_LEN/sizeof(short)];
387 int i[TEST_LEN/sizeof(int)];
388 long l[TEST_LEN/sizeof(long)];
389 long long ll[TEST_LEN/sizeof(long long)];
390 } target;
380d60b1 391 long long readval;
6dc2ca62 392 unsigned int s, l;
6dc2ca62 393
9d9b332b
MD		 394 if (!src_i)
395 nrbits_i = 0; /* The number of bits needed to represent 0 is 0. */
396 else if (src_i & 0x80000000U)
0675eb8c 397 nrbits_i = fls_u32(~src_i) + 1; /* Find least significant bit conveying sign */
6dc2ca62 398 else
0675eb8c 399 nrbits_i = fls_u32(src_i) + 1; /* Keep sign at 0 */
6dc2ca62 400
0675eb8c 401 /* Write from signed integer src input. */
9e8e57d0 402 for (s = 0; s < CHAR_BIT * TEST_LEN; s++) {
09650ea1 403 for (l = nrbits_i; l <= (CHAR_BIT * TEST_LEN) - s; l++) {
6dc2ca62 404 init_byte_array(target.c, TEST_LEN, 0x0);
0675eb8c 405 bt_bitfield_write(target.c, signed char, s, l, src_i);
47e0f2e2 406 bt_bitfield_read(target.c, signed char, s, l, &readval);
0675eb8c
MD		 407 if (check_result(src_i, readval, target.c, signed char,
408 s, l, SIGNED_INT_WRITE_TEST_DESC_FMT_STR)) {
9e8e57d0 409 return;
6dc2ca62
MD		 410 }
411
412 init_byte_array(target.c, TEST_LEN, 0x0);
0675eb8c 413 bt_bitfield_write(target.s, short, s, l, src_i);
47e0f2e2 414 bt_bitfield_read(target.c, signed char, s, l, &readval);
0675eb8c
MD		 415 if (check_result(src_i, readval, target.c, short,
416 s, l, SIGNED_INT_WRITE_TEST_DESC_FMT_STR)) {
9e8e57d0 417 return;
6dc2ca62
MD		 418 }
419
420 init_byte_array(target.c, TEST_LEN, 0x0);
0675eb8c 421 bt_bitfield_write(target.i, int, s, l, src_i);
47e0f2e2 422 bt_bitfield_read(target.c, signed char, s, l, &readval);
0675eb8c
MD		 423 if (check_result(src_i, readval, target.c, int,
424 s, l, SIGNED_INT_WRITE_TEST_DESC_FMT_STR)) {
9e8e57d0 425 return;
6dc2ca62
MD		 426 }
427
428 init_byte_array(target.c, TEST_LEN, 0x0);
0675eb8c 429 bt_bitfield_write(target.l, long, s, l, src_i);
47e0f2e2 430 bt_bitfield_read(target.c, signed char, s, l, &readval);
0675eb8c
MD		 431 if (check_result(src_i, readval, target.c, long,
432 s, l, SIGNED_INT_WRITE_TEST_DESC_FMT_STR)) {
9e8e57d0 433 return;
6dc2ca62
MD		 434 }
435
436 init_byte_array(target.c, TEST_LEN, 0x0);
0675eb8c 437 bt_bitfield_write(target.ll, long long, s, l, src_i);
47e0f2e2 438 bt_bitfield_read(target.c, signed char, s, l, &readval);
0675eb8c
MD		 439 if (check_result(src_i, readval, target.c, long long,
440 s, l, SIGNED_INT_WRITE_TEST_DESC_FMT_STR)) {
9e8e57d0 441 return;
6dc2ca62
MD		 442 }
443 }
444 }
0675eb8c
MD		 445 pass(SIGNED_INT_WRITE_TEST_DESC_FMT_STR, src_i);
446
9d9b332b
MD		 447 if (!src_ll)
448 nrbits_ll = 0; /* The number of bits needed to represent 0 is 0. */
449 else if (src_ll & 0x8000000000000000ULL)
0675eb8c
MD		 450 nrbits_ll = fls_u64(~src_ll) + 1; /* Find least significant bit conveying sign */
451 else
452 nrbits_ll = fls_u64(src_ll) + 1; /* Keep sign at 0 */
453
454 /* Write from signed long long src input. */
455 for (s = 0; s < CHAR_BIT * TEST_LEN; s++) {
09650ea1 456 for (l = nrbits_ll; l <= (CHAR_BIT * TEST_LEN) - s; l++) {
0675eb8c
MD		 457 init_byte_array(target.c, TEST_LEN, 0x0);
458 bt_bitfield_write(target.c, signed char, s, l, src_ll);
459 bt_bitfield_read(target.c, signed char, s, l, &readval);
460 if (check_result(src_ll, readval, target.c, signed char,
461 s, l, SIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR)) {
462 return;
463 }
464
465 init_byte_array(target.c, TEST_LEN, 0x0);
466 bt_bitfield_write(target.s, short, s, l, src_ll);
467 bt_bitfield_read(target.c, signed char, s, l, &readval);
468 if (check_result(src_ll, readval, target.c, short,
469 s, l, SIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR)) {
470 return;
471 }
472
473 init_byte_array(target.c, TEST_LEN, 0x0);
474 bt_bitfield_write(target.i, int, s, l, src_ll);
475 bt_bitfield_read(target.c, signed char, s, l, &readval);
476 if (check_result(src_ll, readval, target.c, int,
477 s, l, SIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR)) {
478 return;
479 }
9e8e57d0 480
0675eb8c
MD		 481 init_byte_array(target.c, TEST_LEN, 0x0);
482 bt_bitfield_write(target.l, long, s, l, src_ll);
483 bt_bitfield_read(target.c, signed char, s, l, &readval);
484 if (check_result(src_ll, readval, target.c, long,
485 s, l, SIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR)) {
486 return;
487 }
488
489 init_byte_array(target.c, TEST_LEN, 0x0);
490 bt_bitfield_write(target.ll, long long, s, l, src_ll);
491 bt_bitfield_read(target.c, signed char, s, l, &readval);
492 if (check_result(src_ll, readval, target.c, long long,
493 s, l, SIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR)) {
494 return;
495 }
496 }
497 }
498 pass(SIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR, src_ll);
6dc2ca62
MD		 499}
500
0675eb8c 501void run_test_signed_read(int src_i, long long src_ll)
6dc2ca62 502{
3622ef51
MD		 503 unsigned int nrbits_i, nrbits_ll;
504 int readval_i;
0675eb8c
MD		 505 union {
506 unsigned char c[TEST_LEN];
507 unsigned short s[TEST_LEN/sizeof(unsigned short)];
508 unsigned int i[TEST_LEN/sizeof(unsigned int)];
509 unsigned long l[TEST_LEN/sizeof(unsigned long)];
510 unsigned long long ll[TEST_LEN/sizeof(unsigned long long)];
511 } target;
512 long long readval_ll;
513 unsigned int s, l;
6dc2ca62 514
9d9b332b
MD		 515 if (!src_i)
516 nrbits_i = 0; /* The number of bits needed to represent 0 is 0. */
517 else if (src_i & 0x80000000U)
0675eb8c
MD		 518 nrbits_i = fls_u32(~src_i) + 1; /* Find least significant bit conveying sign */
519 else
520 nrbits_i = fls_u32(src_i) + 1; /* Keep sign at 0 */
6dc2ca62 521
0675eb8c
MD		 522 /* Read to signed integer readval output. */
523 for (s = 0; s < CHAR_BIT * TEST_LEN; s++) {
09650ea1 524 for (l = nrbits_i; l <= (CHAR_BIT * TEST_LEN) - s; l++) {
0675eb8c
MD		 525 init_byte_array(target.c, TEST_LEN, 0xFF);
526 bt_bitfield_write(target.c, signed char, s, l, src_i);
527 bt_bitfield_read(target.c, signed char, s, l, &readval_i);
528 if (check_result(src_i, readval_i, target.c, signed char,
529 s, l, SIGNED_INT_READ_TEST_DESC_FMT_STR)) {
530 return;
531 }
9e8e57d0 532
0675eb8c 533 init_byte_array(target.c, TEST_LEN, 0xFF);
056d0f40
MD		 534 bt_bitfield_write(target.c, signed char, s, l, src_i);
535 bt_bitfield_read(target.s, short, s, l, &readval_i);
0675eb8c
MD		 536 if (check_result(src_i, readval_i, target.c, short,
537 s, l, SIGNED_INT_READ_TEST_DESC_FMT_STR)) {
538 return;
539 }
9e8e57d0 540
0675eb8c 541 init_byte_array(target.c, TEST_LEN, 0xFF);
056d0f40
MD		 542 bt_bitfield_write(target.c, signed char, s, l, src_i);
543 bt_bitfield_read(target.i, int, s, l, &readval_i);
0675eb8c
MD		 544 if (check_result(src_i, readval_i, target.c, int,
545 s, l, SIGNED_INT_READ_TEST_DESC_FMT_STR)) {
546 return;
547 }
9e8e57d0 548
0675eb8c 549 init_byte_array(target.c, TEST_LEN, 0xFF);
056d0f40
MD		 550 bt_bitfield_write(target.c, signed char, s, l, src_i);
551 bt_bitfield_read(target.l, long, s, l, &readval_i);
0675eb8c
MD		 552 if (check_result(src_i, readval_i, target.c, long,
553 s, l, SIGNED_INT_READ_TEST_DESC_FMT_STR)) {
554 return;
555 }
9e8e57d0 556
0675eb8c 557 init_byte_array(target.c, TEST_LEN, 0xFF);
056d0f40
MD		 558 bt_bitfield_write(target.c, signed char, s, l, src_i);
559 bt_bitfield_read(target.ll, long long, s, l, &readval_i);
0675eb8c
MD		 560 if (check_result(src_i, readval_i, target.c, long long,
561 s, l, SIGNED_INT_READ_TEST_DESC_FMT_STR)) {
562 return;
563 }
564 }
565 }
566 pass(SIGNED_INT_READ_TEST_DESC_FMT_STR, src_i);
567
9d9b332b
MD		 568 if (!src_ll)
569 nrbits_ll = 0; /* The number of bits needed to represent 0 is 0. */
0675eb8c
MD		 570 if (src_ll & 0x8000000000000000ULL)
571 nrbits_ll = fls_u64(~src_ll) + 1; /* Find least significant bit conveying sign */
572 else
573 nrbits_ll = fls_u64(src_ll) + 1; /* Keep sign at 0 */
574
575 /* Read to signed long long readval output. */
576 for (s = 0; s < CHAR_BIT * TEST_LEN; s++) {
09650ea1 577 for (l = nrbits_ll; l <= (CHAR_BIT * TEST_LEN) - s; l++) {
0675eb8c
MD		 578 init_byte_array(target.c, TEST_LEN, 0xFF);
579 bt_bitfield_write(target.c, signed char, s, l, src_ll);
580 bt_bitfield_read(target.c, signed char, s, l, &readval_ll);
581 if (check_result(src_ll, readval_ll, target.c, signed char,
582 s, l, SIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR)) {
583 return;
584 }
585
586 init_byte_array(target.c, TEST_LEN, 0xFF);
056d0f40
MD		 587 bt_bitfield_write(target.c, signed char, s, l, src_ll);
588 bt_bitfield_read(target.s, short, s, l, &readval_ll);
0675eb8c
MD		 589 if (check_result(src_ll, readval_ll, target.c, short,
590 s, l, SIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR)) {
591 return;
592 }
593
594 init_byte_array(target.c, TEST_LEN, 0xFF);
056d0f40
MD		 595 bt_bitfield_write(target.c, signed char, s, l, src_ll);
596 bt_bitfield_read(target.i, int, s, l, &readval_ll);
0675eb8c
MD		 597 if (check_result(src_ll, readval_ll, target.c, int,
598 s, l, SIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR)) {
599 return;
600 }
601
602 init_byte_array(target.c, TEST_LEN, 0xFF);
056d0f40
MD		 603 bt_bitfield_write(target.c, signed char, s, l, src_ll);
604 bt_bitfield_read(target.l, long, s, l, &readval_ll);
0675eb8c
MD		 605 if (check_result(src_ll, readval_ll, target.c, long,
606 s, l, SIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR)) {
607 return;
608 }
609
610 init_byte_array(target.c, TEST_LEN, 0xFF);
056d0f40
MD		 611 bt_bitfield_write(target.c, signed char, s, l, src_ll);
612 bt_bitfield_read(target.ll, long long, s, l, &readval_ll);
0675eb8c
MD		 613 if (check_result(src_ll, readval_ll, target.c, long long,
614 s, l, SIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR)) {
615 return;
616 }
617 }
618 }
619 pass(SIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR, src_ll);
620}
621
622void run_test_signed(int src_i, long long src_ll)
623{
624 run_test_signed_write(src_i, src_ll);
625 run_test_signed_read(src_i, src_ll);
626}
627
628void run_test(void)
629{
630 int i;
631
632 plan_tests(NR_TESTS * 8 + 24);
633
634 srand(time(NULL));
635
636 run_test_unsigned(0, 0);
637 run_test_signed(0, 0);
638 run_test_unsigned(1, 1);
639 run_test_unsigned(~0U, ~0ULL);
640 run_test_signed(-1U, -1ULL);
641 run_test_signed(0x80000000U, 0x8000000000000000ULL);
6dc2ca62
MD		 642
643 for (i = 0; i < NR_TESTS; i++) {
0675eb8c
MD		 644 unsigned int src_ui = rand();
645 unsigned long long src_ull = ((unsigned long long) (unsigned int) rand() << 32) |
646 (unsigned long long) (unsigned int) rand();
647
648 run_test_unsigned(src_ui, src_ull);
649 run_test_signed((int) src_ui, (long long) src_ull);
6dc2ca62 650 }
6dc2ca62
MD		 651}
652
9e8e57d0
JG		 653static
654int print_encodings(unsigned long src, unsigned int shift, unsigned int len)
6dc2ca62 655{
6dc2ca62
MD		 656 union {
657 unsigned char c[8];
658 unsigned short s[4];
659 unsigned int i[2];
660 unsigned long l[2];
661 unsigned long long ll[1];
662 } target;
380d60b1 663 unsigned long long readval;
6dc2ca62 664
9e8e57d0 665 init_byte_array(target.c, 8, 0xFF);
47e0f2e2 666 bt_bitfield_write(target.c, unsigned char, shift, len, src);
6dc2ca62
MD		 667 printf("bytewise\n");
668 print_byte_array(target.c, 8);
669
9e8e57d0 670 init_byte_array(target.c, 8, 0xFF);
47e0f2e2 671 bt_bitfield_write(target.s, unsigned short, shift, len, src);
6dc2ca62
MD		 672 printf("shortwise\n");
673 print_byte_array(target.c, 8);
674
9e8e57d0 675 init_byte_array(target.c, 8, 0xFF);
47e0f2e2 676 bt_bitfield_write(target.i, unsigned int, shift, len, src);
6dc2ca62
MD		 677 printf("intwise\n");
678 print_byte_array(target.c, 8);
679
9e8e57d0 680 init_byte_array(target.c, 8, 0xFF);
47e0f2e2 681 bt_bitfield_write(target.l, unsigned long, shift, len, src);
6dc2ca62
MD		 682 printf("longwise\n");
683 print_byte_array(target.c, 8);
684
9e8e57d0 685 init_byte_array(target.c, 8, 0xFF);
47e0f2e2 686 bt_bitfield_write(target.ll, unsigned long long, shift, len, src);
6dc2ca62
MD		 687 printf("lluwise\n");
688 print_byte_array(target.c, 8);
689
47e0f2e2 690 bt_bitfield_read(target.c, unsigned char, shift, len, &readval);
6dc2ca62 691 printf("read: %llX\n", readval);
9e8e57d0 692 print_byte_array(target.c, 8);
6dc2ca62 693
9e8e57d0
JG		 694 return 0;
695}
696
697int main(int argc, char **argv)
698{
699 if (argc > 1) {
700 /* Print encodings */
701 unsigned long src;
702 unsigned int shift, len;
703
704 src = atoi(argv[1]);
705 if (argc > 2)
706 shift = atoi(argv[2]);
707 else
708 shift = 12;
709 if (argc > 3)
710 len = atoi(argv[3]);
711 else
712 len = 40;
713 return print_encodings(src, shift, len);
714 }
6dc2ca62 715
9e8e57d0
JG		 716 /* Run tap-formated tests */
717 run_test();
718 return exit_status();
6dc2ca62 719}
BabelTrace - Trace Format Babel Tower
This page took 0.089079 seconds and 4 git commands to generate.