void test_bytemap_malloc() {
// sync test_buf with byte score board after initialization
memset(test_buf, '1', 64);
// try assigning 20 bytes (24 + 8 bytes really)
void *addr20 = malloc(20);
assert_addr_equal(WORD(g_pheap) + 65, addr20);
memset(test_buf + 64, '1', 4);
assert_str_equal(test_buf, g_pheap, sizeof(test_buf));
// try assigning one byte more than the space available.
void *addr_null = malloc(HEAP_SIZE - HEAP_SIZE / WORD_SIZE - 20 + 1);
assert_equal(addr_null, NULL);
assert_str_equal(test_buf, g_pheap, sizeof(test_buf));
// try assigning 1001 bytes (1008 + 8 bytes really)
void *addr1001 = malloc(1001);
memset(test_buf + 68, '1', 127);
assert_str_equal(test_buf, g_pheap, sizeof(test_buf));
assert_addr_equal(WORD(g_pheap) + 69, addr1001);
// try get all remaining bytes
// 32, 1016, for the previous allocations.
// 512 for the byte score board, and 8 for the boundary tag.
void *add_remain = malloc(HEAP_SIZE - 32 - 1016 - 512 - 8);
memset(test_buf, '1', sizeof(test_buf));
assert_str_equal(test_buf, g_pheap, sizeof(test_buf));
assert_addr_equal(WORD(g_pheap) + 196, add_remain);
}
void test_bys_init() {
byset bs;
byset_init(&bs, NUM_WORDS, g_heap);
char expected[65] = {0};
memset(expected, '1', 64);
assert_str_equal(expected, bs.bytes, 64);
}
void test_push_pop(void)
{
queue_t q;
queue_init(&q);
queue_push(&q, "your");
queue_push(&q, "muffin");
queue_push(&q, "stink");
assert_str_equal("your", queue_pop(&q));
assert_str_equal("muffin", queue_pop(&q));
assert_str_equal("stink", queue_pop(&q));
assert_equal(NULL, queue_pop(&q));
queue_reset(&q);
}
void test_bys_set1() {
byset bs;
byset_init(&bs, NUM_WORDS, g_heap);
byset_set1(&bs, 66, 193);// 128 bytes
char expected[129] = {0};
memset(expected , '0', 2);
memset(expected + 2, '1', 126);
assert_str_equal(expected, bs.bytes + 64, 128);
}
void test_get_counter_suffix() {
char buffer[256];
char *suffix;
// test non-existant file
suffix = get_counter_suffix(buffer, sizeof(buffer), "test_data/does_not_exist", "fakehost", true);
assert_str_equal("^host.fakehost", suffix);
// test empty file
suffix = get_counter_suffix(buffer, sizeof(buffer), "test_data/empty_istatd.categories", "fakehost", true);
assert_str_equal("^host.fakehost", suffix);
// test sample file
suffix = get_counter_suffix(buffer, sizeof(buffer), "test_data/istatd.categories", "fakehost", true);
assert_str_equal("^class^trailing_ws^leading_ws^surrounded_ws^clean_me_up__por_-favor5^host.fakehost", suffix);
//Test no suffix addition
// test non-existant file
suffix = get_counter_suffix(buffer, sizeof(buffer), "test_data/does_not_exist", "fakehost", false);
assert_str_equal("", suffix);
// test empty file
suffix = get_counter_suffix(buffer, sizeof(buffer), "test_data/empty_istatd.categories", "fakehost", false);
assert_str_equal("", suffix);
// test sample file
suffix = get_counter_suffix(buffer, sizeof(buffer), "test_data/istatd.categories", "fakehost", false);
assert_str_equal("", suffix);
}
void test_bys_nrun() {
byset bs;
byset_init(&bs, NUM_WORDS, g_heap);
size_t index_not_found = byset_nrun(&bs, NUM_WORDS + 1);
assert_equal(NOT_FOUND, index_not_found);
size_t index256 = byset_nrun(&bs, 256);
assert_equal(64, index256);
byset_set0(&bs, 128, 255);
char expected[320];
memset(expected, '1', sizeof(expected));
memset(expected + 128, '0', 128);
assert_str_equal(expected, bs.bytes, sizeof(expected));
bs.bytes[255] = '1';
size_t index128 = byset_nrun(&bs, 128);
assert_equal(320, index128);
size_t index127 = byset_nrun(&bs, 127);
assert_equal(128, index127);
memset(expected, '1', sizeof(expected));
assert_str_equal(expected, bs.bytes, sizeof(expected));
}
void test_bytemap_malloc_free() {
// sync test_buf with byte score board after initialization
memset(test_buf, '1', 64);
// try assigning 20 bytes (24 + 8 bytes really)
void *addr20 = malloc(20);
assert_addr_equal(WORD(g_pheap) + 65, addr20);
memset(test_buf + 64, '1', 4);
assert_str_equal(test_buf, g_pheap, sizeof(test_buf));
// try assigning 1001 bytes (1008 + 8 bytes really)
void *addr1001 = malloc(1001);
memset(test_buf + 68, '1', 127);
assert_str_equal(test_buf, g_pheap, sizeof(test_buf));
assert_addr_equal(WORD(g_pheap) + 69, addr1001);
// freeing the first chunk
free(addr20);
memset(test_buf + 64, '0', 4);
assert_str_equal(test_buf, g_pheap, sizeof(test_buf));
// try get 7 bytes (8 + 8 bytes really)
void *addr7 = malloc(7);
memset(test_buf + 64, '1', 2);
assert_str_equal(test_buf, g_pheap, sizeof(test_buf));
assert_addr_equal(WORD(g_pheap) + 65, addr7);
// try get all remaining bytes
// 32, 1016, for the previous allocations.
// 512 for the byte score board, and 8 for the boundary tag.
void *addr_remain = malloc(HEAP_SIZE - 32 - 1016 - 512 - 8);
memset(test_buf, '1', sizeof(test_buf));
memset(test_buf + 66, '0', 2);
assert_str_equal(test_buf, g_pheap, sizeof(test_buf));
assert_addr_equal(WORD(g_pheap) + 196, addr_remain);
// free all left chunks
free(addr7);
free(addr_remain);
free(addr1001);
memset(test_buf, '0', sizeof(test_buf));
memset(test_buf, '1', 64);
assert_str_equal(test_buf, g_pheap, sizeof(test_buf));
}
void test_bytemap_init() {
// check byte score board after initialization
memset(test_buf, '1', 64);
assert_str_equal(test_buf, g_pheap, sizeof(test_buf));
}
void test_make_istatd_metric_name() {
char buffer[1024];
data_set_t ds;
value_list_t vl;
// test uninitialized value_list returns empty string
memset(&ds, 0, sizeof(ds));
memset(&vl, 0, sizeof(vl));
strcpy(buffer,"bogus");
make_istatd_metric_name(buffer, sizeof(buffer), &ds, &vl);
assert_str_equal("", buffer);
// test plugin appears in name
memset(&ds, 0, sizeof(ds));
memset(&vl, 0, sizeof(vl));
strcpy(vl.plugin, "plug");
make_istatd_metric_name(buffer, sizeof(buffer), &ds, &vl);
assert_str_equal("plug", buffer);
// test plugin_instance appears in name
memset(&ds, 0, sizeof(ds));
memset(&vl, 0, sizeof(vl));
strcpy(vl.plugin_instance, "plug_inst");
make_istatd_metric_name(buffer, sizeof(buffer), &ds, &vl);
assert_str_equal("plug_inst", buffer);
// test type appears in name
memset(&ds, 0, sizeof(ds));
memset(&vl, 0, sizeof(vl));
strcpy(ds.type, "type");
strcpy(vl.type, "type");
make_istatd_metric_name(buffer, sizeof(buffer), &ds, &vl);
assert_str_equal("type", buffer);
// test type_instance appears in name
memset(&ds, 0, sizeof(ds));
memset(&vl, 0, sizeof(vl));
strcpy(vl.type_instance, "type_inst");
make_istatd_metric_name(buffer, sizeof(buffer), &ds, &vl);
assert_str_equal("type_inst", buffer);
// test type does not appear when equal to plugin
memset(&ds, 0, sizeof(ds));
memset(&vl, 0, sizeof(vl));
strcpy(ds.type, "foo");
strcpy(vl.type, "foo");
strcpy(vl.plugin, "foo");
make_istatd_metric_name(buffer, sizeof(buffer), &ds, &vl);
assert_str_equal("foo", buffer); // is foo, not foo.foo
// test name ordering
memset(&ds, 0, sizeof(ds));
memset(&vl, 0, sizeof(vl));
strcpy(ds.type, "type");
strcpy(vl.type, "type");
strcpy(vl.plugin, "plug");
strcpy(vl.plugin_instance, "plug_inst");
strcpy(vl.type_instance, "type_inst");
make_istatd_metric_name(buffer, sizeof(buffer), &ds, &vl);
assert_str_equal("plug.plug_inst.type.type_inst", buffer);
}
void test_map_to_istatd() {
counter_suffix = "^buildbot.linu-15-14^host.linu-15-14";
char buffer[1024];
data_set_t ds;
value_list_t vl;
value_t values[3];
// test default case
values[0].counter = 9;
make_fake_data(&ds, &vl, DS_TYPE_COUNTER, "cpu", "", "idle", "", values, 1);
map_to_istatd(buffer, sizeof(buffer), &ds, &vl);
assert_str_equal("*cpu.idle^buildbot.linu-15-14^host.linu-15-14 9\n", buffer);
destroy_fake_data(&ds, &vl);
// test memcache_ps_count
values[0].gauge = 1.0;
values[1].gauge = 9.0;
make_fake_data(&ds, &vl, DS_TYPE_GAUGE, "memcached", "", "ps_count", "", values, 2);
map_to_istatd(buffer, sizeof(buffer), &ds, &vl);
assert_str_equal("memcached.ps_count^buildbot.linu-15-14^host.linu-15-14 9.000000\n", buffer);
destroy_fake_data(&ds, &vl);
// test load
values[0].gauge = 1.0;
values[1].gauge = 5.0;
values[2].gauge = 15.0;
make_fake_data(&ds, &vl, DS_TYPE_GAUGE, "load", "", "load", "", values, 3);
map_to_istatd(buffer, sizeof(buffer), &ds, &vl);
assert_str_equal("load.1min^buildbot.linu-15-14^host.linu-15-14 1.000000\n"
"load.5min^buildbot.linu-15-14^host.linu-15-14 5.000000\n"
"load.15min^buildbot.linu-15-14^host.linu-15-14 15.000000\n", buffer);
destroy_fake_data(&ds, &vl);
// test load
values[0].gauge = 1.0;
values[1].gauge = 5.0;
values[2].gauge = 15.0;
make_fake_data(&ds, &vl, DS_TYPE_GAUGE, "load", "", "load", "", values, 3);
map_to_istatd(buffer, sizeof(buffer), &ds, &vl);
assert_str_equal("load.1min^buildbot.linu-15-14^host.linu-15-14 1.000000\n"
"load.5min^buildbot.linu-15-14^host.linu-15-14 5.000000\n"
"load.15min^buildbot.linu-15-14^host.linu-15-14 15.000000\n", buffer);
destroy_fake_data(&ds, &vl);
// test network usage
values[0].derive = 1.0;
values[1].derive = 5.0;
make_fake_data(&ds, &vl, DS_TYPE_DERIVE, "interface", "eth0", "if_packets", "", values, 2);
map_to_istatd(buffer, sizeof(buffer), &ds, &vl);
assert_str_equal("*interface.eth0.if_packets.fake_data_source^buildbot.linu-15-14^host.linu-15-14 1\n"
"*interface.eth0.if_packets.fake_data_source^buildbot.linu-15-14^host.linu-15-14 5\n"
, buffer);
destroy_fake_data(&ds, &vl);
// test collectd plugins time
values[0].gauge = 1.0;
make_fake_data(&ds, &vl, DS_TYPE_GAUGE, "collectd-plugins_time", "2011-11-11T11:11:11Z", "", "", values, 3);
map_to_istatd(buffer, sizeof(buffer), &ds, &vl);
assert_str_equal("#collectd-plugins_time 2011-11-11T11:11:11Z\n", buffer);
destroy_fake_data(&ds, &vl);
// test collectd plugins dpkg
values[0].gauge = 1.0;
make_fake_data(&ds, &vl, DS_TYPE_GAUGE, "collectd-plugins_dpkg", "0.11-1", "", "", values, 3);
map_to_istatd(buffer, sizeof(buffer), &ds, &vl);
assert_str_equal("#collectd-plugins_dpkg 0.11-1\n", buffer);
destroy_fake_data(&ds, &vl);
// test collectd dpkg
values[0].gauge = 1.0;
make_fake_data(&ds, &vl, DS_TYPE_GAUGE, "collectd_dpkg", "5.0.1-0imvu1", "", "", values, 3);
map_to_istatd(buffer, sizeof(buffer), &ds, &vl);
assert_str_equal("#collectd_dpkg 5.0.1-0imvu1\n", buffer);
destroy_fake_data(&ds, &vl);
// test istatd dpkg
values[0].gauge = 1.0;
make_fake_data(&ds, &vl, DS_TYPE_GAUGE, "istatd_dpkg", "0.11-1", "", "", values, 3);
map_to_istatd(buffer, sizeof(buffer), &ds, &vl);
assert_str_equal("#istatd_dpkg 0.11-1\n", buffer);
destroy_fake_data(&ds, &vl);
}
void test_str_equal_pass() {
assert_str_equal("lorem", "lorem");
}
