static void test_bigend_u64(TestBatch *batch) { size_t count = 32; uint64_t *ints = TestUtils_random_u64s(NULL, count, 0, U64_MAX); size_t amount = (count + 1) * sizeof(uint64_t); char *allocated = (char*)CALLOCATE(amount, sizeof(char)); char *encoded = allocated + 1; // Intentionally misaligned. char *target = encoded; for (size_t i = 0; i < count; i++) { NumUtil_encode_bigend_u64(ints[i], &target); target += sizeof(uint64_t); } target = encoded; for (size_t i = 0; i < count; i++) { uint64_t got = NumUtil_decode_bigend_u64(target); TEST_TRUE(batch, got == ints[i], "bigend u64"); target += sizeof(uint64_t); } target = encoded; NumUtil_encode_bigend_u64(1, &target); TEST_INT_EQ(batch, encoded[0], 0, "Truly big-endian"); TEST_INT_EQ(batch, encoded[7], 1, "Truly big-endian"); FREEMEM(allocated); FREEMEM(ints); }
static void test_u1(TestBatch *batch) { size_t count = 64; uint64_t *ints = TestUtils_random_u64s(NULL, count, 0, 2); size_t amount = count / 8; uint8_t *bits = (uint8_t*)CALLOCATE(amount, sizeof(uint8_t)); for (size_t i = 0; i < count; i++) { if (ints[i]) { NumUtil_u1set(bits, i); } } for (size_t i = 0; i < count; i++) { TEST_INT_EQ(batch, NumUtil_u1get(bits, i), (long)ints[i], "u1 set/get"); } for (size_t i = 0; i < count; i++) { NumUtil_u1flip(bits, i); } for (size_t i = 0; i < count; i++) { TEST_INT_EQ(batch, NumUtil_u1get(bits, i), !ints[i], "u1 flip"); } FREEMEM(bits); FREEMEM(ints); }
static void test_To_Array(TestBatch *batch) { uint64_t *source_ints = TestUtils_random_u64s(NULL, 20, 0, 200); BitVector *bit_vec = BitVec_new(0); I32Array *array; long num_unique = 0; long i; // Unique the random ints. Sort_quicksort(source_ints, 20, sizeof(uint64_t), S_compare_u64s, NULL); for (i = 0; i < 19; i++) { if (source_ints[i] != source_ints[i + 1]) { source_ints[num_unique] = source_ints[i]; num_unique++; } } // Set bits. for (i = 0; i < num_unique; i++) { BitVec_Set(bit_vec, (uint32_t)source_ints[i]); } // Create the array and compare it to the source. array = BitVec_To_Array(bit_vec); for (i = 0; i < num_unique; i++) { if (I32Arr_Get(array, i) != (int32_t)source_ints[i]) { break; } } TEST_INT_EQ(batch, i, num_unique, "To_Array (%ld == %ld)", i, num_unique); DECREF(array); DECREF(bit_vec); FREEMEM(source_ints); }
static void test_bigend_u32(TestBatchRunner *runner) { size_t count = 32; uint64_t *ints = TestUtils_random_u64s(NULL, count, 0, UINT64_C(1) + UINT32_MAX); size_t amount = (count + 1) * sizeof(uint32_t); char *allocated = (char*)CALLOCATE(amount, sizeof(char)); char *encoded = allocated + 1; // Intentionally misaligned. char *target = encoded; for (size_t i = 0; i < count; i++) { NumUtil_encode_bigend_u32((uint32_t)ints[i], &target); target += sizeof(uint32_t); } target = encoded; for (size_t i = 0; i < count; i++) { uint32_t got = NumUtil_decode_bigend_u32(target); TEST_INT_EQ(runner, got, (long)ints[i], "bigend u32"); target += sizeof(uint32_t); } target = encoded; NumUtil_encode_bigend_u32(1, &target); TEST_INT_EQ(runner, encoded[0], 0, "Truly big-endian u32"); TEST_INT_EQ(runner, encoded[3], 1, "Truly big-endian u32"); FREEMEM(allocated); FREEMEM(ints); }
static void test_To_Array(TestBatchRunner *runner) { uint64_t *source_ints = TestUtils_random_u64s(NULL, 20, 0, 200); BitVector *bit_vec = BitVec_new(0); I32Array *array; unsigned num_unique = 0; // Unique the random ints. qsort(source_ints, 20, sizeof(uint64_t), S_compare_u64s); for (unsigned i = 0; i < 19; i++) { if (source_ints[i] != source_ints[i + 1]) { source_ints[num_unique] = source_ints[i]; num_unique++; } } // Set bits. for (unsigned i = 0; i < num_unique; i++) { BitVec_Set(bit_vec, (size_t)source_ints[i]); } // Create the array and compare it to the source. array = BitVec_To_Array(bit_vec); unsigned i; for (i = 0; i < num_unique; i++) { if (I32Arr_Get(array, (size_t)i) != (int32_t)source_ints[i]) { break; } } TEST_UINT_EQ(runner, i, num_unique, "To_Array (%u == %u)", i, num_unique); DECREF(array); DECREF(bit_vec); FREEMEM(source_ints); }
static void test_c32(TestBatch *batch) { uint64_t mins[] = { 0, 0x4000 - 100, (uint32_t)I32_MAX - 100, U32_MAX - 10 }; uint64_t limits[] = { 500, 0x4000 + 100, (uint32_t)I32_MAX + 100, U32_MAX }; uint32_t set_num; uint32_t num_sets = sizeof(mins) / sizeof(uint64_t); size_t count = 64; uint64_t *ints = NULL; size_t amount = count * C32_MAX_BYTES; char *encoded = (char*)CALLOCATE(amount, sizeof(char)); char *target = encoded; char *limit = target + amount; for (set_num = 0; set_num < num_sets; set_num++) { char *skip; ints = TestUtils_random_u64s(ints, count, mins[set_num], limits[set_num]); target = encoded; for (size_t i = 0; i < count; i++) { NumUtil_encode_c32((uint32_t)ints[i], &target); } target = encoded; skip = encoded; for (size_t i = 0; i < count; i++) { TEST_INT_EQ(batch, NumUtil_decode_c32(&target), (long)ints[i], "c32 %lu", (long)ints[i]); NumUtil_skip_cint(&skip); if (target > limit) { THROW(ERR, "overrun"); } } TEST_TRUE(batch, skip == target, "skip %lu == %lu", (unsigned long)skip, (unsigned long)target); target = encoded; for (size_t i = 0; i < count; i++) { NumUtil_encode_padded_c32((uint32_t)ints[i], &target); } TEST_TRUE(batch, target == limit, "padded c32 uses 5 bytes (%lu == %lu)", (unsigned long)target, (unsigned long)limit); target = encoded; skip = encoded; for (size_t i = 0; i < count; i++) { TEST_INT_EQ(batch, NumUtil_decode_c32(&target), (long)ints[i], "padded c32 %lu", (long)ints[i]); NumUtil_skip_cint(&skip); if (target > limit) { THROW(ERR, "overrun"); } } TEST_TRUE(batch, skip == target, "skip padded %lu == %lu", (unsigned long)skip, (unsigned long)target); } target = encoded; NumUtil_encode_c32(U32_MAX, &target); target = encoded; TEST_INT_EQ(batch, NumUtil_decode_c32(&target), U32_MAX, "c32 U32_MAX"); FREEMEM(encoded); FREEMEM(ints); }
static void test_u4(TestBatch *batch) { size_t count = 128; uint64_t *ints = TestUtils_random_u64s(NULL, count, 0, 16); uint8_t *bits = (uint8_t*)CALLOCATE((count / 2), sizeof(uint8_t)); for (size_t i = 0; i < count; i++) { NumUtil_u4set(bits, i, (uint8_t)ints[i]); } for (size_t i = 0; i < count; i++) { TEST_INT_EQ(batch, NumUtil_u4get(bits, i), (long)ints[i], "u4"); } FREEMEM(bits); FREEMEM(ints); }
static void test_u2(TestBatchRunner *runner) { size_t count = 32; uint64_t *ints = TestUtils_random_u64s(NULL, count, 0, 4); uint8_t *bits = (uint8_t*)CALLOCATE((count / 4), sizeof(uint8_t)); for (size_t i = 0; i < count; i++) { NumUtil_u2set(bits, i, (uint8_t)ints[i]); } for (size_t i = 0; i < count; i++) { TEST_INT_EQ(runner, NumUtil_u2get(bits, i), (long)ints[i], "u2"); } FREEMEM(bits); FREEMEM(ints); }
static void test_c64(TestBatch *batch) { uint64_t mins[] = { 0, 0x4000 - 100, (uint64_t)U32_MAX - 100, U64_MAX - 10 }; uint64_t limits[] = { 500, 0x4000 + 100, (uint64_t)U32_MAX + 1000, U64_MAX }; uint32_t set_num; uint32_t num_sets = sizeof(mins) / sizeof(uint64_t); size_t count = 64; uint64_t *ints = NULL; size_t amount = count * C64_MAX_BYTES; char *encoded = (char*)CALLOCATE(amount, sizeof(char)); char *target = encoded; char *limit = target + amount; for (set_num = 0; set_num < num_sets; set_num++) { char *skip; ints = TestUtils_random_u64s(ints, count, mins[set_num], limits[set_num]); target = encoded; for (size_t i = 0; i < count; i++) { NumUtil_encode_c64(ints[i], &target); } target = encoded; skip = encoded; for (size_t i = 0; i < count; i++) { uint64_t got = NumUtil_decode_c64(&target); TEST_TRUE(batch, got == ints[i], "c64 %" U64P " == %" U64P, got, ints[i]); if (target > limit) { THROW(ERR, "overrun"); } NumUtil_skip_cint(&skip); } TEST_TRUE(batch, skip == target, "skip %lu == %lu", (unsigned long)skip, (unsigned long)target); } target = encoded; NumUtil_encode_c64(U64_MAX, &target); target = encoded; uint64_t got = NumUtil_decode_c64(&target); TEST_TRUE(batch, got == U64_MAX, "c64 U64_MAX"); FREEMEM(encoded); FREEMEM(ints); }