void test_mempool_alloconly(void) { #define PMALLOC_MAX_COUNT 128 pool_t pool; unsigned int i, j, k; void *mem[PMALLOC_MAX_COUNT + 1]; bool success = TRUE; for (i = 0; i < 64; i++) { for (j = 1; j <= 128; j++) { pool = pool_alloconly_create(MEMPOOL_GROWING"test", i); mem[0] = p_malloc(pool, j); memset(mem[0], j, j); for (k = 1; k <= PMALLOC_MAX_COUNT; k++) { mem[k] = p_malloc(pool, k); memset(mem[k], k, k); } if (!mem_has_bytes(mem[0], j, j)) success = FALSE; for (k = 1; k <= PMALLOC_MAX_COUNT; k++) { if (!mem_has_bytes(mem[k], k, k)) success = FALSE; } pool_unref(&pool); } } test_out("mempool_alloconly", success); }
void test_end(void) { i_assert(test_prefix != NULL); test_out("", test_success); i_free_and_null(test_prefix); test_success = FALSE; }
int main() { test_for_each(); test_out(); test_cast_to_char(); test_cast_from_char(); test_operators(); return EXIT_SUCCESS; }
void UltMtgReader::unGZip(string inf, string outf) { igzstream in(inf.c_str()); ofstream test_out(outf.c_str(), std::ios::binary | std::ios::out); char c; while(in.get(c)) { test_out << c; } in.close(); test_out.close(); }
int main(void) { int *pmatched=0; int i, key; int arr0[] = {1}; int arr1[] = {1,4}; int arr2[] = {1,4,8}; int arr3[] = {1,4,8,10}; int arr4[] = {1,4,8,10,18}; int arr5[] = {1,4,8,10,18,23}; int arr6[] = {1,4,8,10,18,23,26}; for (key=0; key <= 28; key++) { printf ("--------------0--------------\n"); test_out(arr0, ARRAY_SIZE(arr0), key) printf ("--------------1--------------\n"); test_out(arr1, ARRAY_SIZE(arr1), key) printf ("--------------2--------------\n"); test_out(arr2, ARRAY_SIZE(arr2), key) printf ("--------------3--------------\n"); test_out(arr3, ARRAY_SIZE(arr3), key) printf ("--------------4--------------\n"); test_out(arr4, ARRAY_SIZE(arr4), key) printf ("--------------5--------------\n"); test_out(arr5, ARRAY_SIZE(arr5), key) printf ("--------------6--------------\n"); test_out(arr6, ARRAY_SIZE(arr6), key) } return 0; }
static void test_message_date_parse(void) { static const char *input[] = { #ifdef TIME_T_SIGNED "Thu, 01 Jan 1970 01:59:59 +0200", "Fri, 13 Dec 1901 20:45:53 +0000", #endif #if (TIME_T_MAX_BITS > 32 || !defined(TIME_T_SIGNED)) "Sun, 07 Feb 2106 06:28:15 +0000", #endif "Wed, 07 Nov 2007 01:07:20 +0200", "Wed, 07 Nov 2007 01:07:20", "Thu, 01 Jan 1970 02:00:00 +0200", "Tue, 19 Jan 2038 03:14:07 +0000", "Tue, 19 Jan 2038" }; static struct test_message_date_output output[] = { #ifdef TIME_T_SIGNED { -1, 2*60, TRUE }, { -2147483647, 0, TRUE }, #endif #if (TIME_T_MAX_BITS > 32 || !defined(TIME_T_SIGNED)) { 4294967295, 0, TRUE }, #endif { 1194390440, 2*60, TRUE }, { 1194397640, 0, TRUE }, { 0, 2*60, TRUE }, { 2147483647, 0, TRUE }, { 0, 0, FALSE } }; unsigned int i; bool success; time_t t; int tz; bool ret; for (i = 0; i < N_ELEMENTS(input); i++) { ret = message_date_parse((const unsigned char *)input[i], strlen(input[i]), &t, &tz); success = (!ret && !output[i].ret) || (ret == output[i].ret && t == output[i].time && tz == output[i].tz_offset); test_out(t_strdup_printf("message_date_parse(%d)", i), success); } }
void test_primes(void) { unsigned int i, j, num; bool success; success = primes_closest(0) > 0; for (num = 1; num < 1024; num++) { if (primes_closest(num) < num) success = FALSE; } for (i = 10; i < 32; i++) { num = (1U << i) - 100; for (j = 0; j < 200; j++, num++) { if (primes_closest(num) < num) success = FALSE; } } test_out("primes_closest()", success); }
static void test_seq_range_array_invert(void) { static const unsigned int input_min = 1, input_max = 5; static const unsigned int input[] = { 1, 2, 3, 4, 5, UINT_MAX, 2, 3, 4, UINT_MAX, 1, 2, 4, 5, UINT_MAX, 1, 3, 5, UINT_MAX, 1, UINT_MAX, 5, UINT_MAX, UINT_MAX }; ARRAY_TYPE(seq_range) range = ARRAY_INIT; unsigned int i, j, seq, start, num; bool old_exists, success; for (i = num = 0; input[i] != UINT_MAX; num++, i++) { success = TRUE; start = i; for (; input[i] != UINT_MAX; i++) { seq_range_array_add_with_init(&range, 32, input[i]); for (j = start; j < i; j++) { if (!seq_range_exists(&range, input[j])) success = FALSE; } } seq_range_array_invert(&range, input_min, input_max); for (seq = input_min; seq <= input_max; seq++) { for (j = start; input[j] != UINT_MAX; j++) { if (input[j] == seq) break; } old_exists = input[j] != UINT_MAX; if (seq_range_exists(&range, seq) == old_exists) success = FALSE; } test_out(t_strdup_printf("seq_range_array_invert(%u)", num), success); array_free(&range); } }
static void test_net_is_in_network(void) { static struct test_net_is_in_network_input input[] = { { "1.2.3.4", "1.2.3.4", 32, TRUE }, { "1.2.3.4", "1.2.3.3", 32, FALSE }, { "1.2.3.4", "1.2.3.5", 32, FALSE }, { "1.2.3.4", "1.2.2.4", 32, FALSE }, { "1.2.3.4", "1.1.3.4", 32, FALSE }, { "1.2.3.4", "0.2.3.4", 32, FALSE }, { "1.2.3.253", "1.2.3.254", 31, FALSE }, { "1.2.3.254", "1.2.3.254", 31, TRUE }, { "1.2.3.255", "1.2.3.254", 31, TRUE }, { "1.2.3.255", "1.2.3.0", 24, TRUE }, { "1.2.255.255", "1.2.254.0", 23, TRUE }, { "255.255.255.255", "128.0.0.0", 1, TRUE }, { "255.255.255.255", "127.0.0.0", 1, FALSE } #ifdef HAVE_IPV6 , { "1234:5678::abcf", "1234:5678::abce", 127, TRUE }, { "1234:5678::abcd", "1234:5678::abce", 127, FALSE }, { "123e::ffff", "123e::0", 15, TRUE }, { "123d::ffff", "123e::0", 15, FALSE } #endif }; struct ip_addr ip, net_ip; unsigned int i; bool success; test_begin("net_is_in_network()"); for (i = 0; i < N_ELEMENTS(input); i++) { test_assert(net_addr2ip(input[i].ip, &ip) == 0); test_assert(net_addr2ip(input[i].net, &net_ip) == 0); success = net_is_in_network(&ip, &net_ip, input[i].bits) == input[i].ret; test_out(t_strdup_printf("net_is_in_network(%u)", i), success); } test_end(); }
void test_bsearch_insert_pos(void) { static const unsigned int input[] = { 1, 5, 9, 15, 16, -1, 1, 5, 9, 15, 16, 17, -1, -1 }; static const unsigned int max_key = 18; const unsigned int *cur; unsigned int key, len, i, idx; bool success; cur = input; for (i = 0; cur[0] != -1U; i++) { for (len = 0; cur[len] != -1U; len++) ; for (key = 0; key < max_key; key++) { if (bsearch_insert_pos(&key, cur, len, sizeof(*cur), cmp_uint, &idx)) success = cur[idx] == key; else if (idx == 0) success = cur[0] > key; else if (idx == len) success = cur[len-1] < key; else { success = cur[idx-1] < key && cur[idx+1] > key; } if (!success) break; } cur += len + 1; test_out(t_strdup_printf("bsearch_insert_pos(%d,%d)", i, key), success); } }
static void test_seq_range_array_random(void) { #define SEQ_RANGE_TEST_BUFSIZE 20 #define SEQ_RANGE_TEST_COUNT 10000 unsigned char shadowbuf[SEQ_RANGE_TEST_BUFSIZE]; ARRAY_TYPE(seq_range) range; const struct seq_range *seqs; uint32_t seq1, seq2; unsigned int i, j, ret, ret2, count; int test = -1; ret = ret2 = 0; i_array_init(&range, 1); memset(shadowbuf, 0, sizeof(shadowbuf)); for (i = 0; i < SEQ_RANGE_TEST_COUNT; i++) { seq1 = rand() % SEQ_RANGE_TEST_BUFSIZE; seq2 = seq1 + rand() % (SEQ_RANGE_TEST_BUFSIZE - seq1); test = rand() % 4; switch (test) { case 0: seq_range_array_add(&range, seq1); shadowbuf[seq1] = 1; break; case 1: seq_range_array_add_range(&range, seq1, seq2); memset(shadowbuf + seq1, 1, seq2 - seq1 + 1); break; case 2: ret = seq_range_array_remove(&range, seq1) ? 1 : 0; ret2 = shadowbuf[seq1] != 0 ? 1 : 0; shadowbuf[seq1] = 0; break; case 3: ret = seq_range_array_remove_range(&range, seq1, seq2); for (ret2 = 0; seq1 <= seq2; seq1++) { if (shadowbuf[seq1] != 0) { ret2++; shadowbuf[seq1] = 0; } } break; } if (ret != ret2) break; seqs = array_get(&range, &count); for (j = 0, seq1 = 0; j < count; j++) { if (j > 0 && seqs[j-1].seq2+1 >= seqs[j].seq1) goto fail; for (; seq1 < seqs[j].seq1; seq1++) { if (shadowbuf[seq1] != 0) goto fail; } for (; seq1 <= seqs[j].seq2; seq1++) { if (shadowbuf[seq1] == 0) goto fail; } } i_assert(seq1 <= SEQ_RANGE_TEST_BUFSIZE); for (; seq1 < SEQ_RANGE_TEST_BUFSIZE; seq1++) { if (shadowbuf[seq1] != 0) goto fail; } } fail: if (i == SEQ_RANGE_TEST_COUNT) test_out("seq_range_array random", TRUE); else { test_out_reason("seq_range_array random", FALSE, t_strdup_printf("round %u test %d failed", i, test)); } }
void test_buffer(void) { #define BUF_TEST_SIZE (1024*2) #define BUF_TEST_COUNT 1000 buffer_t *buf; unsigned char *p, testdata[BUF_TEST_SIZE], shadowbuf[BUF_TEST_SIZE]; unsigned int i, shadowbuf_size; size_t pos, pos2, size; int test = -1; bool zero; buf = buffer_create_dynamic(default_pool, 1); for (i = 0; i < BUF_TEST_SIZE; i++) testdata[i] = random(); memset(shadowbuf, 0, sizeof(shadowbuf)); srand(1); shadowbuf_size = 0; for (i = 0; i < BUF_TEST_COUNT; i++) { if (buf->used == BUF_TEST_SIZE) { size = shadowbuf_size = rand() % (buf->used - 1); buffer_set_used_size(buf, size); memset(shadowbuf + shadowbuf_size, 0, BUF_TEST_SIZE - shadowbuf_size); i_assert(buf->used < BUF_TEST_SIZE); } test = rand() % 6; zero = rand() % 10 == 0; switch (test) { case 0: pos = rand() % (BUF_TEST_SIZE-1); size = rand() % (BUF_TEST_SIZE - pos); if (!zero) { buffer_write(buf, pos, testdata, size); memcpy(shadowbuf + pos, testdata, size); } else { buffer_write_zero(buf, pos, size); memset(shadowbuf + pos, 0, size); } if (pos + size > shadowbuf_size) shadowbuf_size = pos + size; break; case 1: size = rand() % (BUF_TEST_SIZE - buf->used); if (!zero) { buffer_append(buf, testdata, size); memcpy(shadowbuf + shadowbuf_size, testdata, size); } else { buffer_append_zero(buf, size); memset(shadowbuf + shadowbuf_size, 0, size); } shadowbuf_size += size; break; case 2: pos = rand() % (BUF_TEST_SIZE-1); size = rand() % (BUF_TEST_SIZE - I_MAX(buf->used, pos)); if (!zero) { buffer_insert(buf, pos, testdata, size); memmove(shadowbuf + pos + size, shadowbuf + pos, BUF_TEST_SIZE - (pos + size)); memcpy(shadowbuf + pos, testdata, size); } else { buffer_insert_zero(buf, pos, size); memmove(shadowbuf + pos + size, shadowbuf + pos, BUF_TEST_SIZE - (pos + size)); memset(shadowbuf + pos, 0, size); } if (pos < shadowbuf_size) shadowbuf_size += size; else shadowbuf_size = pos + size; break; case 3: pos = rand() % (BUF_TEST_SIZE-1); size = rand() % (BUF_TEST_SIZE - pos); buffer_delete(buf, pos, size); if (pos < shadowbuf_size) { if (pos + size > shadowbuf_size) size = shadowbuf_size - pos; memmove(shadowbuf + pos, shadowbuf + pos + size, BUF_TEST_SIZE - (pos + size)); shadowbuf_size -= size; memset(shadowbuf + shadowbuf_size, 0, BUF_TEST_SIZE - shadowbuf_size); } break; case 4: if (shadowbuf_size == 0) break; pos = rand() % (shadowbuf_size-1); /* dest */ pos2 = rand() % (shadowbuf_size-1); /* source */ size = rand() % (shadowbuf_size - I_MAX(pos, pos2)); buffer_copy(buf, pos, buf, pos2, size); memmove(shadowbuf + pos, shadowbuf + pos2, size); if (pos > pos2 && pos + size > shadowbuf_size) shadowbuf_size = pos + size; break; case 5: pos = rand() % (BUF_TEST_SIZE-1); size = rand() % (BUF_TEST_SIZE - pos); p = buffer_get_space_unsafe(buf, pos, size); memcpy(p, testdata, size); memcpy(shadowbuf + pos, testdata, size); if (pos + size > shadowbuf_size) shadowbuf_size = pos + size; break; } i_assert(shadowbuf_size <= BUF_TEST_SIZE); if (buf->used != shadowbuf_size || memcmp(buf->data, shadowbuf, buf->used) != 0) break; } if (i == BUF_TEST_COUNT) test_out("buffer", TRUE); else { test_out_reason("buffer", FALSE, t_strdup_printf("round %u test %d failed", i, test)); } buffer_free(&buf); }