void test_boe_replay_complete(void)
{
struct boe_message *msg = (void *) recv_buffer;
struct buffer *buf;
int fd;
buf = buffer_new(1024);
fd = open(DATA_PATH "replay-complete-message.bin", O_RDONLY);
fail_if(fd < 0);
fail_if(buffer_xread(buf, fd) < 0);
fail_if(boe_message_decode(buf, msg, BOE_MAX_MESSAGE_LEN) < 0);
assert_int_equals(BOE_MAGIC, msg->header.StartOfMessage);
assert_int_equals(8, msg->header.MessageLength);
assert_int_equals(ReplayComplete, msg->header.MessageType);
assert_int_equals(0, msg->header.MatchingUnit);
assert_int_equals(0, msg->header.SequenceNumber);
buffer_delete(buf);
fail_if(close(fd) < 0);
}
void basic_test() {
printf("Basic Test\n");
int data[SIZE];
int i;
for (i = 0; i < SIZE; i++) {
data[i] = i;
}
linked_array la;
la_create(&la, SIZE);
assert_true(la_is_empty(&la), "Basic Test Is Empty");
for (i = 0; i < SIZE; i++) {
assert_false(la_has_element(&la, i), "Basic Test Pre-Insertion");
la_insert(&la, i, (void *)&data[i]);
assert_true(la_has_element(&la, i), "Basic Test Post-Insertion");
assert_int_equals(data[i], *(int *)la_get_element(&la, i), "Basic Test get_element");
}
assert_false(la_is_empty(&la), "Basic Test Is Not Empty");
for (i = 0; i < SIZE; i++) {
assert_true(la_has_element(&la, i), "Basic Test Pre-Deletion");
assert_int_equals(data[i], *(int *)la_head(&la), "Basic Test Head Check");
la_remove(&la, i);
assert_false(la_has_element(&la, i), "Basic Test Post-Deletion");
}
assert_true(la_is_empty(&la), "Basic Test Is Empty Final");
}
void test_cell_add_neighbour(void)
{
printf("\ntest_cell_add_neighbour\n");
s_cell cells[4];
int c, result;
uint8_t nb_cells;
nb_cells = 3;
for (c = 0; c < 4; c++) {
init_cell(&cells[c], c, nb_cells);
}
result = cell_add_neighbour(&cells[0], &cells[1]);
assert_int_equals(result, CELL_ADD_NEIGHBOUR_OK);
assert_int_equals(cells[0].nb_neighbours, 1);
assert_int_equals(cells[1].nb_neighbours, 1);
result = cell_add_neighbour(&cells[0], &cells[1]);
assert_int_equals(result, CELL_ERROR_ALREADY_NEIGHBOUR);
assert_int_equals(cells[0].nb_neighbours, 1);
assert_int_equals(cells[1].nb_neighbours, 1);
cell_add_neighbour(&cells[0], &cells[2]);
result = cell_add_neighbour(&cells[0], &cells[3]);
assert_int_equals(result, CELL_ERROR_MAX_NEIGHBOURS_REACHED);
assert_int_equals(cells[0].nb_neighbours, nb_cells - 1);
assert_int_equals(cells[3].nb_neighbours, 0);
for (c = 0; c < 4; c++) {
free_cell(&cells[c]);
}
}
static void user_task2() {
int tid = MyTid();
assert_int_equals(child_1_tid, tid, "Basic Test: Child Check Tid");
int p_tid = MyParentTid();
assert_int_equals(parent_tid, p_tid, "Basic Test: Child Check Parent Tid");
flag = 1;
Exit();
}
void test_instruction_positions_are_computed_in_basic_block_order(void)
{
struct compilation_unit *cu = compilation_unit_alloc(&method);
struct basic_block *b1, *b2;
struct insn *insns[4];
unsigned long i;
for (i = 0; i < ARRAY_SIZE(insns); i++)
insns[i] = alloc_insn(INSN_ADD);
b1 = get_basic_block(cu, 0, ARRAY_SIZE(insns)/2);
for (i = 0 ; i < ARRAY_SIZE(insns) / 2; i++)
bb_add_insn(b1, insns[i]);
b2 = get_basic_block(cu, ARRAY_SIZE(insns) / 2, ARRAY_SIZE(insns));
for (i = ARRAY_SIZE(insns) / 2 ; i < ARRAY_SIZE(insns); i++)
bb_add_insn(b2, insns[i]);
compute_insn_positions(cu);
for (i = 0; i < ARRAY_SIZE(insns); i++)
assert_int_equals(i * 2, insns[i]->lir_pos);
free_compilation_unit(cu);
}
void test_convert_tableswitch_bbs1(void)
{
struct basic_block *bb0, *bb1, *bb2, *bb3, *bb4, *bb5, *bb6;
struct compilation_unit *cu;
struct cafebabe_method_info method_info;
struct vm_method method = {
.code_attribute.code = tableswitch1,
.code_attribute.code_length = ARRAY_SIZE(tableswitch1),
.method = &method_info,
};
memset(&method_info, 0, sizeof(method_info));
cu = compilation_unit_alloc(&method);
analyze_control_flow(cu);
convert_to_ir(cu);
assert_int_equals(7, nr_bblocks(cu));
bb0 = bb_entry(cu->bb_list.next);
bb1 = bb_entry(bb0->bb_list_node.next);
bb2 = bb_entry(bb1->bb_list_node.next);
bb3 = bb_entry(bb2->bb_list_node.next);
bb4 = bb_entry(bb3->bb_list_node.next);
bb5 = bb_entry(bb4->bb_list_node.next);
bb6 = bb_entry(bb5->bb_list_node.next);
assert_basic_block_successors((struct basic_block*[]){bb6, bb1}, 2, bb0);
assert_basic_block_successors((struct basic_block*[]){bb6, bb2}, 2, bb1);
void test_init_cell(void)
{
printf("\ntest_init_cell\n");
s_cell c;
int result;
result = init_cell(&c, 1, 4);
assert_null(c.owner);
assert_int_equals(result, 1);
assert_int_equals(c.id, 1);
assert_int_equals(c.nb_pawns, 0);
assert_int_equals(c.nb_neighbours, 0);
assert_int_equals(c.nb_max_neighbours, 3);
free_cell(&c);
}
void test_branch_opcode_ends_basic_block(void)
{
struct basic_block *bb1, *bb2, *bb3;
struct compilation_unit *cu;
struct cafebabe_method_info method_info;
struct vm_method method = {
.code_attribute.code = default_string,
.code_attribute.code_length = ARRAY_SIZE(default_string),
.method = &method_info,
};
cu = compilation_unit_alloc(&method);
analyze_control_flow(cu);
assert_int_equals(3, nr_bblocks(cu));
bb1 = bb_entry(cu->bb_list.next);
bb2 = bb_entry(bb1->bb_list_node.next);
bb3 = bb_entry(bb2->bb_list_node.next);
assert_basic_block(cu, 0, 4, bb1);
assert_basic_block(cu, 4, 7, bb2);
assert_basic_block(cu, 7, 9, bb3);
assert_basic_block_successors((struct basic_block*[]){bb2, bb3}, 2, bb1);
assert_basic_block_successors((struct basic_block*[]){bb3 }, 1, bb2);
static void user_task3() {
child_2_tid = MyTid();
int p_tid = MyParentTid();
assert_int_equals(parent_tid, p_tid, "Basic Test: Child_2 Check Parent Tid");
Exit();
}
static void user_task() {
did_run = 1;
parent_tid = MyTid();
child_1_tid = Create(MED_PRI, &user_task2);
int p_tid = MyParentTid();
assert_int_equals(-1, p_tid, "Basic Test: Parent Check Parent Tid");
Pass();
assert_int_equals(1, flag, "Basic Test: Parent Check Pass");
// Let child run first to test that the right return value is returned.
int tid = Create(HI_PRI, &user_task3);
assert_int_equals(child_2_tid, tid, "Basic Test: Parent Check Child_2 Tid");
Exit();
}
void test_cell_set_nb_pawns(void)
{
printf("\ntest_cell_set_nb_pawns\n");
s_cell c;
s_player p;
int result;
init_cell(&c, 1, 4);
init_player(&p, 1, "test", 1, STRATEGY_NONE, 10);
result = cell_set_nb_pawns(&c, 13);
assert_int_equals(result, CELL_ERROR_SET_PAWNS_NO_OWNER);
assert_int_equals(c.nb_pawns, 0);
cell_set_owner(&c, &p);
result = cell_set_nb_pawns(&c, 13);
assert_int_equals(result, CELL_ERROR_SET_PAWNS_NOT_ENOUGH_PAWNS);
assert_int_equals(c.nb_pawns, 0);
result = cell_set_nb_pawns(&c, 10);
assert_int_equals(result, CELL_SET_PAWNS_OK);
assert_int_equals(c.nb_pawns, 10);
free_cell(&c);
}
void test_honors_fixed_interval_register_constraint_for_overlapping_intervals(void)
{
struct compilation_unit *cu;
struct var_info *v1, *v2;
cu = compilation_unit_alloc(&method);
v1 = get_fixed_var(cu, R0);
v1->interval->range.start = 0;
v1->interval->range.end = 2;
v2 = get_var(cu);
v2->interval->range.start = 0;
v2->interval->range.end = 2;
allocate_registers(cu);
assert_int_equals(R0, v1->interval->reg);
assert_int_equals(R1, v2->interval->reg);
free_compilation_unit(cu);
}
void run_basic_test() {
char* name = "Basic Test";
start_test(name);
flag = 0;
did_run = 0;
kernel_add_task(MED_PRI, &user_task);
kernel_run();
assert_int_equals(1, did_run, "Basic Test: User Program Never Ran");
end_test(name);
}
void test_cell_are_neighbours(void)
{
printf("\ntest_cell_are_neighbours\n");
s_cell cells[3];
int c;
uint8_t nb_cells;
nb_cells = 3;
for (c = 0; c < 4; c++) {
init_cell(&cells[c], c, nb_cells);
}
cell_add_neighbour(&cells[0], &cells[1]);
cell_add_neighbour(&cells[1], &cells[2]);
assert_int_equals(cell_are_neighbours(&cells[0], &cells[1]), 1);
assert_int_equals(cell_are_neighbours(&cells[1], &cells[2]), 1);
assert_int_equals(cell_are_neighbours(&cells[0], &cells[2]), 0);
for (c = 0; c < 3; c++) {
free_cell(&cells[c]);
}
}
void test_cell_set_owner(void)
{
printf("\ntest_cell_set_owner\n");
s_cell c;
s_player p;
init_cell(&c, 1, 4);
init_player(&p, 1, "test", 1, STRATEGY_NONE, 10);
assert_null(c.owner);
cell_set_owner(&c, &p);
assert_str_equals(c.owner->name, "test");
assert_int_equals(c.owner->nb_cells, 1);
free_cell(&c);
}
static void set_unset_test() {
printf("Set/Unset Tests\n");
bitmask bm;
bm_create(&bm);
int bit, hi, low;
hi = 0; low = 0;
assert_int_equals(hi, bm_gethibit(&bm), "Basic Test Hi 1");
assert_int_equals(low, bm_getlowbit(&bm), "Basic Test Low 1");
bit = 5; hi = 5; low = 5;
bm_set(&bm, bit);
assert_int_equals(hi, bm_gethibit(&bm), "Basic Test Hi 1");
assert_int_equals(low, bm_getlowbit(&bm), "Basic Test Low 1");
assert_true(bm_isset(&bm, bit), "Basic Test isset 1");
bit = 10; hi = 10; low = 5;
bm_set(&bm, bit);
assert_int_equals(hi, bm_gethibit(&bm), "Basic Test Hi 2");
assert_int_equals(low, bm_getlowbit(&bm), "Basic Test Low 2");
assert_true(bm_isset(&bm, bit), "Basic Test isset 2");
bit = 7; hi = 10; low = 5;
bm_set(&bm, bit);
assert_int_equals(hi, bm_gethibit(&bm), "Basic Test Hi 3");
assert_int_equals(low, bm_getlowbit(&bm), "Basic Test Low 2");
assert_true(bm_isset(&bm, bit), "Basic Test isset 3");
bit = 5; hi = 10; low = 7;
bm_unset(&bm, bit);
assert_int_equals(hi, bm_gethibit(&bm), "Basic Test Hi 3");
assert_int_equals(low, bm_getlowbit(&bm), "Basic Test Low 2");
assert_false(bm_isset(&bm, bit), "Basic Test isset 4");
}
static void assert_emit_insn(unsigned char *expected,
unsigned long expected_size,
struct insn *insn)
{
struct basic_block *bb;
struct buffer *buf;
bb = alloc_basic_block(NULL, 0, 1);
bb_add_insn(bb, insn);
buf = alloc_buffer();
emit_body(bb, buf);
assert_int_equals(expected_size, buffer_offset(buf));
assert_mem_equals(expected, buffer_ptr(buf), expected_size);
free_basic_block(bb);
free_buffer(buf);
}
void test_mbt_quote_decode_logging_on(void)
{
struct mbt_quote_logging_on *logon;
setup();
buffer_printf(buf, "L|100=USERNAME;101=PASSWORD\n");
mbt_msg = mbt_quote_message_decode(buf);
assert_int_equals(MBT_QUOTE_LOGGING_ON, mbt_msg->Type);
logon = mbt_quote_message_payload(mbt_msg);
assert_str_equals("USERNAME", logon->UserName, 8);
assert_str_equals("PASSWORD", logon->Password, 8);
teardown();
}
void insertion_removal_test() {
printf("Insertion/Removal Test\n");
int data[SIZE];
int i;
for (i = 0; i < SIZE; i++) {
data[i] = i;
}
linked_array la;
la_create(&la, SIZE);
int pos, head;
pos = 5; head = 5;
la_insert(&la, pos, (void *)&data[head]);
assert_int_equals(data[head], *(int *)la_head(&la), "Insertion Test Head Check 1");
pos = 3; head = 3;
la_insert(&la, pos, (void *)&data[head]);
assert_int_equals(data[head], *(int *)la_head(&la), "Insertion Test Head Check 2");
pos = 4; head = 3;
la_insert(&la, pos, (void *)&data[head]);
assert_int_equals(data[head], *(int *)la_head(&la), "Insertion Test Head Check 3");
pos = 8; head = 3;
la_insert(&la, pos, (void *)&data[head]);
assert_int_equals(data[head], *(int *)la_head(&la), "Insertion Test Head Check 4");
pos = 8; head = 3;
la_remove(&la, pos);
assert_int_equals(data[head], *(int *)la_head(&la), "Insertion Test Head Check 4");
pos = 4; head = 3;
la_remove(&la, pos);
assert_int_equals(data[head], *(int *)la_head(&la), "Insertion Test Head Check 4");
pos = 3; head = 5;
la_remove(&la, pos);
assert_int_equals(data[head], *(int *)la_head(&la), "Insertion Test Head Check 4");
}
void test_init_player(void)
{
printf("\ntest_init_player\n");
s_player p1, p2, p3, p4, p5;
int result;
result = init_player(&p1, 1, "my name 1", 1, STRATEGY_NONE, 10);
assert_int_equals(result, INIT_PLAYER_OK);
assert_str_equals(p1.name, "my name 1");
assert_int_equals(p1.id, 1);
assert_int_equals(p1.nb_cells, 0);
assert_int_equals(p1.nb_pawns, 10);
assert_int_equals(p1.strategy, STRATEGY_NONE);
assert_int_equals(p1.is_human, 1);
result = init_player(&p2, 2, "my name 2", 1, STRATEGY_OFFENCE, 10);
assert_int_equals(result, PLAYER_ERROR_INIT_PLAYER_STRATEGY);
result = init_player(&p3, 3, "my name 3", 0, STRATEGY_NONE, 10);
assert_int_equals(result, PLAYER_ERROR_INIT_PLAYER_STRATEGY);
result = init_player(&p4, 4, "my name 4", 0, STRATEGY_SPREAD, 10);
assert_int_equals(result, INIT_PLAYER_OK);
assert_str_equals(p4.name, "my name 4");
assert_int_equals(p4.id, 4);
assert_int_equals(p4.nb_cells, 0);
assert_int_equals(p4.nb_pawns, 10);
assert_int_equals(p4.strategy, STRATEGY_SPREAD);
assert_int_equals(p4.is_human, 0);
//~
result = init_player(&p5, 5, "", 1, STRATEGY_NONE, 10);
assert_int_equals(result, PLAYER_ERROR_INIT_PLAYER_EMPTY_NAME);
}
void test_player_move_to_cell(void)
{
printf("\ntest_player_move_to_cell\n");
s_cell c1, c2, c3;
s_player p1, p2;
short result;
init_cell(&c1, 1, 3);
init_cell(&c2, 2, 3);
init_cell(&c3, 3, 3);
init_player(&p1, 1, "p1", 1, STRATEGY_NONE, 10);
init_player(&p2, 2, "p2", 1, STRATEGY_NONE, 10);
cell_add_neighbour(&c1, &c2);
cell_add_neighbour(&c2, &c3);
cell_set_owner(&c1, &p1);
cell_set_nb_pawns(&c1, 10);
cell_set_owner(&c3, &p2);
cell_set_nb_pawns(&c3, 10);
// test move all pawns from src cell
result = player_move_to_cell(&p1, 10, &c1, &c2);
assert_int_equals(result, PLAYER_ERROR_MOVE_ALL_PAWNS);
// test move too many pawns
result = player_move_to_cell(&p1, 11, &c1, &c2);
assert_int_equals(result, PLAYER_ERROR_MOVE_NOT_ENOUGH_PAWNS);
// test move to a cell too far away
result = player_move_to_cell(&p1, 1, &c1, &c3);
assert_int_equals(result, PLAYER_ERROR_MOVE_CELLS_NOT_NEIGHBOURS);
// move no fight
assert_int_equals(p1.nb_cells, 1);
result = player_move_to_cell(&p1, 5, &c1, &c2);
assert_int_equals(result, NO_FIGHT);
assert_int_equals(c1.nb_pawns, 5);
assert_int_equals(c2.nb_pawns, 5);
assert_int_equals(p1.nb_pawns, 10);
assert_int_equals(p1.nb_cells, 2);
assert_int_equals(c2.owner->id, p1.id);
// move fight win
result = player_move_to_cell(&p2, 6, &c3, &c2);
assert_int_equals(result, FIGHT_WON);
assert_int_equals(c3.nb_pawns, 4);
assert_int_equals(c2.nb_pawns, 6);
assert_int_equals(p2.nb_pawns, 10);
assert_int_equals(p2.nb_cells, 2);
assert_int_equals(p1.nb_pawns, 5);
assert_int_equals(p1.nb_cells, 1);
assert_int_equals(c2.owner->id, p2.id);
// move fight lose
result = player_move_to_cell(&p1, 4, &c1, &c2);
assert_int_equals(result, FIGHT_LOST);
assert_int_equals(c1.nb_pawns, 1);
assert_int_equals(c2.nb_pawns, 6);
assert_int_equals(p1.nb_pawns, 1);
assert_int_equals(p1.nb_cells, 1);
assert_int_equals(p2.nb_pawns, 10);
assert_int_equals(p2.nb_cells, 2);
assert_int_equals(c2.owner->id, p2.id);
// move fight draw
result = player_move_to_cell(&p2, 1, &c2, &c1);
assert_int_equals(result, FIGHT_DRAW);
assert_int_equals(c2.nb_pawns, 6);
assert_int_equals(c1.nb_pawns, 1);
assert_int_equals(p1.nb_pawns, 1);
assert_int_equals(p1.nb_cells, 1);
assert_int_equals(p2.nb_pawns, 10);
assert_int_equals(p2.nb_cells, 2);
assert_int_equals(c2.owner->id, p2.id);
assert_int_equals(c1.owner->id, p1.id);
free_cell(&c1);
free_cell(&c2);
free_cell(&c3);
}
void test_get_method_return_type(void)
{
assert_int_equals(J_VOID, get_method_return_type("(BCDFIJSZ)V"));
assert_int_equals(J_BYTE, get_method_return_type("(DD)B"));
assert_int_equals(J_LONG, get_method_return_type("(V)J"));
}
void test_empty_range_does_not_contain_anything(void)
{
struct live_range range = { .start = 0, .end = 0 };
assert_false(in_range(&range, 0));
assert_false(in_range(&range, 1));
}
void test_empy_range_is_empty(void)
{
struct live_range range = { .start = 0, .end = 0 };
assert_true(range_is_empty(&range));
}
void test_range_length_treats_end_as_exclusive(void)
{
struct live_range range = { .start = 0, .end = 2 };
assert_int_equals(2, range_len(&range));
}
void test_in_range_treats_end_as_exclusive(void)
{
struct live_range range = { .start = 0, .end = 2 };
assert_true(in_range(&range, 0));
assert_true(in_range(&range, 1));
assert_false(in_range(&range, 2));
}
void test_range_that_is_within_another_range_intersects(void)
{
struct live_range range1 = { .start = 0, .end = 3 };
struct live_range range2 = { .start = 1, .end = 2 };
assert_true(ranges_intersect(&range1, &range2));
assert_true(ranges_intersect(&range2, &range1));
}
void test_ranges_that_intersect(void)
{
struct live_range range1 = { .start = 0, .end = 2 };
struct live_range range2 = { .start = 1, .end = 3 };
assert_true(ranges_intersect(&range1, &range2));
assert_true(ranges_intersect(&range2, &range1));
}
void test_ranges_that_do_not_intersect(void)
{
struct live_range range1 = { .start = 0, .end = 2 };
struct live_range range2 = { .start = 2, .end = 4 };
assert_false(ranges_intersect(&range1, &range2));
assert_false(ranges_intersect(&range2, &range1));
}
void test_interval_add_range(void)
{
#if 0
struct live_interval it;
struct live_range *r;
INIT_LIST_HEAD(&it.range_list);
interval_add_range(&it, 1, 3);
r = interval_first_range(&it);
assert_int_equals(1, r->start);
assert_int_equals(3, r->end);
assert_ptr_equals(NULL, next_range(&it.range_list, r));
interval_add_range(&it, 5, 7);
r = interval_first_range(&it);
assert_int_equals(1, r->start);
assert_int_equals(3, r->end);
r = next_range(&it.range_list, r);
assert_int_equals(5, r->start);
assert_int_equals(7, r->end);
assert_ptr_equals(NULL, next_range(&it.range_list, r));
interval_add_range(&it, 3, 5);
r = interval_first_range(&it);
assert_int_equals(1, r->start);
assert_int_equals(7, r->end);
assert_ptr_equals(NULL, next_range(&it.range_list, r));
interval_add_range(&it, 7, 8);
r = interval_first_range(&it);
assert_int_equals(1, r->start);
assert_int_equals(8, r->end);
assert_ptr_equals(NULL, next_range(&it.range_list, r));
interval_add_range(&it, 10, 13);
r = interval_first_range(&it);
assert_int_equals(1, r->start);
assert_int_equals(8, r->end);
r = next_range(&it.range_list, r);
assert_int_equals(10, r->start);
assert_int_equals(13, r->end);
assert_ptr_equals(NULL, next_range(&it.range_list, r));
interval_add_range(&it, 0, 14);
r = interval_first_range(&it);
assert_int_equals(0, r->start);
assert_int_equals(14, r->end);
assert_ptr_equals(NULL, next_range(&it.range_list, r));
#endif
}
static void assert_ld_insn(enum insn_type type, enum machine_reg reg, struct stack_slot *slot, struct insn *insn)
{
assert_int_equals(type, insn->type);
assert_int_equals(reg, mach_reg(&insn->x.reg));
assert_ptr_equals(slot, insn->y.slot);
}
void test_boe_login_response(void)
{
struct boe_login_response *login;
struct boe_message *msg = (void *) recv_buffer;
struct buffer *buf;
int fd;
buf = buffer_new(1024);
fd = open(DATA_PATH "login-response-message.bin", O_RDONLY);
fail_if(fd < 0);
fail_if(buffer_xread(buf, fd) < 0);
fail_if(boe_message_decode(buf, msg, BOE_MAX_MESSAGE_LEN) < 0);
login = boe_message_payload(msg);
assert_int_equals(BOE_MAGIC, msg->header.StartOfMessage);
assert_int_equals(183, msg->header.MessageLength);
assert_int_equals(LoginResponse, msg->header.MessageType);
assert_int_equals(0, msg->header.MatchingUnit);
assert_int_equals(0, msg->header.SequenceNumber);
assert_int_equals('A', login->LoginResponseStatus);
assert_mem_equals("Accepted", login->LoginResponseText, strlen("Accepted"));
assert_int_equals(0, login->NoUnspecifiedUnitReplay);
assert_int_equals(Symbol|ClearingFirm|ClearingAccount, login->OrderAcknowledgementBitfields);
assert_int_equals(Symbol|ClearingFirm|ClearingAccount, login->OrderRejectedBitfields);
assert_int_equals(Symbol|ClearingFirm|ClearingAccount, login->OrderModifiedBitfields);
assert_int_equals(0, login->OrderRestatedBitfields);
assert_int_equals(Symbol|ClearingFirm|ClearingAccount, login->UserModifyRejectedBitfields);
assert_int_equals(0, login->OrderCancelledBitfields);
assert_int_equals(0, login->CancelRejectedBitfields);
assert_int_equals(Symbol|ClearingFirm|ClearingAccount, login->OrderExecutionBitfields);
assert_int_equals(Symbol, login->TradeCancelOrCorrectBitfields);
assert_int_equals(0, login->ReservedBitfields1);
assert_int_equals(0, login->ReservedBitfields2);
assert_int_equals(4, login->NumberOfUnits);
assert_int_equals(1, login->Units[0].UnitNumber);
assert_int_equals(113482, login->Units[0].UnitSequence);
assert_int_equals(2, login->Units[1].UnitNumber);
assert_int_equals(0, login->Units[1].UnitSequence);
assert_int_equals(3, login->Units[2].UnitNumber);
assert_int_equals(0, login->Units[2].UnitSequence);
assert_int_equals(4, login->Units[3].UnitNumber);
assert_int_equals(41337, login->Units[3].UnitSequence);
buffer_delete(buf);
fail_if(close(fd) < 0);
}
static void assert_live_range(struct live_interval *interval, unsigned long expected_start, unsigned long expected_end)
{
assert_int_equals(expected_start, interval->range.start);
assert_int_equals(expected_end, interval->range.end);
}
void test_boe_login_request(void)
{
struct boe_login_request *login;
struct boe_message *msg = (void *) recv_buffer;
struct buffer *buf;
int fd;
buf = buffer_new(1024);
fd = open(DATA_PATH "login-request-message.bin", O_RDONLY);
fail_if(fd < 0);
fail_if(buffer_xread(buf, fd) < 0);
fail_if(boe_message_decode(buf, msg, BOE_MAX_MESSAGE_LEN) < 0);
login = boe_message_payload(msg);
assert_int_equals(BOE_MAGIC, msg->header.StartOfMessage);
assert_int_equals(131, msg->header.MessageLength);
assert_int_equals(LoginRequest, msg->header.MessageType);
assert_int_equals(0, msg->header.MatchingUnit);
assert_int_equals(0, msg->header.SequenceNumber);
assert_mem_equals("0001", login->SessionSubID, ARRAY_SIZE(login->SessionSubID));
assert_mem_equals("TEST", login->Username, ARRAY_SIZE(login->Username));
assert_mem_equals("TESTING\0\0\0", login->Password, ARRAY_SIZE(login->Password));
assert_int_equals(0, login->NoUnspecifiedUnitReplay);
assert_int_equals(Symbol|ClearingFirm|ClearingAccount, login->OrderAcknowledgementBitfields);
assert_int_equals(Symbol|ClearingFirm|ClearingAccount, login->OrderRejectedBitfields);
assert_int_equals(Symbol|ClearingFirm|ClearingAccount, login->OrderModifiedBitfields);
assert_int_equals(0, login->OrderRestatedBitfields);
assert_int_equals(Symbol|ClearingFirm|ClearingAccount, login->UserModifyRejectedBitfields);
assert_int_equals(0, login->OrderCancelledBitfields);
assert_int_equals(0, login->CancelRejectedBitfields);
assert_int_equals(Symbol|ClearingFirm|ClearingAccount, login->OrderExecutionBitfields);
assert_int_equals(Symbol, login->TradeCancelOrCorrectBitfields);
assert_int_equals(0, login->ReservedBitfields1);
assert_int_equals(0, login->ReservedBitfields2);
assert_int_equals(3, login->NumberOfUnits);
assert_int_equals(1, login->Units[0].UnitNumber);
assert_int_equals(113482, login->Units[0].UnitSequence);
assert_int_equals(2, login->Units[1].UnitNumber);
assert_int_equals(0, login->Units[1].UnitSequence);
assert_int_equals(4, login->Units[2].UnitNumber);
assert_int_equals(41337, login->Units[2].UnitSequence);
buffer_delete(buf);
fail_if(close(fd) < 0);
}
void test_boe_logout(void)
{
struct boe_logout *logout;
struct boe_message *msg = (void *) recv_buffer;
struct buffer *buf;
int fd;
buf = buffer_new(1024);
fd = open(DATA_PATH "logout-message.bin", O_RDONLY);
fail_if(fd < 0);
fail_if(buffer_xread(buf, fd) < 0);
fail_if(boe_message_decode(buf, msg, BOE_MAX_MESSAGE_LEN) < 0);
logout = boe_message_payload(msg);
assert_int_equals(BOE_MAGIC, msg->header.StartOfMessage);
assert_int_equals(89, msg->header.MessageLength);
assert_int_equals(Logout, msg->header.MessageType);
assert_int_equals(0, msg->header.MatchingUnit);
assert_int_equals(0, msg->header.SequenceNumber);
assert_int_equals('U', logout->LogoutReason);
assert_mem_equals("User", logout->LogoutReasonText, 4);
assert_int_equals(103231, logout->LastReceivedSequenceNumber);
assert_int_equals(3, logout->NumberOfUnits);
assert_int_equals(1, logout->Units[0].UnitNumber);
assert_int_equals(113482, logout->Units[0].UnitSequence);
assert_int_equals(2, logout->Units[1].UnitNumber);
assert_int_equals(0, logout->Units[1].UnitSequence);
assert_int_equals(4, logout->Units[2].UnitNumber);
assert_int_equals(41337, logout->Units[2].UnitSequence);
buffer_delete(buf);
fail_if(close(fd) < 0);
}
static void assert_def_mask(int r0_set, int r1_set, int r2_set, struct insn *insn)
{
assert_int_equals(r0_set, insn_defs(insn, &r0));
assert_int_equals(r1_set, insn_defs(insn, &r1));
assert_int_equals(r2_set, insn_defs(insn, &r2));
}
static void assert_def_fixed_mask(int a_set, int c_set, int d_set, struct insn *insn)
{
assert_int_equals(a_set, insn_defs(insn, &eax));
assert_int_equals(c_set, insn_defs(insn, &ecx));
assert_int_equals(d_set, insn_defs(insn, &edx));
}
