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);
}
static void assert_emit_call(long target_offset)
{
unsigned char expected[5];
struct basic_block *bb;
struct buffer *buf;
void *call_target;
long disp;
buf = alloc_buffer();
call_target = buffer_ptr(buf) + target_offset;
disp = call_target - buffer_ptr(buf) - 5;
expected[0] = 0xe8;
expected[1] = (disp & 0x000000ffUL);
expected[2] = (disp & 0x0000ff00UL) >> 8;
expected[3] = (disp & 0x00ff0000UL) >> 16;
expected[4] = (disp & 0xff000000UL) >> 24;
bb = alloc_basic_block(NULL, 0, 1);
bb_add_insn(bb, rel_insn(INSN_CALL_REL, (unsigned long) call_target));
emit_body(bb, buf);
assert_mem_equals(expected, buffer_ptr(buf), ARRAY_SIZE(expected));
free_basic_block(bb);
free_buffer(buf);
}
void write_at_processes_wrote_correct_bytes_into_overlapping_parts() {
int rank = get_rank(global_context->communicator);
int comm_size = get_comm_size();
MPI_File file;
int result = MPI_File_open_pmem(global_context->communicator, global_context->file_path, MPI_MODE_RDWR, create_mpi_info(), &file);
assert_true(result == MPI_SUCCESS, "MPI_File_open_pmem returned with error");
int location_modifier = strlen(TEXT_TO_WRITE) / get_comm_size() / 2;
for (int i=0; i<comm_size; i++) {
if (rank == i) {
result = MPI_File_write_at_pmem(file, rank * location_modifier, TEXT_TO_WRITE, strlen(TEXT_TO_WRITE), MPI_CHAR, MPI_STATUS_IGNORE);
assert_true(result == MPI_SUCCESS, "MPI_File_write_at_pmem returned with error");
}
MPI_Barrier(global_context->communicator);
}
result = MPI_File_close_pmem(&file);
assert_true(result == MPI_SUCCESS, "MPI_File_close_pmem returned with error");
if (rank == 0) {
assert_true(get_file_size() == global_context->file_size, "File changed its size after read/write operations");
char* final_text = (char*) malloc(strlen(TEXT_TO_WRITE) * get_comm_size());
for (int i=0; i<get_comm_size(); i++) {
strcpy(final_text + i * location_modifier, TEXT_TO_WRITE);
}
char* c_read_result = c_read_at(0, strlen(final_text));
assert_mem_equals(final_text, c_read_result, strlen(final_text), "Function wrote incorrect bytes");
}
share_message_errors();
}
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_mem_insn_5(unsigned char expected_1,
unsigned char expected_2,
unsigned char expected_3,
unsigned char expected_4,
unsigned char expected_5,
const char *actual)
{
unsigned char expected[] = { expected_1, expected_2, expected_3, expected_4, expected_5 };
assert_mem_equals(expected, actual, ARRAY_SIZE(expected));
}
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_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);
}
void file_sync_call() {
MPI_File file;
int result = MPI_File_open_pmem(global_context->communicator, global_context->file_path, MPI_MODE_RDWR, create_mpi_info(), &file);
assert_true(result == MPI_SUCCESS, "MPI_File_open_pmem returned with error");
result = MPI_File_write_at_pmem(file, 0, TEXT_TO_WRITE, strlen(TEXT_TO_WRITE), MPI_CHAR, MPI_STATUS_IGNORE);
assert_true(result == MPI_SUCCESS, "MPI_File_write_at_pmem returned with error");
result = MPI_File_sync_pmem(file);
assert_true(result == MPI_SUCCESS, "MPI_File_sync returned with error");
// check data on storage device before MPI_File_close is called
char* c_read_result = c_read_at(0, strlen(TEXT_TO_WRITE));
assert_mem_equals(TEXT_TO_WRITE, c_read_result, strlen(TEXT_TO_WRITE), "Function does not sync bytes with fs");
// another write operation to prove that the file is still opened
result = MPI_File_write_at_pmem(file, 1, TEXT_TO_WRITE, strlen(TEXT_TO_WRITE), MPI_CHAR, MPI_STATUS_IGNORE);
assert_true(result == MPI_SUCCESS, "MPI_File_write returned an error after MPI_File_sync was called");
result = MPI_File_close_pmem(&file);
assert_true(result == MPI_SUCCESS, "MPI_File_close_pmem returned with error");
}
void long_sequence_of_read_at_operations() {
MPI_File file;
int result = MPI_File_open_pmem(global_context->communicator, global_context->file_path, MPI_MODE_RDWR, create_mpi_info(), &file);
assert_true(result == MPI_SUCCESS, "MPI_File_open_pmem returned with error");
int size = 64;
char* file_fragment = (char*) malloc(size * sizeof(char));
for (int i=0; i<LONG_SEQUENCE_LENGTH; i++) {
int location = rand() % (global_context->file_size - size);
result = MPI_File_read_at_pmem(file, location, file_fragment, size, MPI_BYTE, MPI_STATUS_IGNORE);
assert_true(result == MPI_SUCCESS, "MPI_File_write_at_pmem returned with error");
char* c_read_result = c_read_at(location, size);
assert_mem_equals(file_fragment, c_read_result, size, "Function read incorrect bytes");
}
result = MPI_File_close_pmem(&file);
assert_true(result == MPI_SUCCESS, "MPI_File_close_pmem returned with error");
if (get_rank(global_context->communicator) == 0) {
assert_true(get_file_size() == global_context->file_size, "File changed its size after read/write operations");
}
}
void test_write_at(char* data_to_write, int location, int size) {
pmem_write_at(data_to_write, location, size);
char* c_read_result = c_read_at(location, size);
assert_mem_equals(data_to_write, c_read_result, size, "Function wrote incorrect bytes");
}
void test_read_at(int location, int size) {
char* pmem_read_result = pmem_read_at(location, size);
char* c_read_result = c_read_at(location, size);
assert_mem_equals(pmem_read_result, c_read_result, size, "Function read incorrect bytes");
}
