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);
}
