static ph_counter_scope_t *resolve_facility(const char *fac)
{
ph_counter_scope_t *scope;
scope = ph_counter_scope_resolve(memory_scope, fac);
if (scope) {
return scope;
}
return ph_counter_scope_define(memory_scope, fac, 0);
}
static void basicCounterFunctionality(void)
{
ph_counter_scope_t *scope;
scope = ph_counter_scope_define(NULL, "test1", 24);
is_true(scope != NULL);
is_string("test1", ph_counter_scope_get_name(scope));
uint8_t slot = ph_counter_scope_register_counter(scope, "dummy");
is(0, slot);
ph_counter_scope_add(scope, slot, 1);
is(1, ph_counter_scope_get(scope, slot));
ph_counter_scope_add(scope, slot, 1);
is(2, ph_counter_scope_get(scope, slot));
ph_counter_scope_add(scope, slot, 3);
is(5, ph_counter_scope_get(scope, slot));
/* register some more slots */
const char *names[2] = {"sent", "recd"};
is_true(ph_counter_scope_register_counter_block(
scope, 2, slot + 1, names));
ph_counter_block_t *block = ph_counter_block_open(scope);
is_true(block != NULL);
ph_counter_block_add(block, slot + 1, 3);
is(3, ph_counter_scope_get(scope, slot + 1));
// C++, clogging up code with casts since the last century
uint8_t bulk_slots[2] = { (uint8_t)(slot + 1), (uint8_t)(slot + 2) };
int64_t values[2] = { 1, 5 };
ph_counter_block_bulk_add(block, 2, bulk_slots, values);
is(4, ph_counter_scope_get(scope, slot + 1));
is(5, ph_counter_scope_get(scope, slot + 2));
uint8_t num_slots;
int64_t view_slots[10];
const char *view_names[10];
num_slots = ph_counter_scope_get_view(scope, 10, view_slots, view_names);
is(3, num_slots);
is(5, view_slots[0]);
is(4, view_slots[1]);
is(5, view_slots[2]);
is_string("dummy", view_names[0]);
is_string("sent", view_names[1]);
is_string("recd", view_names[2]);
ph_counter_scope_t *kid_scope;
// Verify that attempting to define the same scope twice fails
kid_scope = ph_counter_scope_define(NULL, "test1", 24);
is_true(kid_scope == NULL);
// Get ourselves a real child
kid_scope = ph_counter_scope_define(scope, "child", 8);
is_true(kid_scope != NULL);
is_string("test1.child",
ph_counter_scope_get_name(kid_scope));
ph_counter_scope_t *resolved;
resolved = ph_counter_scope_resolve(NULL, "test1");
is(scope, resolved);
resolved = ph_counter_scope_resolve(NULL, "test1.child");
is(kid_scope, resolved);
ph_counter_scope_register_counter(kid_scope, "w00t");
// Test iteration
struct counter_name_val counter_data[16];
int n_counters = 0;
ph_counter_scope_iterator_t iter;
// Collect all counter data; it is returned in an undefined order.
// For the sake of testing we want to order it, so we collect the data
// and then sort it
ph_counter_scope_iterator_init(&iter);
ph_counter_scope_t *iter_scope;
while ((iter_scope = ph_counter_scope_iterator_next(&iter)) != NULL) {
int i;
if (strncmp(ph_counter_scope_get_name(iter_scope), "test1", 5)) {
continue;
}
num_slots = ph_counter_scope_get_view(iter_scope, 10,
view_slots, view_names);
for (i = 0; i < num_slots; i++) {
counter_data[n_counters].scope_name =
ph_counter_scope_get_name(iter_scope);
counter_data[n_counters].name = view_names[i];
counter_data[n_counters].val = view_slots[i];
n_counters++;
}
ph_counter_scope_delref(iter_scope);
}
qsort(counter_data, n_counters, sizeof(struct counter_name_val),
compare_counter_name_val);
struct counter_name_val expected_data[] = {
{ "test1", "dummy", 5 },
{ "test1", "recd", 5 },
{ "test1", "sent", 4 },
{ "test1.child", "w00t", 0 },
};
int num_expected = sizeof(expected_data) / sizeof(expected_data[0]);
is_int(num_expected, n_counters);
for (int i = 0; i < n_counters; i++) {
is_string(expected_data[i].scope_name,
counter_data[i].scope_name);
is_string(expected_data[i].name,
counter_data[i].name);
is(expected_data[i].val, counter_data[i].val);
diag("%s.%s = %" PRIi64, counter_data[i].scope_name,
counter_data[i].name, counter_data[i].val);
}
}
