epee_levin_protocol_handler_async.cpp File Reference

#include <boost/thread/mutex.hpp>
#include <boost/thread/thread.hpp>
#include "gtest/gtest.h"
#include "include_base_utils.h"
#include "string_tools.h"
#include "net/levin_protocol_handler_async.h"
#include "net/net_utils_base.h"
#include "unit_tests_utils.h"

Include dependency graph for epee_levin_protocol_handler_async.cpp:

Go to the source code of this file.

Functions
	TEST_F (positive_test_connection_to_levin_protocol_handler_calls, new_handler_is_not_initialized)
	TEST_F (positive_test_connection_to_levin_protocol_handler_calls, handler_initialization_and_destruction_is_correct)
	TEST_F (positive_test_connection_to_levin_protocol_handler_calls, concurent_handler_initialization_and_destruction_is_correct)
	TEST_F (positive_test_connection_to_levin_protocol_handler_calls, handler_processes_handle_read_as_invoke)
	TEST_F (positive_test_connection_to_levin_protocol_handler_calls, handler_processes_handle_read_as_notify)
	TEST_F (positive_test_connection_to_levin_protocol_handler_calls, handler_processes_qued_callback)
	TEST_F (test_levin_protocol_handler__hanle_recv_with_invalid_data, handles_big_packet_1)
	TEST_F (test_levin_protocol_handler__hanle_recv_with_invalid_data, handles_big_packet_2)
	TEST_F (test_levin_protocol_handler__hanle_recv_with_invalid_data, handles_invalid_signature_for_full_header)
	TEST_F (test_levin_protocol_handler__hanle_recv_with_invalid_data, handles_invalid_signature_for_partial_header)
	TEST_F (test_levin_protocol_handler__hanle_recv_with_invalid_data, handles_big_cb)
	TEST_F (test_levin_protocol_handler__hanle_recv_with_invalid_data, does_not_handle_data_after_close)
	TEST_F (test_levin_protocol_handler__hanle_recv_with_invalid_data, handles_network_error)
	TEST_F (test_levin_protocol_handler__hanle_recv_with_invalid_data, handles_chunked_header)
	TEST_F (test_levin_protocol_handler__hanle_recv_with_invalid_data, handles_chunked_body)
	TEST_F (test_levin_protocol_handler__hanle_recv_with_invalid_data, handles_two_requests_at_once)
	TEST_F (test_levin_protocol_handler__hanle_recv_with_invalid_data, handles_unexpected_response)

Function Documentation

TEST_F() [1/17]

TEST_F	(	positive_test_connection_to_levin_protocol_handler_calls	,
		concurent_handler_initialization_and_destruction_is_correct	)

Definition at line 295 of file epee_levin_protocol_handler_async.cpp.

{
  const size_t connection_count = 10000;
  auto create_and_destroy_connections = [this]()
  {
    std::vector<test_connection_ptr> connections(connection_count);
    for (size_t i = 0; i < connection_count; ++i)
    {
      connections[i] = create_connection();
    }
 
    for (size_t i = 0; i < connection_count; ++i)
    {
      connections[i].reset();
    }
  };
 
  const size_t thread_count = boost::thread::hardware_concurrency();
  std::vector<boost::thread> threads(thread_count);
  for (boost::thread& th : threads)
  {
    th = boost::thread(create_and_destroy_connections);
  }
 
  for (boost::thread& th : threads)
  {
    th.join();
  }
 
  ASSERT_EQ(0, m_handler_config.get_connections_count());
  ASSERT_EQ(connection_count * thread_count, m_commands_handler.new_connection_counter());
  ASSERT_EQ(connection_count * thread_count, m_commands_handler.close_connection_counter());
}

TEST_F() [2/17]

TEST_F	(	positive_test_connection_to_levin_protocol_handler_calls	,
		handler_initialization_and_destruction_is_correct	)

Definition at line 284 of file epee_levin_protocol_handler_async.cpp.

