projects / babeltrace.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
tests: add format attributes to functions receiving format strings in tap.h
[babeltrace.git] / tests / bitfield / 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"
092f9aea
SM		 51#define DIAG_FMT_STR(val_type_fmt) "Failed reading value written \"%s\"-wise, with start=%i" \
52 " and length=%i. Read 0x" val_type_fmt
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
092f9aea
SM		 139#define check_result(ref, val, buffer, typename, start, len, \
140 desc_fmt_str, val_type_fmt) \
141({ \
142 if ((val) != (ref)) { \
143 fail(desc_fmt_str, ref); \
144 diag(DIAG_FMT_STR(val_type_fmt), #typename, start, len, val); \
145 printf("# "); \
146 print_byte_array(buffer, TEST_LEN); \
147 } \
148 (val) != (ref); \
9e8e57d0
JG		 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 173 if (check_result(src_ui, readval, target.c, unsigned char,
092f9aea
SM		 174 s, l, UNSIGNED_INT_WRITE_TEST_DESC_FMT_STR,
175 "%llX")) {
9e8e57d0 176 return;
6dc2ca62
MD		 177 }
178
179 init_byte_array(target.c, TEST_LEN, 0xFF);
0675eb8c 180 bt_bitfield_write(target.s, unsigned short, s, l, src_ui);
47e0f2e2 181 bt_bitfield_read(target.c, unsigned char, s, l, &readval);
0675eb8c 182 if (check_result(src_ui, readval, target.c, unsigned short,
092f9aea
SM		 183 s, l, UNSIGNED_INT_WRITE_TEST_DESC_FMT_STR,
184 "%llX")) {
9e8e57d0 185 return;
6dc2ca62
MD		 186 }
187
188 init_byte_array(target.c, TEST_LEN, 0xFF);
0675eb8c 189 bt_bitfield_write(target.i, unsigned int, s, l, src_ui);
47e0f2e2 190 bt_bitfield_read(target.c, unsigned char, s, l, &readval);
0675eb8c 191 if (check_result(src_ui, readval, target.c, unsigned int,
092f9aea
SM		 192 s, l, UNSIGNED_INT_WRITE_TEST_DESC_FMT_STR,
193 "%llX")) {
9e8e57d0 194 return;
6dc2ca62
MD		 195 }
196
197 init_byte_array(target.c, TEST_LEN, 0xFF);
0675eb8c 198 bt_bitfield_write(target.l, unsigned long, s, l, src_ui);
47e0f2e2 199 bt_bitfield_read(target.c, unsigned char, s, l, &readval);
0675eb8c 200 if (check_result(src_ui, readval, target.c, unsigned long,
092f9aea
SM		 201 s, l, UNSIGNED_INT_WRITE_TEST_DESC_FMT_STR,
202 "%llX")) {
9e8e57d0 203 return;
6dc2ca62
MD		 204 }
205
206 init_byte_array(target.c, TEST_LEN, 0xFF);
0675eb8c 207 bt_bitfield_write(target.ll, unsigned long long, s, l, src_ui);
47e0f2e2 208 bt_bitfield_read(target.c, unsigned char, s, l, &readval);
0675eb8c 209 if (check_result(src_ui, readval, target.c, unsigned long long,
092f9aea
SM		 210 s, l, UNSIGNED_INT_WRITE_TEST_DESC_FMT_STR,
211 "%llX")) {
9e8e57d0 212 return;
6dc2ca62
MD		 213 }
214 }
215 }
0675eb8c
MD		 216 pass(UNSIGNED_INT_WRITE_TEST_DESC_FMT_STR, src_ui);
217
09650ea1 218 /* The number of bits needed to represent 0 is 0. */
0675eb8c
MD		 219 nrbits_ull = fls_u64(src_ull);
220
221 /* Write from unsigned long long src input. */
222 for (s = 0; s < CHAR_BIT * TEST_LEN; s++) {
09650ea1 223 for (l = nrbits_ull; l <= (CHAR_BIT * TEST_LEN) - s; l++) {
0675eb8c
MD		 224 init_byte_array(target.c, TEST_LEN, 0xFF);
225 bt_bitfield_write(target.c, unsigned char, s, l, src_ull);
226 bt_bitfield_read(target.c, unsigned char, s, l, &readval);
227 if (check_result(src_ull, readval, target.c, unsigned char,
092f9aea
SM		 228 s, l, UNSIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR,
229 "%llX")) {
0675eb8c
MD		 230 return;
231 }
9e8e57d0 232
0675eb8c
MD		 233 init_byte_array(target.c, TEST_LEN, 0xFF);
234 bt_bitfield_write(target.s, unsigned short, s, l, src_ull);
235 bt_bitfield_read(target.c, unsigned char, s, l, &readval);
236 if (check_result(src_ull, readval, target.c, unsigned short,
092f9aea
SM		 237 s, l, UNSIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR,
238 "%llX")) {
0675eb8c
MD		 239 return;
240 }
241
242 init_byte_array(target.c, TEST_LEN, 0xFF);
243 bt_bitfield_write(target.i, unsigned int, s, l, src_ull);
244 bt_bitfield_read(target.c, unsigned char, s, l, &readval);
245 if (check_result(src_ull, readval, target.c, unsigned int,
092f9aea
SM		 246 s, l, UNSIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR,
247 "%llX")) {
0675eb8c
MD		 248 return;
249 }
250
251 init_byte_array(target.c, TEST_LEN, 0xFF);
252 bt_bitfield_write(target.l, unsigned 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,
092f9aea
SM		 255 s, l, UNSIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR,
256 "%llX")) {
0675eb8c
MD		 257 return;
258 }
259
260 init_byte_array(target.c, TEST_LEN, 0xFF);
261 bt_bitfield_write(target.ll, unsigned long long, s, l, src_ull);
262 bt_bitfield_read(target.c, unsigned char, s, l, &readval);
263 if (check_result(src_ull, readval, target.c, unsigned long long,
092f9aea
SM		 264 s, l, UNSIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR,
265 "%llX")) {
0675eb8c
MD		 266 return;
267 }
268 }
269 }
270 pass(UNSIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR, src_ull);
6dc2ca62
MD		 271}
272
0675eb8c 273void run_test_unsigned_read(unsigned int src_ui, unsigned long long src_ull)
6dc2ca62 274{
0675eb8c
MD		 275 unsigned int nrbits_ui, nrbits_ull, readval_ui;
276 union {
277 unsigned char c[TEST_LEN];
278 unsigned short s[TEST_LEN/sizeof(unsigned short)];
279 unsigned int i[TEST_LEN/sizeof(unsigned int)];
280 unsigned long l[TEST_LEN/sizeof(unsigned long)];
281 unsigned long long ll[TEST_LEN/sizeof(unsigned long long)];
282 } target;
283 unsigned long long readval_ull;
284 unsigned int s, l;
285
09650ea1 286 /* The number of bits needed to represent 0 is 0. */
0675eb8c
MD		 287 nrbits_ui = fls_u32(src_ui);
288
289 /* Read to unsigned integer readval output. */
290 for (s = 0; s < CHAR_BIT * TEST_LEN; s++) {
09650ea1 291 for (l = nrbits_ui; l <= (CHAR_BIT * TEST_LEN) - s; l++) {
0675eb8c
MD		 292 init_byte_array(target.c, TEST_LEN, 0xFF);
293 bt_bitfield_write(target.c, unsigned char, s, l, src_ui);
294 bt_bitfield_read(target.c, unsigned char, s, l, &readval_ui);
295 if (check_result(src_ui, readval_ui, target.c, unsigned char,
092f9aea
SM		 296 s, l, UNSIGNED_INT_READ_TEST_DESC_FMT_STR,
297 "%X")) {
0675eb8c
MD		 298 return;
299 }
300
301 init_byte_array(target.c, TEST_LEN, 0xFF);
056d0f40
MD		 302 bt_bitfield_write(target.c, unsigned char, s, l, src_ui);
303 bt_bitfield_read(target.s, unsigned short, s, l, &readval_ui);
0675eb8c 304 if (check_result(src_ui, readval_ui, target.c, unsigned short,
092f9aea
SM		 305 s, l, UNSIGNED_INT_READ_TEST_DESC_FMT_STR,
306 "%X")) {
0675eb8c
MD		 307 return;
308 }
309
310 init_byte_array(target.c, TEST_LEN, 0xFF);
056d0f40
MD		 311 bt_bitfield_write(target.c, unsigned char, s, l, src_ui);
312 bt_bitfield_read(target.i, unsigned int, s, l, &readval_ui);
0675eb8c 313 if (check_result(src_ui, readval_ui, target.c, unsigned int,
092f9aea
SM		 314 s, l, UNSIGNED_INT_READ_TEST_DESC_FMT_STR,
315 "%X")) {
0675eb8c
MD		 316 return;
317 }
318
319 init_byte_array(target.c, TEST_LEN, 0xFF);
056d0f40
MD		 320 bt_bitfield_write(target.c, unsigned char, s, l, src_ui);
321 bt_bitfield_read(target.l, unsigned long, s, l, &readval_ui);
0675eb8c 322 if (check_result(src_ui, readval_ui, target.c, unsigned long,
092f9aea
SM		 323 s, l, UNSIGNED_INT_READ_TEST_DESC_FMT_STR,
324 "%X")) {
0675eb8c
MD		 325 return;
326 }
327
328 init_byte_array(target.c, TEST_LEN, 0xFF);
056d0f40
MD		 329 bt_bitfield_write(target.c, unsigned char, s, l, src_ui);
330 bt_bitfield_read(target.ll, unsigned long long, s, l, &readval_ui);
0675eb8c 331 if (check_result(src_ui, readval_ui, target.c, unsigned long long,
092f9aea
SM		 332 s, l, UNSIGNED_INT_READ_TEST_DESC_FMT_STR,
333 "%X")) {
0675eb8c
MD		 334 return;
335 }
336 }
337 }
338 pass(UNSIGNED_INT_READ_TEST_DESC_FMT_STR, src_ui);
339
09650ea1 340 /* The number of bits needed to represent 0 is 0. */
0675eb8c
MD		 341 nrbits_ull = fls_u64(src_ull);
342
343 /* Read to unsigned long long readval output. */
344 for (s = 0; s < CHAR_BIT * TEST_LEN; s++) {
09650ea1 345 for (l = nrbits_ull; l <= (CHAR_BIT * TEST_LEN) - s; l++) {
0675eb8c
MD		 346 init_byte_array(target.c, TEST_LEN, 0xFF);
347 bt_bitfield_write(target.c, unsigned char, s, l, src_ull);
348 bt_bitfield_read(target.c, unsigned char, s, l, &readval_ull);
349 if (check_result(src_ull, readval_ull, target.c, unsigned char,
092f9aea
SM		 350 s, l, UNSIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR,
351 "%llX")) {
0675eb8c
MD		 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.s, unsigned short, s, l, &readval_ull);
0675eb8c 358 if (check_result(src_ull, readval_ull, target.c, unsigned short,
092f9aea
SM		 359 s, l, UNSIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR,
360 "%llX")) {
0675eb8c
MD		 361 return;
362 }
363
364 init_byte_array(target.c, TEST_LEN, 0xFF);
056d0f40
MD		 365 bt_bitfield_write(target.c, unsigned char, s, l, src_ull);
366 bt_bitfield_read(target.i, unsigned int, s, l, &readval_ull);
0675eb8c 367 if (check_result(src_ull, readval_ull, target.c, unsigned int,
092f9aea
SM		 368 s, l, UNSIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR,
369 "%llX")) {
0675eb8c
MD		 370 return;
371 }
372
373 init_byte_array(target.c, TEST_LEN, 0xFF);
056d0f40
MD		 374 bt_bitfield_write(target.c, unsigned char, s, l, src_ull);
375 bt_bitfield_read(target.l, unsigned long, s, l, &readval_ull);
0675eb8c 376 if (check_result(src_ull, readval_ull, target.c, unsigned long,
092f9aea
SM		 377 s, l, UNSIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR,
378 "%llX")) {
0675eb8c
MD		 379 return;
380 }
381
382 init_byte_array(target.c, TEST_LEN, 0xFF);
056d0f40
MD		 383 bt_bitfield_write(target.c, unsigned char, s, l, src_ull);
384 bt_bitfield_read(target.ll, unsigned long long, s, l, &readval_ull);
0675eb8c 385 if (check_result(src_ull, readval_ull, target.c, unsigned long long,
092f9aea
SM		 386 s, l, UNSIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR,
387 "%llX")) {
0675eb8c
MD		 388 return;
389 }
390 }
391 }
392 pass(UNSIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR, src_ull);
393}
394
395void run_test_unsigned(unsigned int src_ui, unsigned long long src_ull)
396{
397 run_test_unsigned_write(src_ui, src_ull);
398 run_test_unsigned_read(src_ui, src_ull);
399}
400
401void run_test_signed_write(int src_i, long long src_ll)
402{
3622ef51 403 unsigned int nrbits_i, nrbits_ll;
6dc2ca62 404 union {
47e0f2e2 405 signed char c[TEST_LEN];
6dc2ca62
MD		 406 short s[TEST_LEN/sizeof(short)];
407 int i[TEST_LEN/sizeof(int)];
408 long l[TEST_LEN/sizeof(long)];
409 long long ll[TEST_LEN/sizeof(long long)];
410 } target;
380d60b1 411 long long readval;
6dc2ca62 412 unsigned int s, l;
6dc2ca62 413
9d9b332b
MD		 414 if (!src_i)
415 nrbits_i = 0; /* The number of bits needed to represent 0 is 0. */
416 else if (src_i & 0x80000000U)
0675eb8c 417 nrbits_i = fls_u32(~src_i) + 1; /* Find least significant bit conveying sign */
6dc2ca62 418 else
0675eb8c 419 nrbits_i = fls_u32(src_i) + 1; /* Keep sign at 0 */
6dc2ca62 420
0675eb8c 421 /* Write from signed integer src input. */
9e8e57d0 422 for (s = 0; s < CHAR_BIT * TEST_LEN; s++) {
09650ea1 423 for (l = nrbits_i; l <= (CHAR_BIT * TEST_LEN) - s; l++) {
6dc2ca62 424 init_byte_array(target.c, TEST_LEN, 0x0);
0675eb8c 425 bt_bitfield_write(target.c, signed char, s, l, src_i);
47e0f2e2 426 bt_bitfield_read(target.c, signed char, s, l, &readval);
0675eb8c 427 if (check_result(src_i, readval, target.c, signed char,
092f9aea
SM		 428 s, l, SIGNED_INT_WRITE_TEST_DESC_FMT_STR,
429 "%llX")) {
9e8e57d0 430 return;
6dc2ca62
MD		 431 }
432
433 init_byte_array(target.c, TEST_LEN, 0x0);
0675eb8c 434 bt_bitfield_write(target.s, short, s, l, src_i);
47e0f2e2 435 bt_bitfield_read(target.c, signed char, s, l, &readval);
0675eb8c 436 if (check_result(src_i, readval, target.c, short,
092f9aea
SM		 437 s, l, SIGNED_INT_WRITE_TEST_DESC_FMT_STR,
438 "%llX")) {
9e8e57d0 439 return;
6dc2ca62
MD		 440 }
441
442 init_byte_array(target.c, TEST_LEN, 0x0);
0675eb8c 443 bt_bitfield_write(target.i, int, s, l, src_i);
47e0f2e2 444 bt_bitfield_read(target.c, signed char, s, l, &readval);
0675eb8c 445 if (check_result(src_i, readval, target.c, int,
092f9aea
SM		 446 s, l, SIGNED_INT_WRITE_TEST_DESC_FMT_STR,
447 "%llX")) {
9e8e57d0 448 return;
6dc2ca62
MD		 449 }
450
451 init_byte_array(target.c, TEST_LEN, 0x0);
0675eb8c 452 bt_bitfield_write(target.l, long, s, l, src_i);
47e0f2e2 453 bt_bitfield_read(target.c, signed char, s, l, &readval);
0675eb8c 454 if (check_result(src_i, readval, target.c, long,
092f9aea
SM		 455 s, l, SIGNED_INT_WRITE_TEST_DESC_FMT_STR,
456 "%llX")) {
9e8e57d0 457 return;
6dc2ca62
MD		 458 }
459
460 init_byte_array(target.c, TEST_LEN, 0x0);
0675eb8c 461 bt_bitfield_write(target.ll, long long, s, l, src_i);
47e0f2e2 462 bt_bitfield_read(target.c, signed char, s, l, &readval);
0675eb8c 463 if (check_result(src_i, readval, target.c, long long,
092f9aea
SM		 464 s, l, SIGNED_INT_WRITE_TEST_DESC_FMT_STR,
465 "%llX")) {
9e8e57d0 466 return;
6dc2ca62
MD		 467 }
468 }
469 }
0675eb8c
MD		 470 pass(SIGNED_INT_WRITE_TEST_DESC_FMT_STR, src_i);
471
9d9b332b
MD		 472 if (!src_ll)
473 nrbits_ll = 0; /* The number of bits needed to represent 0 is 0. */
474 else if (src_ll & 0x8000000000000000ULL)
0675eb8c
MD		 475 nrbits_ll = fls_u64(~src_ll) + 1; /* Find least significant bit conveying sign */
476 else
477 nrbits_ll = fls_u64(src_ll) + 1; /* Keep sign at 0 */
478
479 /* Write from signed long long src input. */
480 for (s = 0; s < CHAR_BIT * TEST_LEN; s++) {
09650ea1 481 for (l = nrbits_ll; l <= (CHAR_BIT * TEST_LEN) - s; l++) {
0675eb8c
MD		 482 init_byte_array(target.c, TEST_LEN, 0x0);
483 bt_bitfield_write(target.c, signed char, s, l, src_ll);
484 bt_bitfield_read(target.c, signed char, s, l, &readval);
485 if (check_result(src_ll, readval, target.c, signed char,
092f9aea
SM		 486 s, l, SIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR,
487 "%llX")) {
0675eb8c
MD		 488 return;
489 }
490
491 init_byte_array(target.c, TEST_LEN, 0x0);
492 bt_bitfield_write(target.s, short, s, l, src_ll);
493 bt_bitfield_read(target.c, signed char, s, l, &readval);
494 if (check_result(src_ll, readval, target.c, short,
092f9aea
SM		 495 s, l, SIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR,
496 "%llX")) {
0675eb8c
MD		 497 return;
498 }
499
500 init_byte_array(target.c, TEST_LEN, 0x0);
501 bt_bitfield_write(target.i, int, s, l, src_ll);
502 bt_bitfield_read(target.c, signed char, s, l, &readval);
503 if (check_result(src_ll, readval, target.c, int,
092f9aea
SM		 504 s, l, SIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR,
505 "%llX")) {
0675eb8c
MD		 506 return;
507 }
9e8e57d0 508
0675eb8c
MD		 509 init_byte_array(target.c, TEST_LEN, 0x0);
510 bt_bitfield_write(target.l, long, s, l, src_ll);
511 bt_bitfield_read(target.c, signed char, s, l, &readval);
512 if (check_result(src_ll, readval, target.c, long,
092f9aea
SM		 513 s, l, SIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR,
514 "%llX")) {
0675eb8c
MD		 515 return;
516 }
517
518 init_byte_array(target.c, TEST_LEN, 0x0);
519 bt_bitfield_write(target.ll, long long, s, l, src_ll);
520 bt_bitfield_read(target.c, signed char, s, l, &readval);
521 if (check_result(src_ll, readval, target.c, long long,
092f9aea
SM		 522 s, l, SIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR,
523 "%llX")) {
0675eb8c
MD		 524 return;
525 }
526 }
527 }
528 pass(SIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR, src_ll);
6dc2ca62
MD		 529}
530
0675eb8c 531void run_test_signed_read(int src_i, long long src_ll)
6dc2ca62 532{
3622ef51
MD		 533 unsigned int nrbits_i, nrbits_ll;
534 int readval_i;
0675eb8c
MD		 535 union {
536 unsigned char c[TEST_LEN];
537 unsigned short s[TEST_LEN/sizeof(unsigned short)];
538 unsigned int i[TEST_LEN/sizeof(unsigned int)];
539 unsigned long l[TEST_LEN/sizeof(unsigned long)];
540 unsigned long long ll[TEST_LEN/sizeof(unsigned long long)];
541 } target;
542 long long readval_ll;
543 unsigned int s, l;
6dc2ca62 544
9d9b332b
MD		 545 if (!src_i)
546 nrbits_i = 0; /* The number of bits needed to represent 0 is 0. */
547 else if (src_i & 0x80000000U)
0675eb8c
MD		 548 nrbits_i = fls_u32(~src_i) + 1; /* Find least significant bit conveying sign */
549 else
550 nrbits_i = fls_u32(src_i) + 1; /* Keep sign at 0 */
6dc2ca62 551
0675eb8c
MD		 552 /* Read to signed integer readval output. */
553 for (s = 0; s < CHAR_BIT * TEST_LEN; s++) {
09650ea1 554 for (l = nrbits_i; l <= (CHAR_BIT * TEST_LEN) - s; l++) {
0675eb8c
MD		 555 init_byte_array(target.c, TEST_LEN, 0xFF);
556 bt_bitfield_write(target.c, signed char, s, l, src_i);
557 bt_bitfield_read(target.c, signed char, s, l, &readval_i);
558 if (check_result(src_i, readval_i, target.c, signed char,
092f9aea
SM		 559 s, l, SIGNED_INT_READ_TEST_DESC_FMT_STR,
560 "%X")) {
0675eb8c
MD		 561 return;
562 }
9e8e57d0 563
0675eb8c 564 init_byte_array(target.c, TEST_LEN, 0xFF);
056d0f40
MD		 565 bt_bitfield_write(target.c, signed char, s, l, src_i);
566 bt_bitfield_read(target.s, short, s, l, &readval_i);
0675eb8c 567 if (check_result(src_i, readval_i, target.c, short,
092f9aea
SM		 568 s, l, SIGNED_INT_READ_TEST_DESC_FMT_STR,
569 "%X")) {
0675eb8c
MD		 570 return;
571 }
9e8e57d0 572
0675eb8c 573 init_byte_array(target.c, TEST_LEN, 0xFF);
056d0f40
MD		 574 bt_bitfield_write(target.c, signed char, s, l, src_i);
575 bt_bitfield_read(target.i, int, s, l, &readval_i);
0675eb8c 576 if (check_result(src_i, readval_i, target.c, int,
092f9aea
SM		 577 s, l, SIGNED_INT_READ_TEST_DESC_FMT_STR,
578 "%X")) {
0675eb8c
MD		 579 return;
580 }
9e8e57d0 581
0675eb8c 582 init_byte_array(target.c, TEST_LEN, 0xFF);
056d0f40
MD		 583 bt_bitfield_write(target.c, signed char, s, l, src_i);
584 bt_bitfield_read(target.l, long, s, l, &readval_i);
0675eb8c 585 if (check_result(src_i, readval_i, target.c, long,
092f9aea
SM		 586 s, l, SIGNED_INT_READ_TEST_DESC_FMT_STR,
587 "%X")) {
0675eb8c
MD		 588 return;
589 }
9e8e57d0 590
0675eb8c 591 init_byte_array(target.c, TEST_LEN, 0xFF);
056d0f40
MD		 592 bt_bitfield_write(target.c, signed char, s, l, src_i);
593 bt_bitfield_read(target.ll, long long, s, l, &readval_i);
0675eb8c 594 if (check_result(src_i, readval_i, target.c, long long,
092f9aea
SM		 595 s, l, SIGNED_INT_READ_TEST_DESC_FMT_STR,
596 "%X")) {
0675eb8c
MD		 597 return;
598 }
599 }
600 }
601 pass(SIGNED_INT_READ_TEST_DESC_FMT_STR, src_i);
602
9d9b332b
MD		 603 if (!src_ll)
604 nrbits_ll = 0; /* The number of bits needed to represent 0 is 0. */
0675eb8c
MD		 605 if (src_ll & 0x8000000000000000ULL)
606 nrbits_ll = fls_u64(~src_ll) + 1; /* Find least significant bit conveying sign */
607 else
608 nrbits_ll = fls_u64(src_ll) + 1; /* Keep sign at 0 */
609
610 /* Read to signed long long readval output. */
611 for (s = 0; s < CHAR_BIT * TEST_LEN; s++) {
09650ea1 612 for (l = nrbits_ll; l <= (CHAR_BIT * TEST_LEN) - s; l++) {
0675eb8c
MD		 613 init_byte_array(target.c, TEST_LEN, 0xFF);
614 bt_bitfield_write(target.c, signed char, s, l, src_ll);
615 bt_bitfield_read(target.c, signed char, s, l, &readval_ll);
616 if (check_result(src_ll, readval_ll, target.c, signed char,
092f9aea
SM		 617 s, l, SIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR,
618 "%llX")) {
0675eb8c
MD		 619 return;
620 }
621
622 init_byte_array(target.c, TEST_LEN, 0xFF);
056d0f40
MD		 623 bt_bitfield_write(target.c, signed char, s, l, src_ll);
624 bt_bitfield_read(target.s, short, s, l, &readval_ll);
0675eb8c 625 if (check_result(src_ll, readval_ll, target.c, short,
092f9aea
SM		 626 s, l, SIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR,
627 "%llX")) {
0675eb8c
MD		 628 return;
629 }
630
631 init_byte_array(target.c, TEST_LEN, 0xFF);
056d0f40
MD		 632 bt_bitfield_write(target.c, signed char, s, l, src_ll);
633 bt_bitfield_read(target.i, int, s, l, &readval_ll);
0675eb8c 634 if (check_result(src_ll, readval_ll, target.c, int,
092f9aea
SM		 635 s, l, SIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR,
636 "%llX")) {
0675eb8c
MD		 637 return;
638 }
639
640 init_byte_array(target.c, TEST_LEN, 0xFF);
056d0f40
MD		 641 bt_bitfield_write(target.c, signed char, s, l, src_ll);
642 bt_bitfield_read(target.l, long, s, l, &readval_ll);
0675eb8c 643 if (check_result(src_ll, readval_ll, target.c, long,
092f9aea
SM		 644 s, l, SIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR,
645 "%llX")) {
0675eb8c
MD		 646 return;
647 }
648
649 init_byte_array(target.c, TEST_LEN, 0xFF);
056d0f40
MD		 650 bt_bitfield_write(target.c, signed char, s, l, src_ll);
651 bt_bitfield_read(target.ll, long long, s, l, &readval_ll);
0675eb8c 652 if (check_result(src_ll, readval_ll, target.c, long long,
092f9aea
SM		 653 s, l, SIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR,
654 "%llX")) {
0675eb8c
MD		 655 return;
656 }
657 }
658 }
659 pass(SIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR, src_ll);
660}
661
662void run_test_signed(int src_i, long long src_ll)
663{
664 run_test_signed_write(src_i, src_ll);
665 run_test_signed_read(src_i, src_ll);
666}
667
668void run_test(void)
669{
670 int i;
671
672 plan_tests(NR_TESTS * 8 + 24);
673
674 srand(time(NULL));
675
676 run_test_unsigned(0, 0);
677 run_test_signed(0, 0);
678 run_test_unsigned(1, 1);
679 run_test_unsigned(~0U, ~0ULL);
680 run_test_signed(-1U, -1ULL);
681 run_test_signed(0x80000000U, 0x8000000000000000ULL);
6dc2ca62
MD		 682
683 for (i = 0; i < NR_TESTS; i++) {
0675eb8c
MD		 684 unsigned int src_ui = rand();
685 unsigned long long src_ull = ((unsigned long long) (unsigned int) rand() << 32) |
686 (unsigned long long) (unsigned int) rand();
687
688 run_test_unsigned(src_ui, src_ull);
689 run_test_signed((int) src_ui, (long long) src_ull);
6dc2ca62 690 }
6dc2ca62
MD		 691}
692
9e8e57d0
JG		 693static
694int print_encodings(unsigned long src, unsigned int shift, unsigned int len)
6dc2ca62 695{
6dc2ca62
MD		 696 union {
697 unsigned char c[8];
698 unsigned short s[4];
699 unsigned int i[2];
700 unsigned long l[2];
701 unsigned long long ll[1];
702 } target;
380d60b1 703 unsigned long long readval;
6dc2ca62 704
9e8e57d0 705 init_byte_array(target.c, 8, 0xFF);
47e0f2e2 706 bt_bitfield_write(target.c, unsigned char, shift, len, src);
6dc2ca62
MD		 707 printf("bytewise\n");
708 print_byte_array(target.c, 8);
709
9e8e57d0 710 init_byte_array(target.c, 8, 0xFF);
47e0f2e2 711 bt_bitfield_write(target.s, unsigned short, shift, len, src);
6dc2ca62
MD		 712 printf("shortwise\n");
713 print_byte_array(target.c, 8);
714
9e8e57d0 715 init_byte_array(target.c, 8, 0xFF);
47e0f2e2 716 bt_bitfield_write(target.i, unsigned int, shift, len, src);
6dc2ca62
MD		 717 printf("intwise\n");
718 print_byte_array(target.c, 8);
719
9e8e57d0 720 init_byte_array(target.c, 8, 0xFF);
47e0f2e2 721 bt_bitfield_write(target.l, unsigned long, shift, len, src);
6dc2ca62
MD		 722 printf("longwise\n");
723 print_byte_array(target.c, 8);
724
9e8e57d0 725 init_byte_array(target.c, 8, 0xFF);
47e0f2e2 726 bt_bitfield_write(target.ll, unsigned long long, shift, len, src);
6dc2ca62
MD		 727 printf("lluwise\n");
728 print_byte_array(target.c, 8);
729
47e0f2e2 730 bt_bitfield_read(target.c, unsigned char, shift, len, &readval);
6dc2ca62 731 printf("read: %llX\n", readval);
9e8e57d0 732 print_byte_array(target.c, 8);
6dc2ca62 733
9e8e57d0
JG		 734 return 0;
735}
736
737int main(int argc, char **argv)
738{
739 if (argc > 1) {
740 /* Print encodings */
741 unsigned long src;
742 unsigned int shift, len;
743
744 src = atoi(argv[1]);
745 if (argc > 2)
746 shift = atoi(argv[2]);
747 else
748 shift = 12;
749 if (argc > 3)
750 len = atoi(argv[3]);
751 else
752 len = 40;
753 return print_encodings(src, shift, len);
754 }
6dc2ca62 755
9e8e57d0
JG		 756 /* Run tap-formated tests */
757 run_test();
758 return exit_status();
6dc2ca62 759}
BabelTrace - Trace Format Babel Tower
This page took 0.098372 seconds and 4 git commands to generate.