예제 #1
0
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);
}
예제 #2
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);
}
예제 #3
0
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();
}
예제 #4
0
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);
}
예제 #5
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));
}
예제 #6
0
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);
}
예제 #7
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);
}
예제 #8
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");
}
예제 #9
0
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");
   }
}
예제 #10
0
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");
}
예제 #11
0
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");
}