{
  test_connection_ptr conn = create_connection();
  ASSERT_TRUE(conn->m_protocol_handler.m_connection_initialized);
  ASSERT_EQ(1, m_handler_config.get_connections_count());
  ASSERT_EQ(1, m_commands_handler.new_connection_counter());
  conn.reset();
  ASSERT_EQ(0, m_handler_config.get_connections_count());
  ASSERT_EQ(1, m_commands_handler.close_connection_counter());
}

TEST_F() [3/17]

TEST_F	(	positive_test_connection_to_levin_protocol_handler_calls	,
		handler_processes_handle_read_as_invoke	)

Definition at line 329 of file epee_levin_protocol_handler_async.cpp.

{
  // Setup
  const int expected_command = 2634981;
  const int expected_return_code = 6732;
  const std::string expected_out_data(128, 'w');
 
  test_connection_ptr conn = create_connection();
 
  std::string in_data(256, 'q');
 
  epee::levin::bucket_head2 req_head;
  req_head.m_signature = LEVIN_SIGNATURE;
  req_head.m_cb = in_data.size();
  req_head.m_have_to_return_data = true;
  req_head.m_command = expected_command;
  req_head.m_flags = LEVIN_PACKET_REQUEST;
  req_head.m_protocol_version = LEVIN_PROTOCOL_VER_1;
 
  std::string buf(reinterpret_cast<const char*>(&req_head), sizeof(req_head));
  buf += in_data;
 
  m_commands_handler.invoke_out_buf(expected_out_data);
  m_commands_handler.return_code(expected_return_code);
 
  // Test
  ASSERT_TRUE(conn->m_protocol_handler.handle_recv(buf.data(), buf.size()));
 
  //
  // Check
  //
 
  // Check connection and levin_commands_handler states
  ASSERT_EQ(1, m_commands_handler.invoke_counter());
  ASSERT_EQ(0, m_commands_handler.notify_counter());
  ASSERT_EQ(expected_command, m_commands_handler.last_command());
  ASSERT_EQ(in_data, m_commands_handler.last_in_buf());
  ASSERT_LE(1, conn->send_counter());
 
  // Parse send data
  std::string send_data = conn->last_send_data();
  epee::levin::bucket_head2 resp_head;
  resp_head = *reinterpret_cast<const epee::levin::bucket_head2*>(send_data.data());
  ASSERT_LT(sizeof(resp_head), send_data.size());
  std::string out_data = send_data.substr(sizeof(resp_head));
 
  // Check sent response
  ASSERT_EQ(expected_out_data, out_data);
  ASSERT_EQ(LEVIN_SIGNATURE, resp_head.m_signature);
  ASSERT_EQ(expected_command, resp_head.m_command);
  ASSERT_EQ(expected_return_code, resp_head.m_return_code);
  ASSERT_EQ(expected_out_data.size(), resp_head.m_cb);
  ASSERT_FALSE(resp_head.m_have_to_return_data);
  ASSERT_EQ(LEVIN_PROTOCOL_VER_1, resp_head.m_protocol_version);
  ASSERT_TRUE(0 != (resp_head.m_flags & LEVIN_PACKET_RESPONSE));
}

TEST_F() [4/17]

TEST_F	(	positive_test_connection_to_levin_protocol_handler_calls	,
		handler_processes_handle_read_as_notify	)

Definition at line 386 of file epee_levin_protocol_handler_async.cpp.

{
  // Setup
  const int expected_command = 4673261;
 
  test_connection_ptr conn = create_connection();
 
  std::string in_data(256, 'e');
 
  epee::levin::bucket_head2 req_head;
  req_head.m_signature = LEVIN_SIGNATURE;
  req_head.m_cb = in_data.size();
  req_head.m_have_to_return_data = false;
  req_head.m_command = expected_command;
  req_head.m_flags = LEVIN_PACKET_REQUEST;
  req_head.m_protocol_version = LEVIN_PROTOCOL_VER_1;
 
  std::string buf(reinterpret_cast<const char*>(&req_head), sizeof(req_head));
  buf += in_data;
 
  // Test
  ASSERT_TRUE(conn->m_protocol_handler.handle_recv(buf.data(), buf.size()));
 
  // Check connection and levin_commands_handler states
  ASSERT_EQ(1, m_commands_handler.notify_counter());
  ASSERT_EQ(0, m_commands_handler.invoke_counter());
  ASSERT_EQ(expected_command, m_commands_handler.last_command());
  ASSERT_EQ(in_data, m_commands_handler.last_in_buf());
  ASSERT_LE(0, conn->send_counter());
  ASSERT_TRUE(conn->last_send_data().empty());
}

