Test(Player, look_up)
{
player_t *pl = player_create_at((vector2d_t){9, 9});
game_t *gm = game_create(20, 20, 7, 5);
cr_assert(pl);
cr_assert(gm);
game_add_team(gm, "pandas");
pl->p_teamname = strdup("pandas");
cr_assert_neq(game_register_player(gm, pl), -1);
pl->p_dir = (vector2d_t){0, -1};
board_put_resource(gm->ga_board, (vector2d_t){9, 9}, SIBUR);
board_put_resource(gm->ga_board, (vector2d_t){8, 8}, THYSTAME);
board_put_resource(gm->ga_board, (vector2d_t){9, 8}, LINEMATE);
board_put_resource(gm->ga_board, (vector2d_t){10, 8}, DERAUMERE);
board_inc_food(gm->ga_board, (vector2d_t){10, 8});
board_inc_food(gm->ga_board, (vector2d_t){10, 8});
dynbuf_t *buf = player_look(pl, gm);
cr_assert(buf);
cr_log_info(buf->b_data);
cr_assert(strstr(buf->b_data, "player"));
cr_assert_eq(count_char(buf->b_data, ','), 3);
cr_assert_str_eq(buf->b_data,
"[sibur player,thystame,linemate,food food deraumere]");
dynbuf_delete(buf);
game_delete(gm);
}
Test(Player, look_empty)
{
player_t *pl = player_create_at((vector2d_t){9, 9});
game_t *gm = game_create(20, 20, 7, 5);
cr_assert(pl);
cr_assert(gm);
game_add_team(gm, "pandas");
pl->p_teamname = strdup("pandas");
cr_assert_neq(game_register_player(gm, pl), -1);
dynbuf_t *buf = player_look(pl, gm);
cr_assert(buf);
cr_log_info(buf->b_data);
cr_assert(strstr(buf->b_data, "player"));
cr_assert_eq(count_char(buf->b_data, ','), 3);
pl->p_lvl = 2;
dynbuf_delete(buf);
buf = player_look(pl, gm);
cr_log_info(buf->b_data);
cr_assert(strstr(buf->b_data, "player"));
cr_assert_eq(count_char(buf->b_data, ','), 8);
dynbuf_delete(buf);
pl->p_lvl = 3;
buf = player_look(pl, gm);
cr_log_info(buf->b_data);
cr_assert(strstr(buf->b_data, "player"));
cr_assert_eq(count_char(buf->b_data, ','), 15);
dynbuf_delete(buf);
game_delete(gm);
}
Test(vc_management_auto, vc_alloc_simple)
{
int ret;
struct gnix_vc *vc[2];
struct gnix_fid_ep *ep_priv;
ep_priv = container_of(ep[0], struct gnix_fid_ep, ep_fid);
ret = _gnix_vc_alloc(ep_priv, gnix_addr[0], &vc[0]);
cr_assert_eq(ret, FI_SUCCESS);
ret = _gnix_vc_alloc(ep_priv, gnix_addr[1], &vc[1]);
cr_assert_eq(ret, FI_SUCCESS);
/*
* vc_id's have to be different since the
* vc's were allocated using the same ep.
*/
cr_assert_neq(vc[0]->vc_id, vc[1]->vc_id);
ret = _gnix_vc_destroy(vc[0]);
cr_assert_eq(ret, FI_SUCCESS);
ret = _gnix_vc_destroy(vc[1]);
cr_assert_eq(ret, FI_SUCCESS);
}
Test(Player, eject)
{
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, 9});
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);
pl2->p_dir = (vector2d_t){-1, 0};
player_eject(pl1, gm->ga_players, gm->ga_board);
cr_expect_eq(pl2->p_pos.v_x, 8);
cr_expect_eq(pl2->p_pos.v_y, 9);
cr_expect_eq(pl3->p_pos.v_x, 10);
cr_expect_eq(pl3->p_pos.v_y, 9);
player_eject(pl1, gm->ga_players, gm->ga_board);
cr_expect_eq(pl2->p_pos.v_x, 8);
cr_expect_eq(pl2->p_pos.v_y, 9);
cr_expect_eq(pl3->p_pos.v_x, 10);
cr_expect_eq(pl3->p_pos.v_y, 9);
player_delete(pl1);
player_delete(pl2);
player_delete(pl3);
game_delete(gm);
}
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(endpoint_info, info)
{
int ret;
hints = fi_allocinfo();
cr_assert(hints, "fi_allocinfo");
hints->domain_attr->mr_mode = GNIX_DEFAULT_MR_MODE;
hints->fabric_attr->prov_name = strdup("gni");
ret = fi_getinfo(fi_version(), NULL, 0, 0, hints, &fi);
cr_assert(!ret, "fi_getinfo");
cr_assert_eq(fi->ep_attr->type, FI_EP_RDM);
cr_assert_eq(fi->next->ep_attr->type, FI_EP_DGRAM);
cr_assert_eq(fi->next->next->ep_attr->type, FI_EP_MSG);
cr_assert_neq(fi->domain_attr->cntr_cnt, 0);
cr_assert_neq(fi->domain_attr->cq_cnt, 0);
cr_assert_eq(fi->domain_attr->ep_cnt, SIZE_MAX);
fi_freeinfo(fi);
hints->ep_attr->type = FI_EP_RDM;
ret = fi_getinfo(fi_version(), NULL, 0, 0, hints, &fi);
cr_assert(!ret, "fi_getinfo");
cr_assert_eq(fi->ep_attr->type, FI_EP_RDM);
fi_freeinfo(fi);
hints->ep_attr->type = FI_EP_DGRAM;
ret = fi_getinfo(fi_version(), NULL, 0, 0, hints, &fi);
cr_assert(!ret, "fi_getinfo");
cr_assert_eq(fi->ep_attr->type, FI_EP_DGRAM);
fi_freeinfo(fi);
fi_freeinfo(hints);
}
Test(av_bare, test_capacity)
{
int ret, i;
fi_addr_t addresses[TABLE_SIZE_FINAL];
struct fi_av_attr av_table_attr = {
.type = FI_AV_TABLE,
.count = TABLE_SIZE_INIT,
};
ret = fi_av_open(dom, &av_table_attr, &av, NULL);
cr_assert_eq(ret, FI_SUCCESS, "failed to open av");
fake_names = (struct gnix_ep_name *)calloc(TABLE_SIZE_FINAL,
sizeof(*fake_names));
cr_assert_neq(fake_names, NULL);
for (i = 0; i < TABLE_SIZE_INIT; i++) {
fake_names[i].gnix_addr.device_addr = i + 100;
fake_names[i].gnix_addr.cdm_id = i;
fake_names[i].cm_nic_cdm_id = 0xbeef;
fake_names[i].cookie = 0xdeadbeef;
}
ret = fi_av_insert(av, fake_names, TABLE_SIZE_INIT,
addresses, 0, NULL);
cr_assert_eq(ret, TABLE_SIZE_INIT, "av insert failed");
/*
* now add some more
*/
for (i = TABLE_SIZE_INIT; i < TABLE_SIZE_FINAL; i++) {
fake_names[i].gnix_addr.device_addr = i + 100;
fake_names[i].gnix_addr.cdm_id = i;
fake_names[i].cm_nic_cdm_id = 0xbeef;
fake_names[i].cookie = 0xdeadbeef;
}
ret = fi_av_insert(av, &fake_names[TABLE_SIZE_INIT],
TABLE_SIZE_FINAL - TABLE_SIZE_INIT,
&addresses[TABLE_SIZE_INIT], 0, NULL);
cr_assert_eq(ret, TABLE_SIZE_FINAL - TABLE_SIZE_INIT,
"av insert failed");
}
void *race_create_func(void *context)
{
pthread_barrier_t *barrier = (pthread_barrier_t *) context;
struct gnix_auth_key *auth_key;
int ret;
/* -1 is the single thread return value for the
thread allowed to make modifications to the barrier.
For the version of the pthread header present on our
systems, the value does not have a define. */
ret = pthread_barrier_wait(barrier);
cr_assert(ret == 0 || ret == -1, "pthread_barrier, "
"ret=%d errno=%d strerror=%s", ret, errno, strerror(errno));
auth_key = GNIX_GET_AUTH_KEY(NULL, 0);
cr_assert_neq(auth_key, NULL, "failed to get authorization key");
return NULL;
}
Test(logqueue, test_zero_diskbuf_and_normal_acks)
{
LogQueue *q;
gint i;
q = log_queue_fifo_new(OVERFLOW_SIZE, NULL);
StatsClusterKey sc_key;
stats_lock();
stats_cluster_logpipe_key_set(&sc_key, SCS_DESTINATION, q->persist_name, NULL );
stats_register_counter(0, &sc_key, SC_TYPE_QUEUED, &q->queued_messages);
stats_register_counter(1, &sc_key, SC_TYPE_MEMORY_USAGE, &q->memory_usage);
stats_unlock();
log_queue_set_use_backlog(q, TRUE);
cr_assert_eq(atomic_gssize_racy_get(&q->queued_messages->value), 0);
fed_messages = 0;
acked_messages = 0;
feed_some_messages(q, 1);
cr_assert_eq(stats_counter_get(q->queued_messages), 1);
cr_assert_neq(stats_counter_get(q->memory_usage), 0);
gint size_when_single_msg = stats_counter_get(q->memory_usage);
for (i = 0; i < 10; i++)
feed_some_messages(q, 10);
cr_assert_eq(stats_counter_get(q->queued_messages), 101);
cr_assert_eq(stats_counter_get(q->memory_usage), 101*size_when_single_msg);
send_some_messages(q, fed_messages);
log_queue_ack_backlog(q, fed_messages);
cr_assert_eq(fed_messages, acked_messages,
"did not receive enough acknowledgements: fed_messages=%d, acked_messages=%d",
fed_messages, acked_messages);
log_queue_unref(q);
}
