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