TEST_F() [5/17]

TEST_F	(	positive_test_connection_to_levin_protocol_handler_calls	,
		handler_processes_qued_callback	)

Definition at line 418 of file epee_levin_protocol_handler_async.cpp.

{
  test_connection_ptr conn = create_connection();
 
  conn->m_protocol_handler.handle_qued_callback();
  conn->m_protocol_handler.handle_qued_callback();
  conn->m_protocol_handler.handle_qued_callback();
 
  ASSERT_EQ(3, m_commands_handler.callback_counter());
}

TEST_F() [6/17]

TEST_F	(	positive_test_connection_to_levin_protocol_handler_calls	,
		new_handler_is_not_initialized	)

Definition at line 273 of file epee_levin_protocol_handler_async.cpp.

{
  test_connection_ptr conn = create_connection(false);
  ASSERT_FALSE(conn->m_protocol_handler.m_connection_initialized);
  ASSERT_EQ(0, m_handler_config.get_connections_count());
  ASSERT_EQ(0, m_commands_handler.new_connection_counter());
  conn.reset();
  ASSERT_EQ(0, m_handler_config.get_connections_count());
  ASSERT_EQ(0, m_commands_handler.close_connection_counter());
}

TEST_F() [7/17]

TEST_F	(	test_levin_protocol_handler__hanle_recv_with_invalid_data	,
		does_not_handle_data_after_close	)

Definition at line 471 of file epee_levin_protocol_handler_async.cpp.

{
  prepare_buf();
 
  ASSERT_TRUE(m_conn->m_protocol_handler.close());
  ASSERT_FALSE(m_conn->m_protocol_handler.handle_recv(m_buf.data(), m_buf.size()));
}

TEST_F() [8/17]

TEST_F	(	test_levin_protocol_handler__hanle_recv_with_invalid_data	,
		handles_big_cb	)

Definition at line 463 of file epee_levin_protocol_handler_async.cpp.

{
  m_req_head.m_cb = max_packet_size + 1;
  prepare_buf();
 
  ASSERT_FALSE(m_conn->m_protocol_handler.handle_recv(m_buf.data(), m_buf.size()));
}

TEST_F() [9/17]

TEST_F	(	test_levin_protocol_handler__hanle_recv_with_invalid_data	,
		handles_big_packet_1	)

Definition at line 429 of file epee_levin_protocol_handler_async.cpp.

{
  std::string buf("yyyyyy");
  ASSERT_FALSE(m_conn->m_protocol_handler.handle_recv(buf.data(), max_packet_size + 1));
}

TEST_F() [10/17]

TEST_F	(	test_levin_protocol_handler__hanle_recv_with_invalid_data	,
		handles_big_packet_2	)

Definition at line 435 of file epee_levin_protocol_handler_async.cpp.

{
  prepare_buf();
  const size_t first_packet_size = sizeof(m_req_head) - 1;
 
  m_buf.resize(first_packet_size);
  ASSERT_TRUE(m_conn->m_protocol_handler.handle_recv(m_buf.data(), m_buf.size()));
 
  ASSERT_FALSE(m_conn->m_protocol_handler.handle_recv(m_buf.data(), max_packet_size - m_buf.size() + 1));
}

TEST_F() [11/17]

TEST_F	(	test_levin_protocol_handler__hanle_recv_with_invalid_data	,
		handles_chunked_body	)

Definition at line 505 of file epee_levin_protocol_handler_async.cpp.

