Test(eight, read_nine)
{
struct slist_entry *list_entry;
struct int_entry *entry;
/*
* Fill the queue. The value of each will be the counter position.
*/
for (size_t i = 0; i < 8; i++) {
list_entry = _gnix_queue_get_free(queue);
cr_expect(list_entry,
"null entry from queue get free function.");
entry = container_of(list_entry, struct int_entry, item);
entry->x = i;
_gnix_queue_enqueue(queue, &entry->item);
}
/*
* Peek and make sure the top of queue is 0.
*/
list_entry = _gnix_queue_peek(queue);
cr_expect(list_entry, "null entry from peek.");
entry = container_of(list_entry, struct int_entry, item);
cr_expect_eq(0, entry->x, "value of peek isn't first added to queue.");
/*
* Peek again and make sure it's still 0.
*/
list_entry = _gnix_queue_peek(queue);
cr_expect(list_entry, "null entry from peek.");
entry = container_of(list_entry, struct int_entry, item);
cr_expect_eq(0, entry->x, "value of peek isn't first added to queue.");
/*
* Read it back.
*/
for (size_t i = 0; i < 8; i++) {
list_entry = _gnix_queue_dequeue(queue);
cr_expect(list_entry, "null entry from queue dequeue.");
entry = container_of(list_entry, struct int_entry, item);
cr_expect_eq(i, entry->x, "value not same as assigned.");
_gnix_queue_enqueue_free(queue, &entry->item);
}
/*
* Read an extra item. Should return null.
*/
list_entry = _gnix_queue_dequeue(queue);
cr_expect(!list_entry, "entry from empty queue not null.");
}
/*
create two empty lists,
merge them into a new one,
verify that the size of the new list is 0,
verify that the new list is empty
*/
Test(listTest,mergeNewEmptyTest) {
plist l1=list_create();
plist l2=list_create();
plist l3=list_merge_new(l1,l2);
cr_expect(list_size(l3)==0);
cr_expect(list_is_empty(l3)==1);
}
/*
create two empty lists,
merge them into the first one,
verify that the size of the merged list is 0,
verify that the merged list is empty
*/
Test(listTest,mergeEmptyTest) {
plist l1=list_create();
plist l2=list_create();
list_merge(l1,l2);
cr_expect(list_size(l1)==0);
cr_expect(list_is_empty(l1)==1);
}
Test(http_loadbalancer, failed_target_is_taken_out_of_rotation)
{
HTTPLoadBalancer *lb = _construct_load_balancer();
HTTPLoadBalancerClient lbc[NUM_CLIENTS];
gint target_counts[NUM_TARGETS] = {0};
gint failing_targets = 0;
_setup_lb_clients(lb, lbc, G_N_ELEMENTS(lbc));
for (gint i = 0; i < G_N_ELEMENTS(lbc); i++)
{
HTTPLoadBalancerTarget *target = http_load_balancer_choose_target(lb, &lbc[i]);
cr_assert(target != NULL);
/* fail every second */
if (_should_fail_this_target(target))
{
http_load_balancer_set_target_failed(lb, target);
failing_targets++;
}
else
http_load_balancer_set_target_successful(lb, target);
}
/* check that our lbc's still get operational targets */
for (gint i = 0; i < G_N_ELEMENTS(lbc); i++)
{
HTTPLoadBalancerTarget *target = http_load_balancer_choose_target(lb, &lbc[i]);
cr_assert(_should_fail_this_target(target) == FALSE,
"HTTPLoadBalancer returned a target that was marked as failed, index=%d",
target->index);
cr_assert(target->state == HTTP_TARGET_OPERATIONAL);
target_counts[target->index]++;
}
/* check that we balance the load on the remaining targets properly */
for (gint i = 0; i < NUM_TARGETS; i++)
{
if (_should_fail_this_target(&lb->targets[i]))
{
cr_expect(lb->targets[i].state == HTTP_TARGET_FAILED);
}
else
{
gint expected_number_of_workers = NUM_CLIENTS / (NUM_TARGETS - failing_targets);
cr_expect(target_counts[i] - expected_number_of_workers <= 1 &&
target_counts[i] - expected_number_of_workers >= 0,
"The target %d is not balanced, expected_number_of_workers=%d, actual=%d",
i, expected_number_of_workers, target_counts[i]);
}
}
_teardown_lb_clients(lb, lbc, G_N_ELEMENTS(lbc));
http_load_balancer_free(lb);
}
Test(empty, single_write)
{
struct slist_entry *list_entry;
struct int_entry *entry;
/*
* Write single entry with value 4 to queue.
*/
list_entry = _gnix_queue_get_free(queue);
cr_expect(list_entry, "null entry from queue get free function.");
entry = container_of(list_entry, struct int_entry, item);
entry->x = 4;
_gnix_queue_enqueue(queue, &entry->item);
/*
* Read back entry with value 4.
*/
list_entry = _gnix_queue_dequeue(queue);
cr_expect(list_entry, "null entry from queue after enqueue.");
entry = container_of(list_entry, struct int_entry, item);
cr_expect_eq(4, entry->x, "entry does not contain assigned value.");
/*
* Add to free list.
*/
_gnix_queue_enqueue_free(queue, &entry->item);
/*
* Read from now empty queue.
*/
list_entry = _gnix_queue_dequeue(queue);
cr_expect(!list_entry, "entry read from empty queue is non-null.");
/*
* Read from free and make sure it's the same.
*/
list_entry = _gnix_queue_get_free(queue);
cr_expect(list_entry,
"null entry from free queue after adding to free.");
entry = container_of(list_entry, struct int_entry, item);
cr_expect_eq(4, entry->x, "entry does not contain assigned value.");
/*
* Completely empty list. Shouldn't seg fault on teardown.
*/
queue->free_item(&entry->item);
}
Test(csv_scanner, empty_input_with_no_columns)
{
const gchar *columns[] = { NULL };
csv_scanner_init(&scanner, _default_options(columns), "");
cr_expect(_column_name_unset());
cr_expect(!_scan_complete());
cr_expect(!_scan_next());
cr_expect(_column_name_unset());
cr_expect(_scan_complete());
csv_scanner_deinit(&scanner);
}
Test(empty, null_read)
{
struct slist_entry *list_entry;
list_entry = _gnix_queue_dequeue(queue);
cr_expect(!list_entry, "non null read on empty queue.");
list_entry = _gnix_queue_dequeue_free(queue);
cr_expect(!list_entry, "non null read on free list of empty queue.");
list_entry = _gnix_queue_peek(queue);
cr_expect(!list_entry, "non null peek on empty queue.");
}
Test(csv_scanner, empty_input_with_some_expected_columns)
{
const gchar *columns[] = { "foo", "bar", "baz", NULL };
csv_scanner_init(&scanner, _default_options(columns), "");
cr_expect(_column_name_equals("foo"));
cr_expect(!_scan_complete());
cr_expect(!_scan_next());
cr_expect(_column_name_equals("foo"));
cr_expect(!_scan_complete());
csv_scanner_deinit(&scanner);
}
/*
create a vector of 4 elements,
insert two true values and one false value in it,
verify that the vector contains two true values
*/
Test(simpl_infoTest,countTrueTest3) {
pbit_vect v1=BV_create(4);
BV_set(v1,0,1);
BV_set(v1,1,1);
BV_set(v1,2,0);
cr_expect(countTrue(v1)==2);
}
Test(http_loadbalancer, choose_target_balances_clients_to_targets)
{
HTTPLoadBalancer *lb = _construct_load_balancer();
HTTPLoadBalancerClient lbc[NUM_CLIENTS];
gint target_counts[NUM_TARGETS] = {0};
_setup_lb_clients(lb, lbc, G_N_ELEMENTS(lbc));
/* count number of workers on each target */
for (gint i = 0; i < G_N_ELEMENTS(lbc); i++)
{
HTTPLoadBalancerTarget *target = http_load_balancer_choose_target(lb, &lbc[i]);
target_counts[target->index]++;
}
for (gint i = 0; i < NUM_TARGETS; i++)
{
gint expected_number_of_workers = NUM_CLIENTS / NUM_TARGETS;
/* we might have one more client, if the number of workers is not
* divisible by the number of targets. The load balancer allocates
* the first couple of targets for the excess.
*/
cr_expect(target_counts[i] - expected_number_of_workers <= 1 &&
target_counts[i] - expected_number_of_workers >= 0,
"The target %d is not balanced, expected_number_of_workers=%d, actual=%d",
i, expected_number_of_workers, target_counts[i]);
}
_teardown_lb_clients(lb, lbc, G_N_ELEMENTS(lbc));
http_load_balancer_free(lb);
}
Test(gnix_hashtable_advanced, insert_8K_lookup_128K_random)
{
int ret, i, index;
gnix_test_element_t *test_elements;
gnix_test_element_t *found = NULL, *to_find = NULL;
gnix_test_element_t *item;
gnix_bitmap_t allocated = {0};
int test_size = 8 * 1024;
int bitmap_size = 64 * test_size;
int lookups = 128 * 1024;
test_elements = calloc(test_size, sizeof(gnix_test_element_t));
cr_assert(test_elements != NULL);
ret = _gnix_alloc_bitmap(&allocated, bitmap_size);
cr_assert(ret == 0);
srand(time(NULL));
for (i = 0; i < test_size; ++i) {
do {
index = rand() % bitmap_size;
} while (_gnix_test_and_set_bit(&allocated, index));
item = &test_elements[i];
item->key = index;
item->val = rand() % lookups;
item->magic = __GNIX_MAGIC_VALUE;
}
for (i = 0; i < test_size; ++i) {
item = &test_elements[i];
ret = _gnix_ht_insert(test_ht,
item->key, item);
cr_assert(ret == 0);
cr_assert(atomic_get(&test_ht->ht_elements) == (i + 1));
}
cr_assert(atomic_get(&test_ht->ht_elements) == test_size);
for (i = 0; i < lookups; ++i) {
to_find = &test_elements[rand() % test_size];
found = _gnix_ht_lookup(test_ht, to_find->key);
cr_assert(found != NULL);
cr_assert(found == to_find);
cr_assert(found->magic == __GNIX_MAGIC_VALUE);
}
ret = _gnix_free_bitmap(&allocated);
cr_expect(ret == 0);
free(test_elements);
}
Test(utils, proc)
{
int rc;
rc = _gnix_task_is_not_app();
cr_expect(rc == 0);
/* *_unassigned_cpus flags don't work on tiger */
rc = _gnix_job_enable_unassigned_cpus();
cr_expect(rc != 0);
rc = _gnix_job_disable_unassigned_cpus();
cr_expect(rc != 0);
rc = _gnix_job_enable_affinity_apply();
cr_expect(rc == 0);
rc = _gnix_job_disable_affinity_apply();
cr_expect(rc == 0);
}
static inline void
_expect_batch_size_remains_the_same_across_retries(TestThreadedDestDriver *self)
{
if (self->super.worker.instance.retries_on_error_counter > 0)
{
cr_expect(self->super.worker.instance.batch_size == self->prev_flush_size,
"batch_size has to remain the same across retries, batch_size=%d, prev_flush_size=%d",
self->super.worker.instance.batch_size, self->prev_flush_size);
}
else
self->prev_flush_size = self->super.worker.instance.batch_size;
}
Test(utils, alps)
{
int rc;
uint8_t ptag;
uint32_t cookie, fmas, cqs, npes, npr;
void *addr = NULL;
_gnix_alps_cleanup();
rc = gnixu_get_rdma_credentials(addr, &ptag, &cookie);
cr_expect(!rc);
rc = _gnix_job_fma_limit(0, ptag, &fmas);
cr_expect(!rc);
rc = _gnix_job_cq_limit(0, ptag, &cqs);
cr_expect(!rc);
rc = _gnix_pes_on_node(&npes);
cr_expect(!rc);
rc = _gnix_nics_per_rank(&npr);
cr_expect(!rc);
cqs /= GNIX_CQS_PER_EP;
cr_expect(((fmas > cqs ? cqs : fmas) / npes) == npr);
_gnix_alps_cleanup();
}
Test(Player, rite_check_tile)
{
player_t *pl1 = player_create_at((vector2d_t){9, 9});
player_t *pl2 = player_create_at((vector2d_t){9, 9});
player_t *pl3 = player_create_at((vector2d_t){9, 7});
player_t *pl4 = player_create_at((vector2d_t){9, 15});
game_t *gm = game_create(20, 20, 7, 5);
cr_assert(pl1);
cr_assert(pl2);
cr_assert(pl2);
cr_assert(gm);
game_add_team(gm, "pandas");
game_add_team(gm, "red-pandas");
pl1->p_teamname = strdup("pandas");
pl3->p_teamname = strdup("pandas");
pl2->p_teamname = strdup("red-pandas");
pl4->p_teamname = strdup("red-pandas");
cr_assert_neq(game_register_player(gm, pl1), -1);
cr_assert_neq(game_register_player(gm, pl2), -1);
cr_assert_neq(game_register_player(gm, pl3), -1);
cr_assert_neq(game_register_player(gm, pl4), -1);
board_put_resource(gm->ga_board, (vector2d_t){9, 9}, 1);
cr_expect(!player_rite_check_tile(pl1, gm));
pl2->p_pos.v_x = 19;
cr_expect(player_rite_check_tile(pl1, gm));
board_put_resource(gm->ga_board, (vector2d_t){9, 9}, 4);
cr_expect(!player_rite_check_tile(pl1, gm));
board_take_resource(gm->ga_board, (vector2d_t){9, 9}, 4);
pl1->p_lvl = 2;
pl2->p_pos.v_x = 9;
pl2->p_lvl = 2;
board_put_resource(gm->ga_board, (vector2d_t){9, 9}, 2);
board_put_resource(gm->ga_board, (vector2d_t){9, 9}, 3);
cr_expect(player_rite_check_tile(pl1, gm));
pl1->p_lvl = 42;
cr_expect(!player_rite_check_tile(pl1, gm));
}
Test(csv_scanner, partial_input)
{
const gchar *columns[] = { "foo", "bar", "baz", NULL };
csv_scanner_init(&scanner, _default_options(columns), "val1,val2");
cr_expect(_column_name_equals("foo"));
cr_expect(!_scan_complete());
cr_expect(_scan_next());
cr_expect(_column_nv_equals("foo", "val1"));
cr_expect(!_scan_complete());
cr_expect(_scan_next());
cr_expect(_column_nv_equals("bar", "val2"));
cr_expect(!_scan_complete());
cr_expect(!_scan_next());
cr_expect(_column_name_equals("baz"));
cr_expect(!_scan_complete());
/* go past the last column */
cr_expect(!_scan_next());
cr_expect(!_scan_complete());
cr_expect(_column_name_equals("baz"));
csv_scanner_deinit(&scanner);
}
Test(csv_scanner, simple_comma_separate_values)
{
const gchar *columns[] = { "foo", "bar", "baz", NULL };
csv_scanner_init(&scanner, _default_options(columns), "val1,val2,val3");
cr_expect(_column_name_equals("foo"));
cr_expect(!_scan_complete());
cr_expect(_scan_next());
cr_expect(_column_nv_equals("foo", "val1"));
cr_expect(!_scan_complete());
cr_expect(_scan_next());
cr_expect(_column_nv_equals("bar", "val2"));
cr_expect(!_scan_complete());
cr_expect(_scan_next());
cr_expect(_column_nv_equals("baz", "val3"));
cr_expect(!_scan_complete());
/* go past the last column */
cr_expect(!_scan_next());
cr_expect(_scan_complete());
cr_expect(_column_name_unset());
csv_scanner_deinit(&scanner);
}
Test(csv_scanner, greedy_column)
{
const gchar *columns[] = { "foo", "bar", NULL };
csv_scanner_init(&scanner, _default_options_with_flags(columns, CSV_SCANNER_GREEDY), "foo,bar,baz");
cr_expect(_column_name_equals("foo"));
cr_expect(!_scan_complete());
cr_expect(_scan_next());
cr_expect(_column_name_equals("foo"));
cr_expect(!_scan_complete());
cr_expect(_scan_next());
cr_expect(_column_name_equals("bar"));
cr_expect(_column_nv_equals("bar", "bar,baz"));
cr_expect(!_scan_complete());
/* go past the last column */
cr_expect(!_scan_next());
cr_expect(_scan_complete());
cr_expect(_column_name_unset());
csv_scanner_deinit(&scanner);
}
/*
create a vector of 10 elements,
verify that the vector contains zero true values
*/
Test(simpl_infoTest,countTrueTest4) {
pbit_vect v1=BV_create(10);
cr_expect(countTrue(v1)==0);
}
/*
create an empty list,
try to use the tail function on it,
verify that this will return 0
*/
Test(listTest,tailEmptyTest) {
plist l1=list_create();
cr_expect(list_tail(l1)==0);
}
/*
create an empty list,
try to use the head function on it,
verify that this will return 0
*/
Test(listTest,headEmptyTest) {
plist l1=list_create();
cr_expect(list_head(l1)==0);
}
/*
create a vector of 10 elements,
insert two true values in arbitrary positions,
verify that the vector contains two true values
*/
Test(simpl_infoTest,countTrueTest6) {
pbit_vect v1=BV_create(10);
BV_set(v1,7,1);
BV_set(v1,4,1);
cr_expect(countTrue(v1)==2);
}
/*
create an empty list,
verify that the size of the list is 0,
verify that the list is empty
*/
Test(listTest,isEmptyTest) {
plist l1=list_create();
cr_expect(list_size(l1)==0);
cr_expect(list_is_empty(l1)==1);
}
