int sl_check_consistency(sl* list) {
return bl_check_consistency(list);
}
void test_big_list(CuTest* tc) {
// Test size_t sizes and indices of bl's.
// Test ptrdiff_t as -1 or index
CuAssertTrue(tc, -1 == BL_NOT_FOUND);
CuAssertTrue(tc, BL_NOT_FOUND < 0);
CuAssertTrue(tc, sizeof(size_t) == sizeof(ptrdiff_t));
// Create a fake list so we don't have to allocate 16 GB of list to test.
int blocksize = 1048576;
il* big = il_new(blocksize);
// that's 1<<20 ~ 1e6 elements per block
// now need 1<<12 ~ 4096 blocks to overflow a 32-bit int
int i;
int N = 4096;
bl_node* nodes = calloc(N, sizeof(bl_node));
for (i=1; i<N; i++) {
nodes[i-1].next = nodes+i;
nodes[i-1].N = blocksize;
}
nodes[N-1].N = blocksize;
big->head = nodes;
big->tail = nodes + (N-1);
big->N = (size_t)blocksize * (size_t)N;
bl_print_structure(big);
printf("N %zu\n", il_size(big));
printf("check: %s\n", (bl_check_consistency(big) ? "bad" : "ok"));
int* p = il_append(big, 42);
printf("appended: %i\n", *p);
CuAssertIntEquals(tc, 42, *p);
CuAssertTrue(tc, 4294967297L == il_size(big));
size_t index = 4294967296L;
int v = il_get(big, index);
CuAssertIntEquals(tc, 42, v);
big->last_access = NULL;
big->last_access_n = 0;
v = il_get(big, index);
CuAssertIntEquals(tc, 42, v);
for (i=0; i<blocksize*2; i++) {
il_push(big, i);
}
il* split = il_new(1024);
bl_split(big, split, (size_t)blocksize * (size_t)N);
printf("split: %zu, %zu\n", il_size(big), il_size(split));
CuAssertIntEquals(tc, 42, il_get(split, 0));
CuAssertIntEquals(tc, 3, il_get(split, 4));
il_append_list(big, split);
CuAssertTrue(tc, 4297064449L == il_size(big));
int* arr = calloc(1024, sizeof(int));
bl_copy(big, (size_t)blocksize * (size_t)N, 1024, arr);
CuAssertIntEquals(tc, 42, arr[0]);
CuAssertIntEquals(tc, 3, arr[4]);
}
int NLF(check_consistency)(nl* list) {
return bl_check_consistency(list);
}