{
  prepare_buf();
 
  size_t buf1_size = sizeof(m_req_head) + (m_buf.size() - sizeof(m_req_head)) / 2;
 
  std::string buf1 = m_buf.substr(0, buf1_size);
  std::string buf2 = m_buf.substr(buf1_size);
  ASSERT_EQ(m_buf, buf1 + buf2);
 
  ASSERT_TRUE(m_conn->m_protocol_handler.handle_recv(buf1.data(), buf1.size()));
  ASSERT_EQ(0, m_commands_handler.invoke_counter());
 
  ASSERT_TRUE(m_conn->m_protocol_handler.handle_recv(buf2.data(), buf2.size()));
  ASSERT_EQ(1, m_commands_handler.invoke_counter());
}

TEST_F() [12/17]

TEST_F	(	test_levin_protocol_handler__hanle_recv_with_invalid_data	,
		handles_chunked_header	)

Definition at line 487 of file epee_levin_protocol_handler_async.cpp.

{
  prepare_buf();
 
  size_t buf1_size = sizeof(m_req_head) / 2;
 
  std::string buf1 = m_buf.substr(0, buf1_size);
  std::string buf2 = m_buf.substr(buf1_size);
  ASSERT_EQ(m_buf, buf1 + buf2);
 
  ASSERT_TRUE(m_conn->m_protocol_handler.handle_recv(buf1.data(), buf1.size()));
  ASSERT_EQ(0, m_commands_handler.invoke_counter());
 
  ASSERT_TRUE(m_conn->m_protocol_handler.handle_recv(buf2.data(), buf2.size()));
  ASSERT_EQ(1, m_commands_handler.invoke_counter());
} 

TEST_F() [13/17]

TEST_F	(	test_levin_protocol_handler__hanle_recv_with_invalid_data	,
		handles_invalid_signature_for_full_header	)

Definition at line 446 of file epee_levin_protocol_handler_async.cpp.

{
  m_req_head.m_signature = LEVIN_SIGNATURE ^ 1;
  prepare_buf();
 
  ASSERT_FALSE(m_conn->m_protocol_handler.handle_recv(m_buf.data(), m_buf.size()));
}

TEST_F() [14/17]

TEST_F	(	test_levin_protocol_handler__hanle_recv_with_invalid_data	,
		handles_invalid_signature_for_partial_header	)

Definition at line 454 of file epee_levin_protocol_handler_async.cpp.

{
  m_req_head.m_signature = LEVIN_SIGNATURE ^ 1;
  prepare_buf();
  m_buf.resize(sizeof(m_req_head.m_signature));
 
  ASSERT_FALSE(m_conn->m_protocol_handler.handle_recv(m_buf.data(), m_buf.size()));
}

TEST_F() [15/17]

TEST_F	(	test_levin_protocol_handler__hanle_recv_with_invalid_data	,
		handles_network_error	)

Definition at line 479 of file epee_levin_protocol_handler_async.cpp.

{
  prepare_buf();
 
  m_conn->send_return(false);
  ASSERT_FALSE(m_conn->m_protocol_handler.handle_recv(m_buf.data(), m_buf.size()));
}

TEST_F() [16/17]

TEST_F	(	test_levin_protocol_handler__hanle_recv_with_invalid_data	,
		handles_two_requests_at_once	)

Definition at line 522 of file epee_levin_protocol_handler_async.cpp.

{
  prepare_buf();
  m_buf.append(m_buf);
 
  ASSERT_TRUE(m_conn->m_protocol_handler.handle_recv(m_buf.data(), m_buf.size()));
  ASSERT_EQ(2, m_commands_handler.invoke_counter());
}

TEST_F() [17/17]

TEST_F	(	test_levin_protocol_handler__hanle_recv_with_invalid_data	,
		handles_unexpected_response	)

Definition at line 531 of file epee_levin_protocol_handler_async.cpp.

{
  m_req_head.m_flags = LEVIN_PACKET_RESPONSE;
  prepare_buf();
 
  ASSERT_FALSE(m_conn->m_protocol_handler.handle_recv(m_buf.data(), m_buf.size()));
}