test();
};
+/*
//-------------is_thread_wait test---------------------------------
void set_is_thread_wait_test(){
- pTest_mutex = &thread_state_update_mutex;
- test_func = boost::bind(&mutex_lock_test::down_thread_exit,this);
+ //pTest_mutex = &thread_state_update_mutex;
+ pTest_mutex2 = &downthread_status_mutex;
+ test_func = boost::bind(&mutex_lock_test::is_thread_wait,this);
};
void is_thread_wait(){
l7vs::tcp_session::is_thread_wait();
after_thread_id = boost::this_thread::get_id();
};
+*/
//-------------down_thread_exit test---------------------------------
void set_down_thread_exit_test(){
after_thread_id = boost::this_thread::get_id();
};
+/*
//-------------thread_state_update test---------------------------------
void set_thread_state_update_test(){
pTest_mutex = &thread_state_update_mutex;
l7vs::tcp_session::thread_state_update(UP_THREAD_ALIVE,true);
after_thread_id = boost::this_thread::get_id();
};
+*/
//-------------handle_ssl_handshake_timer test---------------------------------
void set_handle_ssl_handshake_timer_test(){
};
};
+// dummy client
+class test_client{
+ public:
+ //
+ test_client(boost::asio::io_service& io_service, boost::asio::ssl::context& context) :
+ my_socket(io_service,context){
+ };
+
+ ~test_client(){
+ };
+ void all_lock(){
+
+ //! socket connect mutex
+ connect_mutex.wrlock();
+ //! socket handshake mutex
+ handshake_mutex.wrlock();
+ //! socket read mutex
+ read_mutex.wrlock();
+ //! socket write mutex
+ write_mutex.wrlock();
+ //! socket close mutex
+ close_mutex.wrlock();
+
+ }
+
+ void connect_close_only_test_run(){
+ // dummy client start
+
+ // connect
+ {
+ l7vs::rw_scoped_lock scope_lock(connect_mutex);
+
+ if(!connect_test()){
+ return;
+ }
+ }
+
+ // close
+ {
+ l7vs::rw_scoped_lock scope_lock(close_mutex);
+ close_test();
+ }
+ };
+
+ void handshake_test_run(){
+ // dummy client start
+
+ // connect
+ {
+ l7vs::rw_scoped_lock scope_lock(connect_mutex);
+
+ if(!connect_test()){
+ return;
+ }
+ }
+
+ // handshake
+ {
+ l7vs::rw_scoped_lock scope_lock(handshake_mutex);
+
+ if(!handshake_test()){
+ return;
+ }
+ }
+
+ // close
+ {
+ l7vs::rw_scoped_lock scope_lock(close_mutex);
+ close_test();
+ }
+
+ };
+
+ bool connect_test(){
+ sleep(1);
+ boost::system::error_code ec;
+ std::cout << "dummy client connect try" << std::endl;
+ boost::asio::ip::tcp::endpoint connect_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
+ my_socket.lowest_layer().connect(connect_end,ec);
+ if(ec){
+ //receive error
+ std::cout << "dummy client connect Error!" << std::endl;
+ std::cout << ec << std::endl;
+ return false;
+ }
+ std::cout << "dummy client connect OK" << std::endl;
+ return true;
+ };
+
+ bool handshake_test(){
+ boost::system::error_code ec;
+ std::cout << "dummy client handshake try" << std::endl;
+ my_socket.handshake(boost::asio::ssl::stream_base::client, ec);
+ if(ec){
+ //receive error
+ std::cout << "dummy client handshake Error!" << std::endl;
+ std::cout << ec << std::endl;
+ return false;
+ }
+ std::cout << "dummy client handshake OK" << std::endl;
+ return true;
+ };
+
+ bool send_test(){
+ sleep(1);
+ boost::system::error_code ec;
+ std::cout << "dummy client write try" << std::endl;
+ std::size_t write_size = my_socket.write_some(boost::asio::buffer(data_buff.data() + send_data_size,receive_data_size - send_data_size), ec);
+ if(ec){
+ //receive error
+ std::cout << "dummy client send Error!" << std::endl;
+ std::cout << ec << std::endl;
+ return false;
+ }
+ send_data_size += write_size;
+ std::cout << "dummy client send OK [" << send_data_size << "]" << std::endl;
+ return true;
+ };
+ bool receive_test(){
+ sleep(1);
+ boost::system::error_code ec;
+ std::cout << "dummy client read try" << std::endl;
+ std::size_t read_size = my_socket.read_some(boost::asio::buffer(data_buff.data() + receive_data_size,MAX_BUFFER_SIZE), ec);
+ if(ec){
+ //receive error
+ std::cout << "dummy client receive Error!" << std::endl;
+ std::cout << ec << std::endl;
+ return false;
+ }
+ receive_data_size += read_size;
+ std::cout << "dummy client receive OK [" << receive_data_size << "]" << std::endl;
+ return true;
+ };
+ void close_test(){
+ sleep(1);
+ boost::system::error_code ec;
+ std::cout << "dummy client close try" << std::endl;
+ my_socket.lowest_layer().close(ec);
+ if(ec){
+ //close error
+ std::cout << "dummy client close Error!" << std::endl;
+ std::cout << ec << std::endl;
+ return;
+ }
+ std::cout << "dummy client close OK" << std::endl;
+ };
+
+ boost::asio::ssl::stream<boost::asio::ip::tcp::socket> my_socket;
+ boost::array<char,MAX_BUFFER_SIZE> data_buff;
+ std::size_t receive_data_size;
+ std::size_t send_data_size;
+
+ //! socket connect mutex
+ l7vs::wr_mutex connect_mutex;
+ //! socket handshake mutex
+ l7vs::wr_mutex handshake_mutex;
+ //! socket read mutex
+ l7vs::wr_mutex read_mutex;
+ //! socket write mutex
+ l7vs::wr_mutex write_mutex;
+ //! socket close mutex
+ l7vs::wr_mutex close_mutex;
+};
+
+class authority{
+ public:
+ authority(){
+ };
+ ~authority(){
+ };
+ std::string get_password() const{
+ std::cout << "call get_password" << std::endl;
+ return "test";
+ };
+};
+
+
// module event map test base class
class module_event_map_test_base_class : public l7vs::tcp_session{
public:
return parent_service;
};
bool get_exit_flag(){
- return exit_flag;
+ return (bool)exit_flag;
};
+/*
std::bitset<TCP_SESSION_THREAD_STATE_BIT> get_thread_state(){
return thread_state;
};
+*/
+ l7vs::tcp_session::UPTHREAD_STATUS_TAG& get_up_status(){
+ return upthread_status;
+ };
+
+ l7vs::tcp_session::DOWNTHREAD_STATUS_TAG& get_down_status(){
+ return downthread_status;
+ };
l7vs::protocol_module_base* get_protocol_module(){
return protocol_module;
};
+/*
bool get_session_pause_flag(){
return session_pause_flag;
};
+*/
l7vs::tcp_socket& get_client_socket(){
return client_socket;
};
BOOST_CHECK_EQUAL(&io , &test_obj.get_io());
BOOST_CHECK_EQUAL(&vs,&test_obj.get_parent_service());
BOOST_CHECK(!test_obj.get_exit_flag());
- std::bitset<TCP_SESSION_THREAD_STATE_BIT> ref;
- ref.reset();
- BOOST_CHECK_EQUAL(ref,test_obj.get_thread_state());
+// std::bitset<TCP_SESSION_THREAD_STATE_BIT> ref;
+// ref.reset();
+// BOOST_CHECK_EQUAL(ref,test_obj.get_thread_state());
+ BOOST_CHECK_EQUAL(0, test_obj.get_up_status());
+ BOOST_CHECK_EQUAL(0, test_obj.get_down_status());
BOOST_CHECK_EQUAL((void*)NULL,test_obj.get_protocol_module());
- BOOST_CHECK(!test_obj.get_session_pause_flag());
+// BOOST_CHECK(!test_obj.get_session_pause_flag());
BOOST_CHECK_EQUAL(&io , &(test_obj.get_client_socket().get_socket().get_io_service()));
BOOST_CHECK_EQUAL(&io , &(test_obj.get_sorry_socket()->get_socket().get_io_service()));
// unit_test [2] constructer set up_thread_module_event_map check
~initialize_test_class(){};
bool& get_exit_flag(){
- return exit_flag;
+ return (bool&)exit_flag;
};
boost::thread::id& get_up_thread_id(){
return up_thread_id;
boost::thread::id& get_down_thread_id(){
return down_thread_id;
};
+/*
std::bitset<TCP_SESSION_THREAD_STATE_BIT>& get_thread_state(){
return thread_state;
};
+*/
+ l7vs::tcp_session::UPTHREAD_STATUS_TAG get_up_status(){
+ return upthread_status;
+ };
+ l7vs::tcp_session::DOWNTHREAD_STATUS_TAG get_down_status(){
+ return downthread_status;
+ };
+ void set_up_status(int s){
+ switch(s) {
+ case 0:
+ upthread_status = l7vs::tcp_session::UPTHREAD_SLEEP;
+ break;
+ case 1:
+ upthread_status = l7vs::tcp_session::UPTHREAD_ALIVE;
+ break;
+ case 2:
+ upthread_status = l7vs::tcp_session::UPTHREAD_ACTIVE;
+ break;
+ default:
+ upthread_status = l7vs::tcp_session::UPTHREAD_LOCK;
+ break;
+ }
+ };
+ void set_down_status(int s){
+ switch(s) {
+ case 0:
+ downthread_status = l7vs::tcp_session::DOWNTHREAD_SLEEP;
+ break;
+ case 1:
+ downthread_status = l7vs::tcp_session::DOWNTHREAD_ALIVE;
+ break;
+ case 2:
+ downthread_status = l7vs::tcp_session::DOWNTHREAD_ACTIVE;
+ break;
+ default:
+ downthread_status = l7vs::tcp_session::DOWNTHREAD_LOCK;
+ break;
+ }
+ };
l7vs::protocol_module_base* get_protocol_module(){
return protocol_module;
};
+/*
bool& get_session_pause_flag(){
return session_pause_flag;
};
+*/
l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_up_thread_message_que(){
return up_thread_message_que;
};
test_obj.get_exit_flag() = true;
test_obj.get_up_thread_id() = boost::this_thread::get_id();
test_obj.get_down_thread_id() = boost::this_thread::get_id();
- test_obj.get_thread_state().set();
+// test_obj.get_thread_state().set();
+ test_obj.set_up_status(1);
+ test_obj.set_down_status(1);
BOOST_CHECK(test_obj.get_protocol_module() != &proto_test);
- test_obj.get_session_pause_flag() = true;
+// test_obj.get_session_pause_flag() = true;
l7vs::tcp_thread_message* test_msg_up = new l7vs::tcp_thread_message;
l7vs::tcp_thread_message* test_msg_dw = new l7vs::tcp_thread_message;
test_obj.get_up_thread_message_que().push(test_msg_up);
// unit_test [4] initialize thread state check
std::cout << "[4] initialize thread state check" << std::endl;
- BOOST_CHECK(test_obj.get_thread_state().none());
+// BOOST_CHECK(test_obj.get_thread_state().none());
+ BOOST_CHECK(test_obj.get_up_status() == 0);
+ BOOST_CHECK(test_obj.get_down_status() == 0);
// unit_test [5] initialize session pause flag check
std::cout << "[5] initialize session pause flag check" << std::endl;
- BOOST_CHECK(!test_obj.get_session_pause_flag());
+// BOOST_CHECK(!test_obj.get_session_pause_flag());
// unit_test [6] initialize up thread message que check
std::cout << "[6] initialize up thread message que check" << std::endl;
}
+/*
// is_thread_wait test
// is_thread_wait test class
class is_thread_wait_test_class : public l7vs::tcp_session{
std::bitset<TCP_SESSION_THREAD_STATE_BIT>& get_thread_state(){
return thread_state;
};
+ l7vs::tcp_session::UPTHREAD_STATUS_TAG get_up_status(){
+ return upthread_status;
+ };
+ l7vs::tcp_session::DOWNTHREAD_STATUS_TAG get_down_status(){
+ return downthread_status;
+ };
};
void is_thread_wait_test(){
BOOST_MESSAGE( "----- is_thread_wait test start -----" );
BOOST_MESSAGE( "----- is_thread_wait test end -----" );
}
+*/
// set_virtual_service_message test
// set_virtual_service_message test class
~set_virtual_service_message_test_class(){};
+/*
bool& get_session_pause_flag(){
return session_pause_flag;
}
+*/
bool& get_access_log_flag(){
return access_log_flag;
set_virtual_service_message_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
- bool& ref_pause_flag = test_obj.get_session_pause_flag();
+// bool& ref_pause_flag = test_obj.get_session_pause_flag();
bool& ref_access_log_flag = test_obj.get_access_log_flag();
l7vs::lockfree_queue<l7vs::tcp_thread_message>& ref_up_msg_que = test_obj.get_up_thread_message_que();
l7vs::lockfree_queue<l7vs::tcp_thread_message>& ref_dw_msg_que = test_obj.get_down_thread_message_que();
// unit_test [4] set_virtual_service_message SESSION_PAUSE_ON
std::cout << "[4] set_virtual_service_message SESSION_PAUSE_ON" << std::endl;
- ref_pause_flag = false;
+// ref_pause_flag = false;
test_obj.set_virtual_service_message(l7vs::tcp_session::SESSION_PAUSE_ON);
- BOOST_CHECK(ref_pause_flag);
+// BOOST_CHECK(ref_pause_flag);
// unit_test [5] set_virtual_service_message SESSION_PAUSE_OFF
std::cout << "[5] set_virtual_service_message SESSION_PAUSE_OFF" << std::endl;
- ref_pause_flag = true;
+// ref_pause_flag = true;
test_obj.set_virtual_service_message(l7vs::tcp_session::SESSION_PAUSE_OFF);
- BOOST_CHECK(!ref_pause_flag);
+// BOOST_CHECK(!ref_pause_flag);
// unit_test [6] set_virtual_service_message ACCESS_LOG_ON
std::cout << "[6] set_virtual_service_message ACCESS_LOG__ON" << std::endl;
};
~up_thread_run_test_class(){};
bool& get_exit_flag(){
- return exit_flag;
+ return (bool&)exit_flag;
};
+/*
bool& get_session_pause_flag(){
return session_pause_flag;
};
+*/
+/*
std::bitset<TCP_SESSION_THREAD_STATE_BIT>& get_thread_state(){
return thread_state;
};
+*/
+ l7vs::tcp_session::UPTHREAD_STATUS_TAG& get_up_status(){
+ return upthread_status;
+ };
+ l7vs::tcp_session::DOWNTHREAD_STATUS_TAG& get_down_status(){
+ return downthread_status;
+ };
+ void set_up_status(int s){
+ switch(s) {
+ case 0:
+ upthread_status = l7vs::tcp_session::UPTHREAD_SLEEP;
+ break;
+ case 1:
+ upthread_status = l7vs::tcp_session::UPTHREAD_ALIVE;
+ break;
+ case 2:
+ upthread_status = l7vs::tcp_session::UPTHREAD_ACTIVE;
+ break;
+ default:
+ upthread_status = l7vs::tcp_session::UPTHREAD_LOCK;
+ break;
+ }
+ };
+ void set_down_status(int s){
+ switch(s) {
+ case 0:
+ downthread_status = l7vs::tcp_session::DOWNTHREAD_SLEEP;
+ break;
+ case 1:
+ downthread_status = l7vs::tcp_session::DOWNTHREAD_ALIVE;
+ break;
+ case 2:
+ downthread_status = l7vs::tcp_session::DOWNTHREAD_ACTIVE;
+ break;
+ default:
+ downthread_status = l7vs::tcp_session::DOWNTHREAD_LOCK;
+ break;
+ }
+ };
boost::mutex test_thread_wait;
void test_run(){
test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
bool& exit_flag = test_obj.get_exit_flag();
- bool& session_pause_flag = test_obj.get_session_pause_flag();
+// bool& session_pause_flag = test_obj.get_session_pause_flag();
boost::thread::id& up_thread_id = test_obj.get_up_thread_id();
boost::thread::id& down_thread_id = test_obj.get_down_thread_id();
- std::bitset<TCP_SESSION_THREAD_STATE_BIT>& thread_state = test_obj.get_thread_state();
+// std::bitset<TCP_SESSION_THREAD_STATE_BIT>& thread_state = test_obj.get_thread_state();
l7vs::tcp_socket& client_socket = test_obj.get_client_socket();
test_mirror_server test_server;
}
test_obj.test_thread_wait.lock();
+/*
thread_state[0] = 0; // UP_THREAD_ALIVE
thread_state[1] = 0; // DOWN_THREAD_ALIVE
thread_state[2] = 0; // UP_THREAD_ACTIVE
thread_state[3] = 0; // DOWN_THREAD_ACTIVE
thread_state[4] = 0; // UP_THREAD_LOCK
thread_state[5] = 0; // DOWN_THREAD_LOCK
+*/
up_thread_id = boost::thread::id();
boost::thread test_thread(boost::bind(&up_thread_run_test_class::test_run,&test_obj));
sleep(1);
boost::thread::id test_id = test_thread.get_id();
boost::thread::id proc_id = boost::this_thread::get_id();
+/*
BOOST_CHECK(!thread_state.test(0)); // UP_THREAD_ALIVE
BOOST_CHECK(!thread_state.test(1)); // DOWN_THREAD_ALIVE
BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
+*/
+ BOOST_CHECK(test_obj.get_up_status() == 0);
+ BOOST_CHECK(test_obj.get_down_status() == 0);
BOOST_CHECK(up_thread_id != test_id);
test_obj.test_thread_wait.unlock();
sleep(1);
// unit_test [2] up_thread_run down thread wait check
std::cout << "[2] up_thread_run down thread wait check" << std::endl;
+/*
BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
BOOST_CHECK(!thread_state.test(1)); // DOWN_THREAD_ALIVE
BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
+*/
+ BOOST_CHECK(test_obj.get_up_status() == 1);
+ BOOST_CHECK(test_obj.get_down_status() == 0);
proto_test.handle_session_initialize_res_tag = l7vs::protocol_module_base::FINALIZE;
proto_test.handle_session_initialize_in_up_thread_id = boost::thread::id();
BOOST_CHECK(proto_test.handle_session_initialize_in_client_endpoint_tcp != connect_end);
BOOST_CHECK(proto_test.handle_session_initialize_in_client_endpoint_udp != boost::asio::ip::udp::endpoint());
down_thread_id = proc_id;
- session_pause_flag = true;
+// session_pause_flag = true;
// DOWN_THREAD_ALIVE
- thread_state[1] = 1;
+// thread_state[1] = 1;
+ test_obj.set_down_status(1);
sleep(1);
// unit_test [3] up_thread_run handle_session_initialize call check
// unit_test [4] up_thread_run state update(UP_THREAD_ACTIVE) check
std::cout << "[4] up_thread_run state update(UP_THREAD_ACTIVE) check" << std::endl;
- BOOST_CHECK(thread_state.test(2)); // UP_THREAD_ACTIVE
+// BOOST_CHECK(thread_state.test(2)); // UP_THREAD_ACTIVE
+ BOOST_CHECK(test_obj.get_up_status() == 2); // UP_THREAD_ACTIVE
// unit_test [5] up_thread_run pause check
std::cout << "[5] up_thread_run pause check" << std::endl;
- BOOST_CHECK(thread_state.test(4)); // UP_THREAD_LOCK
+ // BOOST_CHECK(thread_state.test(4)); // UP_THREAD_LOCK
test_obj.up_thread_exit_process_type = l7vs::tcp_session::MESSAGE_PROC;
test_obj.up_thread_exit_call_check = false;
test_obj.up_thread_all_socket_close_call_check = false;
- session_pause_flag = false;
+// session_pause_flag = false;
sleep(1);
// unit_test [6] up_thread_run restart check
std::cout << "[6] up_thread_run restart check" << std::endl;
- BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
+// BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
// unit_test [7] up_thread_run up_thread_next_call_function call (up_thread_exit) check
std::cout << "[7] up_thread_run up_thread_next_call_function call (up_thread_exit) check" << std::endl;
// unit_test [8] up_thread_run main loop exit check
std::cout << "[8] up_thread_run main loop exit check" << std::endl;
BOOST_CHECK(exit_flag);
- BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
+// BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
// unit_test [9] up_thread_run up_thread_all_socket_close_call_check call check
// unit_test [10] up_thread_run down thread end wait check
std::cout << "[10] up_thread_run down thread wait check" << std::endl;
+/*
BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
BOOST_CHECK(thread_state.test(1)); // DOWN_THREAD_ALIVE
BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
+*/
+ BOOST_CHECK(test_obj.get_up_status() == 1); // UP_THREAD_ALIVE
+ BOOST_CHECK(test_obj.get_down_status() == 1); // DOWN_THREAD_ALIVE
// proto_test.handle_session_finalize_in_up_thread_id = boost::thread::id();
// proto_test.handle_session_finalize_in_down_thread_id = boost::thread::id();
// vs.release_session_ptr = NULL;
// BOOST_CHECK(vs.release_session_ptr != test_id);
- thread_state[1] = 0;
+// thread_state[1] = 0;
sleep(1);
// unit_test [11] up_thread_run handle_session_finalize call check
// unit_test [13] up_thread_run state update(UP_THREAD_ACTIVE) check
std::cout << "[13] up_thread_run state update(UP_THREAD_ACTIVE) check" << std::endl;
- BOOST_CHECK(!thread_state.test(0)); // UP_THREAD_ACTIVE
+// BOOST_CHECK(!thread_state.test(0)); // UP_THREAD_ACTIVE
// message call test
exit_flag = false;
- session_pause_flag = false;
+// session_pause_flag = false;
l7vs::tcp_data& msg_data = test_obj.get_up_thread_message_data();
test_obj.test_message_set(connect_end);
+/*
thread_state[0] = 0; // UP_THREAD_ALIVE
thread_state[1] = 1; // DOWN_THREAD_ALIVE
thread_state[2] = 0; // UP_THREAD_ACTIVE
thread_state[3] = 0; // DOWN_THREAD_ACTIVE
thread_state[4] = 0; // UP_THREAD_LOCK
thread_state[5] = 0; // DOWN_THREAD_LOCK
+*/
msg_data.set_endpoint(boost::asio::ip::tcp::endpoint());
test_obj.up_thread_exit_call_check = false;
test_obj.up_thread_exit_process_type = l7vs::tcp_session::LOCAL_PROC;
// test thread start
test_obj.test_wait = false;
sleep(1);
+/*
BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
BOOST_CHECK(thread_state.test(1)); // DOWN_THREAD_ALIVE
BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
+*/
// unit_test [14] up_thread_run message call check
std::cout << "[14] up_thread_run message call check" << std::endl;
BOOST_CHECK(test_obj.up_thread_exit_process_type == l7vs::tcp_session::MESSAGE_PROC);
proto_test.handle_session_initialize_res_tag = l7vs::protocol_module_base::FINALIZE;
- thread_state[1] = 0;
+// thread_state[1] = 0;
sleep(1);
// error test not find function map
test_obj.clear_function_array();
exit_flag = false;
- session_pause_flag = false;
- thread_state[1] = 1;
+// session_pause_flag = false;
+// thread_state[1] = 1;
l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
l7vs::Logger::putLogError_id = 0;
BOOST_CHECK_EQUAL(15,l7vs::Logger::putLogError_id);
std::cout << l7vs::Logger::putLogError_message << std::endl;
- thread_state[1] = 0;
+// thread_state[1] = 0;
sleep(1);
//error test protocol_module returnd illegal EVENT_TAG
test_obj.clear_event_map();
exit_flag = false;
- session_pause_flag = false;
- thread_state[1] = 1;
+// session_pause_flag = false;
+// thread_state[1] = 1;
l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
l7vs::Logger::putLogError_id = 0;
BOOST_CHECK_EQUAL(14,l7vs::Logger::putLogError_id);
std::cout << l7vs::Logger::putLogError_message << std::endl;
- thread_state[1] = 0;
+// thread_state[1] = 0;
sleep(1);
// unit_test [17] up_thread_run set non blocking fail check
std::cout << "[17] up_thread_run set non blocking fail check" << std::endl;
exit_flag = false;
- session_pause_flag = false;
- thread_state[1] = 1;
+// session_pause_flag = false;
+// thread_state[1] = 1;
l7vs::tcp_socket::set_non_blocking_mode_res = false;
l7vs::tcp_socket::set_non_blocking_mode_ec = boost::asio::error::bad_descriptor;
l7vs::tcp_socket::set_non_blocking_mode_res = true;
l7vs::tcp_socket::set_non_blocking_mode_ec.clear();
- thread_state[1] = 0;
+// thread_state[1] = 0;
sleep(1);
//error test client endpoint get error
client_socket.get_socket().close(ec);
exit_flag = false;
- session_pause_flag = false;
- thread_state[1] = 1;
+// session_pause_flag = false;
+// thread_state[1] = 1;
l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
l7vs::Logger::putLogError_id = 0;
BOOST_CHECK_EQUAL(9,l7vs::Logger::putLogError_id);
std::cout << l7vs::Logger::putLogError_message << std::endl;
- thread_state[1] = 0;
+// thread_state[1] = 0;
sleep(1);
//error test protocol module null error
test_obj.set_protocol_module(NULL);
exit_flag = false;
- session_pause_flag = false;
- thread_state[1] = 1;
+// session_pause_flag = false;
+// thread_state[1] = 1;
l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
l7vs::Logger::putLogError_id = 0;
BOOST_CHECK_EQUAL(8,l7vs::Logger::putLogError_id);
std::cout << l7vs::Logger::putLogError_message << std::endl;
- thread_state[1] = 0;
+// thread_state[1] = 0;
sleep(1);
test_obj.test_end = true;
};
~down_thread_run_test_class(){};
bool& get_exit_flag(){
- return exit_flag;
+ return (bool&)exit_flag;
};
+/*
bool& get_session_pause_flag(){
return session_pause_flag;
};
+*/
+/*
std::bitset<TCP_SESSION_THREAD_STATE_BIT>& get_thread_state(){
return thread_state;
};
+*/
boost::mutex test_thread_wait;
void test_run(){
test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
bool& exit_flag = test_obj.get_exit_flag();
- bool& session_pause_flag = test_obj.get_session_pause_flag();
+// bool& session_pause_flag = test_obj.get_session_pause_flag();
boost::thread::id& down_thread_id = test_obj.get_down_thread_id();
boost::asio::ip::tcp::endpoint connect_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
- std::bitset<TCP_SESSION_THREAD_STATE_BIT>& thread_state = test_obj.get_thread_state();
+// std::bitset<TCP_SESSION_THREAD_STATE_BIT>& thread_state = test_obj.get_thread_state();
test_obj.test_thread_wait.lock();
+/*
thread_state[0] = 1; // UP_THREAD_ALIVE
thread_state[1] = 0; // DOWN_THREAD_ALIVE
thread_state[2] = 0; // UP_THREAD_ACTIVE
thread_state[3] = 0; // DOWN_THREAD_ACTIVE
thread_state[4] = 0; // UP_THREAD_LOCK
thread_state[5] = 0; // DOWN_THREAD_LOCK
+*/
down_thread_id = boost::thread::id();
boost::thread test_thread(boost::bind(&down_thread_run_test_class::test_run,&test_obj));
sleep(1);
boost::thread::id test_id = test_thread.get_id();
boost::thread::id proc_id = boost::this_thread::get_id();
+/*
BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
BOOST_CHECK(!thread_state.test(1)); // DOWN_THREAD_ALIVE
BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
+*/
BOOST_CHECK(down_thread_id != test_id);
test_obj.test_thread_wait.unlock();
sleep(1);
// unit_test [2] down_thread_run up thread active wait check
std::cout << "[2] down_thread_run up thread active wait check" << std::endl;
+/*
BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
BOOST_CHECK(thread_state.test(1)); // DOWN_THREAD_ALIVE
BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
+*/
- session_pause_flag = true;
+// session_pause_flag = true;
// UP_THREAD_ACTIVE
- thread_state[2] = 1;
+// thread_state[2] = 1;
sleep(1);
// unit_test [3] down_thread_run state update(DOWN_THREAD_ACTIVE) check
std::cout << "[3] down_thread_run state update(DOWN_THREAD_ACTIVE) check" << std::endl;
- BOOST_CHECK(thread_state.test(3)); // DOWN_THREAD_ACTIVE
+// BOOST_CHECK(thread_state.test(3)); // DOWN_THREAD_ACTIVE
// unit_test [4] down_thread_run pause check
std::cout << "[4] down_thread_run pause check" << std::endl;
- BOOST_CHECK(thread_state.test(5)); // DOWN_THREAD_LOCK
+// BOOST_CHECK(thread_state.test(5)); // DOWN_THREAD_LOCK
test_obj.down_thread_realserver_receive_call_check = false;
test_obj.down_thread_realserver_receive_process_type = l7vs::tcp_session::MESSAGE_PROC;
test_obj.set_down_thread_connect_socket_list();
- session_pause_flag = false;
+// session_pause_flag = false;
sleep(1);
// unit_test [5] down_thread_run restart check
std::cout << "[5] down_thread_run restart check" << std::endl;
- BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
+// BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
// unit_test [6] down_thread_run connect realserver set receive list check
// unit_test [8] down_thread_run main loop exit check
std::cout << "[8] down_thread_run main loop exit check" << std::endl;
BOOST_CHECK(exit_flag);
- BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
+// BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
// unit_test [9] down_thread_run down_thread_all_socket_close_call_check call check
std::cout << "[9] down_thread_run down_thread_all_socket_close_call_check call check" << std::endl;
// unit_test [10] down_thread_run state update(DOWN_THREAD_ACTIVE) check
std::cout << "[10] down_thread_run state update(DOWN_THREAD_ACTIVE) check" << std::endl;
- BOOST_CHECK(!thread_state.test(1)); // DOWN_THREAD_ACTIVE
+// BOOST_CHECK(!thread_state.test(1)); // DOWN_THREAD_ACTIVE
// message call test
exit_flag = false;
- session_pause_flag = false;
+// session_pause_flag = false;
l7vs::tcp_data& msg_data = test_obj.get_down_thread_message_data();
test_obj.test_message_set(connect_end);
+/*
thread_state[0] = 1; // UP_THREAD_ALIVE
thread_state[2] = 1; // UP_THREAD_ACTIVE
+*/
msg_data.set_endpoint(boost::asio::ip::tcp::endpoint());
test_obj.down_thread_exit_call_check = false;
test_obj.down_thread_exit_process_type = l7vs::tcp_session::LOCAL_PROC;
// error test not find function map
test_obj.clear_function_array();
exit_flag = false;
- session_pause_flag = true;
+// session_pause_flag = true;
+/*
thread_state[0] = 1; // UP_THREAD_ALIVE
thread_state[2] = 1; // UP_THREAD_ACTIVE
+*/
l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
l7vs::Logger::putLogError_id = 0;
}
+/*
// thread_state_update test
// thread_state_update test class
class thread_state_update_test_class : public l7vs::tcp_session{
BOOST_MESSAGE( "----- thread_state_update test end -----" );
}
-
+*/
// up_thread_exit test
set_access_logger){};
~up_thread_exit_test_class(){};
bool& get_exit_flag(){
- return exit_flag;
+ return (bool&)exit_flag;
};
void test_call(){
l7vs::tcp_session::up_thread_exit(LOCAL_PROC);
~down_thread_exit_test_class(){};
bool& get_exit_flag(){
- return exit_flag;
+ return (bool&)exit_flag;
};
void test_call(){
l7vs::tcp_session::down_thread_exit(LOCAL_PROC);
//up_thread_realserver_connect test class
class up_thread_realserver_connect_test_class : public l7vs::tcp_session{
public:
-// up_thread_realserver_connect_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io,const l7vs::tcp_socket::tcp_socket_option_info set_option) : l7vs::tcp_session(vs,session_io,set_option){
-// };
up_thread_realserver_connect_test_class(
l7vs::virtualservice_tcp& vs,
boost::asio::io_service& session_io,
boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
bool set_ssl_cache_flag(false);
int set_ssl_handshake_time_out = 0;
- //std::string access_log_file_name = "test";
- l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
-
-// up_thread_realserver_connect_test_class test_obj(vs,io);
-// up_thread_realserver_connect_test_class test_obj(vs,io,set_option);
+ l7vs::logger_implement_access* plogger = NULL;// new l7vs::logger_implement_access(access_log_file_name);
+
up_thread_realserver_connect_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
BOOST_MESSAGE( "----- up_thread_realserver_connect test end -----" );
}
+//up_thread_realserver_connect access log test
+//up_thread_realserver_connect access log class
+class up_thread_realserver_connect_access_log_test_class : public l7vs::tcp_session{
+ public:
+ up_thread_realserver_connect_access_log_test_class(
+ l7vs::virtualservice_tcp& vs,
+ boost::asio::io_service& session_io,
+ l7vs::tcp_socket_option_info& set_socket_option,
+ boost::asio::ip::tcp::endpoint listen_endpoint,
+ bool ssl_mode,
+ boost::asio::ssl::context& set_ssl_context,
+ bool set_ssl_cache_flag,
+ int set_ssl_handshake_time_out,
+ l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
+ session_io,
+ set_socket_option,
+ listen_endpoint,
+ ssl_mode,
+ set_ssl_context,
+ set_ssl_cache_flag,
+ set_ssl_handshake_time_out,
+ set_access_logger){};
+
+ ~up_thread_realserver_connect_access_log_test_class(){};
+
+ void test_call(){
+ l7vs::tcp_session::up_thread_realserver_connect(LOCAL_PROC);
+ };
+
+ void set_protocol_module(l7vs::protocol_module_base* set_prot){
+ protocol_module = set_prot;
+ };
+ l7vs::tcp_data& get_up_thread_data_client_side(){
+ return up_thread_data_client_side;
+ };
+ l7vs::tcp_data& get_up_thread_data_dest_side(){
+ return up_thread_data_dest_side;
+ };
+ l7vs::tcp_data& get_down_thread_data_client_side(){
+ return down_thread_data_client_side;
+ };
+ l7vs::tcp_data& get_down_thread_data_dest_side(){
+ return down_thread_data_dest_side;
+ };
+ l7vs::tcp_socket& get_client_socket(){
+ return client_socket;
+ };
+ socket_element& get_sorryserver_socket(){
+ return sorryserver_socket;
+ };
+ std::list<socket_element>& get_down_thread_receive_realserver_socket_list(){
+ return down_thread_receive_realserver_socket_list;
+ };
+ std::map<endpoint,tcp_socket_ptr>& get_up_thread_send_realserver_socket_map(){
+ return up_thread_send_realserver_socket_map;
+ };
+ std::list<socket_element>::iterator& get_down_thread_current_receive_realserver_socket(){
+ return down_thread_current_receive_realserver_socket;
+ };
+ l7vs::tcp_realserver_connect_socket_list& get_down_thread_connect_socket_list(){
+ return down_thread_connect_socket_list;
+ };
+
+
+ void set_up_thread_id(boost::thread::id set_id){
+ up_thread_id = set_id;
+ }
+ void set_down_thread_id(boost::thread::id set_id){
+ down_thread_id = set_id;
+ }
+
+ void next_up_function_call(){
+ up_thread_next_call_function.second(LOCAL_PROC);
+ }
+ void next_down_function_call(){
+ down_thread_next_call_function.second(LOCAL_PROC);
+ }
+
+ void set_up_thread_next_function_call_exit(){
+ up_thread_function_pair fun_it = up_thread_function_array[UP_FUNC_EXIT];
+ up_thread_next_call_function = fun_it;
+ };
+
+ void set_down_thread_next_function_call_exit(){
+ down_thread_function_pair fun_it = down_thread_function_array[DOWN_FUNC_EXIT];
+ down_thread_next_call_function = fun_it;
+ };
+
+ // next call function check
+ void up_thread_realserver_connect_event(const TCP_PROCESS_TYPE_TAG process_type){
+ up_thread_realserver_connect_event_call_check = true;
+ };
+ bool up_thread_realserver_connect_event_call_check;
+ void up_thread_realserver_connection_fail_event(const TCP_PROCESS_TYPE_TAG process_type){
+ up_thread_realserver_connection_fail_event_check = true;
+ };
+ bool up_thread_realserver_connection_fail_event_check;
+
+ void up_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
+ up_thread_exit_call_check = true;
+ }
+ bool up_thread_exit_call_check;
+
+ void down_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
+ down_thread_exit_call_check = true;
+ }
+ bool down_thread_exit_call_check;
+
+ // map clear
+ void up_thread_function_array_clear(){
+ for(int i = 0;i <= UP_FUNC_EXIT;i++){
+ up_thread_function_array[i].second = NULL;
+ }
+ };
+ void down_thread_function_array_clear(){
+ for(int i = 0;i <= DOWN_FUNC_EXIT;i++){
+ down_thread_function_array[i].second = NULL;
+ }
+ };
+
+ void up_thread_module_event_map_clear(){
+ up_thread_module_event_map.clear();
+ };
+
+ void down_thread_module_event_map_clear(){
+ down_thread_module_event_map.clear();
+ };
+
+
+ void set_client_endpoint(boost::asio::ip::tcp::endpoint& set_endpoint){
+ client_endpoint = set_endpoint;
+ };
+
+ std::string get_test_string(boost::asio::ip::tcp::endpoint& set_endpoint){
+ return endpoint_to_string(set_endpoint);
+ };
+
+ void set_access_log_flag( bool set_flag ){
+ access_log_flag = set_flag;
+ };
+};
+
+void up_thread_realserver_connect_access_log_test(){
+ BOOST_MESSAGE( "----- up_thread_realserver_connect access log test start -----" );
+
+ boost::asio::io_service io;
+ l7vs::virtualservice_tcp vs;
+
+ std::string test_protocol_name("test protocol");
+ l7vs::test_protocol_module proto_test(test_protocol_name);
+
+ l7vs::tcp_socket_option_info set_option;
+ //! TCP_NODELAY (false:not set,true:set option)
+ set_option.nodelay_opt = false;
+ //! TCP_NODELAY option value (false:off,true:on)
+ set_option.nodelay_val = false;
+ //! TCP_CORK (false:not set,true:set option)
+ set_option.cork_opt = false;
+ //! TCP_CORK option value (false:off,true:on)
+ set_option.cork_val = false;
+ //! TCP_QUICKACK (false:not set,true:set option)
+ set_option.quickack_opt = false;
+ //! TCP_QUICKACK option value (false:off,true:on)
+ set_option.quickack_val = false;
+
+ boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string("192.168.0.1"), 8080);
+ bool set_mode(false);
+ boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
+ bool set_ssl_cache_flag(false);
+ int set_ssl_handshake_time_out = 0;
+ l7vs::logger_implement_access* plogger = new l7vs::logger_implement_access( "test.log" );
+
+ up_thread_realserver_connect_access_log_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
+ test_obj.set_access_log_flag(true);
+
+
+ boost::asio::ip::tcp::endpoint client_src_endpoint(boost::asio::ip::address::from_string("192.168.10.20"), 54321);
+ test_obj.set_client_endpoint(client_src_endpoint);
+
+ test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
+ boost::thread::id proc_id = boost::this_thread::get_id();
+
+ l7vs::tcp_data& con_data = test_obj.get_up_thread_data_dest_side();
+ boost::asio::ip::tcp::endpoint con_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP),DUMMI_SERVER_PORT);
+
+ //up_thread_data_dest_side set
+ con_data.initialize();
+ con_data.set_endpoint(con_end);
+ // thread_id set
+ test_obj.set_up_thread_id(boost::thread::id());
+ test_obj.set_down_thread_id(proc_id);
+ // socket set
+ l7vs::tcp_socket::connect_res = true;
+ l7vs::tcp_socket::connect_connect_endpoint = boost::asio::ip::tcp::endpoint();
+ l7vs::tcp_socket::connect_ec = NULL;
+ l7vs::tcp_socket::connect_call_check = false;
+ l7vs::tcp_socket::is_connect = true;
+ // vs set
+ vs.connection_active_list.clear();
+ // map set
+ std::map< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > >& rs_map = test_obj.get_up_thread_send_realserver_socket_map();
+ rs_map.clear();
+ // connection list set
+ l7vs::tcp_realserver_connect_socket_list& con_list = test_obj.get_down_thread_connect_socket_list();
+ con_list.clear();
+ //tcp_session set
+ test_obj.set_up_thread_next_function_call_exit();
+ test_obj.up_thread_realserver_connect_event_call_check = false;
+
+ // dummy server
+ test_mirror_server test_server;
+ // accept req
+ test_server.breq_acc_flag = true;
+ // close wait req
+ test_server.breq_close_wait_flag = true;
+ // recv cont
+ test_server.req_recv_cnt = 0;
+ // test server start
+ boost::thread server_thread(boost::bind(&test_mirror_server::run,&test_server));
+ while( !test_server.brun_flag ){
+ sleep(1);
+ }
+
+ test_obj.test_call();
+
+ BOOST_CHECK(con_end == l7vs::tcp_socket::connect_connect_endpoint);
+ BOOST_CHECK(l7vs::tcp_socket::connect_ec != NULL);
+ BOOST_CHECK(l7vs::tcp_socket::connect_call_check);
+
+ BOOST_CHECK(!con_list.empty());
+ std::pair<boost::asio::ip::tcp::endpoint,boost::shared_ptr<l7vs::tcp_socket> > set_socket = con_list.get_socket();
+ BOOST_CHECK(set_socket.first == con_end);
+ BOOST_CHECK(set_socket.second == rs_map.begin()->second);
+
+ std::string cl_rm_end = test_obj.get_test_string( client_src_endpoint );
+ std::string cl_lo_end = test_obj.get_test_string( listen_endpoint );
+ boost::asio::ip::tcp::endpoint rs_local = set_socket.second->get_socket().local_endpoint();
+ std::string rs_lo_end = test_obj.get_test_string( rs_local );
+ std::string rs_rm_end = test_obj.get_test_string( con_end );
+
+ // unit_test [1] up_thread_realserver_connect client endpoint string check
+ std::cout << "[1] up_thread_realserver_connect client endpoint string check" << std::endl;
+ BOOST_CHECK_EQUAL( cl_rm_end , plogger->putLog_cl_con_org );
+ // unit_test [2] up_thread_realserver_connect virtualservice endpoint string check
+ std::cout << "[2] up_thread_realserver_connect virtualservice endpoint string check" << std::endl;
+ BOOST_CHECK_EQUAL( cl_lo_end , plogger->putLog_vsinfo );
+ // unit_test [3] up_thread_realserver_connect realserver local endpoint string check
+ std::cout << "[3] up_thread_realserver_connect realserver local endpoint string check" << std::endl;
+ BOOST_CHECK_EQUAL( rs_lo_end , plogger->putLog_rs_con_org );
+ // unit_test [4] up_thread_realserver_connect realserver remote endpoint string check
+ std::cout << "[4] up_thread_realserver_connect realserver remote endpoint string check" << std::endl;
+ BOOST_CHECK_EQUAL( rs_rm_end , plogger->putLog_rs_con_dest );
+ // unit_test [5] up_thread_realserver_connect realserver local endpoint string check
+ std::cout << "[5] up_thread_realserver_connect realserver local endpoint string check" << std::endl;
+ BOOST_CHECK_EQUAL( "" , plogger->putLog_msg );
+
+ rs_map.clear();
+ con_list.clear();
+
+ set_socket.second->get_socket().close();
+
+ // dummy server stop
+ test_server.breq_close_wait_flag = false;
+ test_server.bstop_flag = true;
+ server_thread.join();
+
+ delete plogger;
+ plogger = NULL;
+
+ BOOST_MESSAGE( "----- up_thread_realserver_connect access log end -----" );
+}
//up_thread_sorryserver_connect test
//up_thread_sorryserver_connect test class
-// dummy client
-class test_client{
- public:
- //
- test_client(boost::asio::io_service& io_service, boost::asio::ssl::context& context) :
- my_socket(io_service,context){
- };
-
- ~test_client(){
- };
- void all_lock(){
-
- //! socket connect mutex
- connect_mutex.wrlock();
- //! socket handshake mutex
- handshake_mutex.wrlock();
- //! socket read mutex
- read_mutex.wrlock();
- //! socket write mutex
- write_mutex.wrlock();
- //! socket close mutex
- close_mutex.wrlock();
-
- }
-
- void handshake_test_run(){
- // dummy client start
-
- // connect
- {
- l7vs::rw_scoped_lock scope_lock(connect_mutex);
-
- if(!connect_test()){
- return;
- }
- }
-
- // handshake
- {
- l7vs::rw_scoped_lock scope_lock(handshake_mutex);
-
- if(!handshake_test()){
- return;
- }
- }
-
- // close
- {
- l7vs::rw_scoped_lock scope_lock(close_mutex);
- close_test();
- }
-
- };
-
- bool connect_test(){
- sleep(1);
- boost::system::error_code ec;
- std::cout << "dummy client connect try" << std::endl;
- boost::asio::ip::tcp::endpoint connect_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
- my_socket.lowest_layer().connect(connect_end,ec);
- if(ec){
- //receive error
- std::cout << "dummy client connect Error!" << std::endl;
- std::cout << ec << std::endl;
- return false;
- }
- std::cout << "dummy client connect OK" << std::endl;
- return true;
- };
-
- bool handshake_test(){
- boost::system::error_code ec;
- std::cout << "dummy client handshake try" << std::endl;
- my_socket.handshake(boost::asio::ssl::stream_base::client, ec);
- if(ec){
- //receive error
- std::cout << "dummy client handshake Error!" << std::endl;
- std::cout << ec << std::endl;
- return false;
- }
- std::cout << "dummy client handshake OK" << std::endl;
- return true;
- };
-
- bool send_test(){
- sleep(1);
- boost::system::error_code ec;
- std::cout << "dummy client write try" << std::endl;
- std::size_t write_size = my_socket.write_some(boost::asio::buffer(data_buff.data() + send_data_size,receive_data_size - send_data_size), ec);
- if(ec){
- //receive error
- std::cout << "dummy client send Error!" << std::endl;
- std::cout << ec << std::endl;
- return false;
- }
- send_data_size += write_size;
- std::cout << "dummy client send OK [" << send_data_size << "]" << std::endl;
- return true;
- };
- bool receive_test(){
- sleep(1);
- boost::system::error_code ec;
- std::cout << "dummy client read try" << std::endl;
- std::size_t read_size = my_socket.read_some(boost::asio::buffer(data_buff.data() + receive_data_size,MAX_BUFFER_SIZE), ec);
- if(ec){
- //receive error
- std::cout << "dummy client receive Error!" << std::endl;
- std::cout << ec << std::endl;
- return false;
- }
- receive_data_size += read_size;
- std::cout << "dummy client receive OK [" << receive_data_size << "]" << std::endl;
- return true;
- };
- void close_test(){
- sleep(1);
- boost::system::error_code ec;
- std::cout << "dummy client close try" << std::endl;
- my_socket.lowest_layer().close(ec);
- if(ec){
- //close error
- std::cout << "dummy client close Error!" << std::endl;
- std::cout << ec << std::endl;
- return;
- }
- std::cout << "dummy client close OK" << std::endl;
- };
-
- boost::asio::ssl::stream<boost::asio::ip::tcp::socket> my_socket;
- boost::array<char,MAX_BUFFER_SIZE> data_buff;
- std::size_t receive_data_size;
- std::size_t send_data_size;
-
- //! socket connect mutex
- l7vs::wr_mutex connect_mutex;
- //! socket handshake mutex
- l7vs::wr_mutex handshake_mutex;
- //! socket read mutex
- l7vs::wr_mutex read_mutex;
- //! socket write mutex
- l7vs::wr_mutex write_mutex;
- //! socket close mutex
- l7vs::wr_mutex close_mutex;
-};
-
-class authority{
- public:
- authority(){
- };
- ~authority(){
- };
- std::string get_password() const{
- std::cout << "call get_password" << std::endl;
- return "test";
- };
-};
// ssl_clear_keep_cache test class
~ssl_clear_keep_cache_test_class(){};
bool& get_exit_flag(){
- return exit_flag;
+ return (bool&)exit_flag;
};
bool test_call(SSL *clear_ssl){
BOOST_CHECK(test_sock.impl()->ssl->rstate == SSL_ST_READ_HEADER); // SSL_ST_READ_HEADER;
// unit_test [18] ssl_clear_keep_cache state initialize check
std::cout << "[18] ssl_clear_keep_cache state initialize check" << std::endl;
- BOOST_CHECK(test_sock.impl()->ssl->state == SSL_ST_BEFORE | SSL_ST_ACCEPT); // SSL_ST_BEFORE | ( ( clear_ssl->server ) ? SSL_ST_ACCEPT : SSL_ST_CONNECT);
+ BOOST_CHECK(test_sock.impl()->ssl->state == (SSL_ST_BEFORE | SSL_ST_ACCEPT)); // SSL_ST_BEFORE | ( ( clear_ssl->server ) ? SSL_ST_ACCEPT : SSL_ST_CONNECT);
// accepter close
void handle_ssl_handshake_timer(const boost::system::error_code&){
handle_ssl_handshake_timer_call_chk = true;
- return handle_ssl_handshake_timer_res;
};
bool handle_ssl_handshake_timer_call_chk;
- bool handle_ssl_handshake_timer_res;
up_thread_function_pair& get_up_thread_next_call_function(){
return up_thread_next_call_function;
return ssl_flag;
};
+ bool& get_ssl_handshake_timer_flag(){
+ return ssl_handshake_timer_flag;
+ };
+
+ int& get_ssl_handshake_time_out(){
+ return ssl_handshake_time_out;
+ };
+
bool& get_ssl_handshake_time_out_flag(){
return ssl_handshake_time_out_flag;
};
+ bool next_func_chk_accept_event(){
+ return up_thread_next_call_function.first == UP_FUNC_CLIENT_ACCEPT_EVENT;
+ };
+ bool next_func_chk_accept(){
+ return up_thread_next_call_function.first == UP_FUNC_CLIENT_ACCEPT;
+ };
+ bool next_func_chk_client_disconnect(){
+ return up_thread_next_call_function.first == UP_FUNC_CLIENT_DISCONNECT;
+ };
+
+ l7vs::tcp_ssl_socket& get_tcp_client_ssl_socket(){
+ return client_ssl_socket;
+ };
+
};
void up_thread_client_accept_test(){
BOOST_MESSAGE( "----- up_thread_client_accept test start -----" );
// test case 1 not ssl mode
test_obj.test_call();
- BOOST_CHECK( test_obj.get_up_thread_next_call_function().first == l7vs::tcp_session::UP_FUNC_CLIENT_ACCEPT_EVENT);
+ // unit_test [1] up_thread_client_accept no ssl mode next func check
+ std::cout << "[1] up_thread_client_accept no ssl mode next func check" << std::endl;
+ BOOST_CHECK( test_obj.next_func_chk_accept_event() );
+
+ // tset case 2 ssl mode and handshaek time out
+ test_obj.get_ssl_flag() = true; //SSL mode
+ test_obj.get_ssl_handshake_time_out_flag() = true; //handshake time out
+
+ test_obj.test_call();
+
+ // unit_test [2] up_thread_client_accept ssl mode time out case next func check
+ std::cout << "[2] up_thread_client_accept ssl mode time out case next func check" << std::endl;
+ BOOST_CHECK( test_obj.next_func_chk_client_disconnect() );
+
+
+ // tset case 3 ssl mode and set timer snd handshake try_again error case check
+ test_obj.get_ssl_flag() = true; //SSL mode
+ test_obj.get_ssl_handshake_time_out_flag() = false; //handshake time out
+ test_obj.get_ssl_handshake_timer_flag() = false; //timer not set
+ test_obj.get_ssl_handshake_time_out() = 3; //timer set second
+ test_obj.handle_ssl_handshake_timer_call_chk = false;
+ test_obj.get_tcp_client_ssl_socket().handshake_call_check = false;
+ test_obj.get_tcp_client_ssl_socket().handshake_res = false;
+ test_obj.get_tcp_client_ssl_socket().handshake_set_ec = boost::asio::error::try_again;
+ test_obj.test_call();
+ // timer thread start
+ boost::thread timer_thread(boost::bind(&boost::asio::io_service::run,&io));
+ // unit_test [3] up_thread_client_accept set timer check
+ std::cout << "[3] up_thread_client_accept set timer check" << std::endl;
+ BOOST_CHECK( test_obj.get_ssl_handshake_timer_flag() == true);
+ // after 1 second
+ sleep(1);
+ std::cout << "1 sec" << std::endl;
+ BOOST_CHECK( test_obj.handle_ssl_handshake_timer_call_chk == false );
+ // after 2 second
+ sleep(1);
+ std::cout << "2 sec" << std::endl;
+ BOOST_CHECK( test_obj.handle_ssl_handshake_timer_call_chk == false );
+ // after 3 second
+ sleep(1);
+ std::cout << "3 sec" << std::endl;
+ BOOST_CHECK( test_obj.handle_ssl_handshake_timer_call_chk == true );
+ timer_thread.join();
+ // unit_test [4] up_thread_client_accept socket handshake call check
+ std::cout << "[4] up_thread_client_accept socket handshake call check" << std::endl;
+ BOOST_CHECK( test_obj.get_tcp_client_ssl_socket().handshake_call_check == true );
- BOOST_MESSAGE( "----- up_thread_client_accept test end -----" );
-}
+ // unit_test [5] up_thread_client_accept socket handshake try_again error next func check
+ std::cout << "[5] up_thread_client_accept socket handshake try_again error next func check" << std::endl;
+ BOOST_CHECK( test_obj.next_func_chk_accept() );
-test_suite* init_unit_test_suite( int argc, char* argv[] ){
- test_suite* ts = BOOST_TEST_SUITE( "l7vs::tcp_socket class test" );
-/*
- ts->add( BOOST_TEST_CASE( &constructer_test ) );
- ts->add( BOOST_TEST_CASE( &initialize_test ) );
- ts->add( BOOST_TEST_CASE( &initialize_ssl_mode_test ) );
- ts->add( BOOST_TEST_CASE( &ssl_clear_keep_cache_test ) );
- ts->add( BOOST_TEST_CASE( &get_client_socket_test) );
- ts->add( BOOST_TEST_CASE( &handle_ssl_handshake_timer_test) );
- ts->add( BOOST_TEST_CASE( &is_thread_wait_test) );
- ts->add( BOOST_TEST_CASE( &set_virtual_service_message_test) );
+ // tset case 4 ssl mode and handshake ok case check
+ test_obj.get_ssl_flag() = true; //SSL mode
+ test_obj.get_ssl_handshake_time_out_flag() = false; //handshake time out
+ test_obj.get_ssl_handshake_timer_flag() = true; //timer not set
+ test_obj.get_ssl_handshake_time_out() = 3; //timer set second
+ test_obj.handle_ssl_handshake_timer_call_chk = false;
+ test_obj.get_tcp_client_ssl_socket().handshake_call_check = false;
+ test_obj.get_tcp_client_ssl_socket().handshake_res = true;
+ test_obj.get_tcp_client_ssl_socket().handshake_set_ec.clear();
- ts->add( BOOST_TEST_CASE( &up_thread_run_test) );
- ts->add( BOOST_TEST_CASE( &down_thread_run_test) );
- ts->add( BOOST_TEST_CASE( &thread_state_update_test) );
- ts->add( BOOST_TEST_CASE( &up_thread_client_respond_test) );
- ts->add( BOOST_TEST_CASE( &up_thread_realserver_get_detination_event_test) );
- ts->add( BOOST_TEST_CASE( &up_thread_sorryserver_get_detination_event_test) );
- ts->add( BOOST_TEST_CASE( &up_thread_all_socket_close_test) );
- ts->add( BOOST_TEST_CASE( &down_thread_all_socket_close_test) );
- ts->add( BOOST_TEST_CASE( &up_thread_client_disconnect_test) );
- ts->add( BOOST_TEST_CASE( &down_thread_client_disconnect_test) );
- ts->add( BOOST_TEST_CASE( &up_thread_sorryserver_disconnect_test) );
- ts->add( BOOST_TEST_CASE( &down_thread_sorryserver_disconnect_test) );
- ts->add( BOOST_TEST_CASE( &up_thread_realserver_connect_event_test) );
- ts->add( BOOST_TEST_CASE( &up_thread_sorryserver_connect_event_test) );
- ts->add( BOOST_TEST_CASE( &down_thread_client_connection_chk_event_test) );
- ts->add( BOOST_TEST_CASE( &up_thread_realserver_connection_fail_event_test) );
- ts->add( BOOST_TEST_CASE( &up_thread_sorryserver_connection_fail_event_test) );
+ test_obj.test_call();
- ts->add( BOOST_TEST_CASE( &up_thread_client_receive_test) );
- ts->add( BOOST_TEST_CASE( &down_thread_realserver_receive_test) );
- ts->add( BOOST_TEST_CASE( &down_thread_sorryserver_receive_test) );
- ts->add( BOOST_TEST_CASE( &up_thread_realserver_send_test) );
- ts->add( BOOST_TEST_CASE( &up_thread_sorryserver_send_test) );
- ts->add( BOOST_TEST_CASE( &down_thread_client_send_test) );
- ts->add( BOOST_TEST_CASE( &up_thread_realserver_connect_test) );
- ts->add( BOOST_TEST_CASE( &up_thread_sorryserver_connect_test) );
- ts->add( BOOST_TEST_CASE( &up_thread_realserver_disconnect_test) );
- ts->add( BOOST_TEST_CASE( &down_thread_realserver_disconnect_test) );
- ts->add( BOOST_TEST_CASE( &up_thread_all_realserver_disconnect_test) );
- ts->add( BOOST_TEST_CASE( &down_thread_all_realserver_disconnect_test) );
+ // unit_test [6] up_thread_client_accept socket handshake no error next func check
+ std::cout << "[6] up_thread_client_accept socket handshake no error next func check" << std::endl;
+ BOOST_CHECK( test_obj.next_func_chk_accept_event() );
- ts->add( BOOST_TEST_CASE( &up_thread_exit_test ) );
- ts->add( BOOST_TEST_CASE( &down_thread_exit_test ) );
- ts->add( BOOST_TEST_CASE( &up_thread_client_disconnect_event_test ) );
- ts->add( BOOST_TEST_CASE( &down_thread_client_disconnect_event_test ) );
- ts->add( BOOST_TEST_CASE( &up_thread_realserver_disconnect_event_test ) );
- ts->add( BOOST_TEST_CASE( &down_thread_realserver_disconnect_event_test ) );
- ts->add( BOOST_TEST_CASE( &up_thread_sorryserver_disconnect_event_test ) );
- ts->add( BOOST_TEST_CASE( &down_thread_sorryserver_disconnect_event_test ) );
- ts->add( BOOST_TEST_CASE( &up_thread_sorryserver_mod_disconnect_test ) );
- ts->add( BOOST_TEST_CASE( &down_thread_sorryserver_mod_disconnect_test ) );
- ts->add( BOOST_TEST_CASE( &up_thread_sorry_enable_event_test ) );
- ts->add( BOOST_TEST_CASE( &up_thread_sorry_disable_event_test ) );
- ts->add( BOOST_TEST_CASE( &down_thread_sorry_enable_event_test ) );
- ts->add( BOOST_TEST_CASE( &down_thread_sorry_disable_event_test ) );
- ts->add( BOOST_TEST_CASE( &up_thread_client_accept_event_test ) );
- ts->add( BOOST_TEST_CASE( &up_thread_client_respond_event_test ) );
- ts->add( BOOST_TEST_CASE( &down_thread_client_respond_event_test ) );
-*/
+ // tset case 5 ssl mode and handshake error case check
+ test_obj.get_ssl_flag() = true; //SSL mode
+ test_obj.get_ssl_handshake_time_out_flag() = false; //handshake time out
+ test_obj.get_ssl_handshake_timer_flag() = true; //timer not set
+ test_obj.get_ssl_handshake_time_out() = 3; //timer set second
+ test_obj.handle_ssl_handshake_timer_call_chk = false;
+ test_obj.get_tcp_client_ssl_socket().handshake_call_check = false;
+ test_obj.get_tcp_client_ssl_socket().handshake_res = false;
+ test_obj.get_tcp_client_ssl_socket().handshake_set_ec = boost::asio::error::eof;
- ts->add( BOOST_TEST_CASE( &up_thread_client_accept_test ) );
-// ts->add( BOOST_TEST_CASE( &up_thread_run_ssl_mode_test) );
+ test_obj.test_call();
+
+ // unit_test [7] up_thread_client_accept socket handshake no error next func check
+ std::cout << "[7] up_thread_client_accept socket handshake no error next func check" << std::endl;
+ BOOST_CHECK( test_obj.next_func_chk_client_disconnect() );
+
+ BOOST_MESSAGE( "----- up_thread_client_accept test end -----" );
+}
+// up_thread_run ssl mode
+// up_thread_run ssl mode test class
+class up_thread_run_ssl_mode_test_class : public l7vs::tcp_session{
+ public:
+ up_thread_run_ssl_mode_test_class(
+ l7vs::virtualservice_tcp& vs,
+ boost::asio::io_service& session_io,
+ l7vs::tcp_socket_option_info& set_socket_option,
+ boost::asio::ip::tcp::endpoint listen_endpoint,
+ bool ssl_mode,
+ boost::asio::ssl::context& set_ssl_context,
+ bool set_ssl_cache_flag,
+ int set_ssl_handshake_time_out,
+ l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
+ session_io,
+ set_socket_option,
+ listen_endpoint,
+ ssl_mode,
+ set_ssl_context,
+ set_ssl_cache_flag,
+ set_ssl_handshake_time_out,
+ set_access_logger){
+ test_end = false;
+ test_wait = true;
+ };
+ ~up_thread_run_ssl_mode_test_class(){};
+ bool& get_exit_flag(){
+ return (bool&)exit_flag;
+ };
+
+/*
+ bool& get_session_pause_flag(){
+ return session_pause_flag;
+ };
+*/
+
+/*
+ std::bitset<TCP_SESSION_THREAD_STATE_BIT>& get_thread_state(){
+ return thread_state;
+ };
+*/
+
+ boost::mutex test_thread_wait;
+ void test_run(){
+ boost::mutex::scoped_lock scope_lock(test_thread_wait);
+ while(!test_end){
+ std::cout << "up_thread_run test call" << std::endl;
+ test_wait = true;
+ up_thread_run();
+ while(test_wait){};
+ }
+ };
+ bool test_end;
+ bool test_wait;
+
+ void set_protocol_module(l7vs::protocol_module_base* set_proto){
+ protocol_module = set_proto;
+ };
+
+ boost::asio::ssl::stream<boost::asio::ip::tcp::socket>& get_client_socket(){
+ return client_ssl_socket.get_socket();
+ };
+
+
+ boost::thread::id& get_up_thread_id(){
+ return up_thread_id;
+ };
+
+ boost::thread::id& get_down_thread_id(){
+ return down_thread_id;
+ };
+
+ void up_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
+ up_thread_exit_process_type = process_type;
+ l7vs::tcp_session::up_thread_exit(process_type);
+ up_thread_exit_call_check = true;
+ };
+ TCP_PROCESS_TYPE_TAG up_thread_exit_process_type;
+ bool up_thread_exit_call_check;
+
+ void up_thread_all_socket_close(void){
+ up_thread_all_socket_close_call_check = true;
+ };
+ bool up_thread_all_socket_close_call_check;
+
+ void test_message_set(boost::asio::ip::tcp::endpoint set_endpoint){
+ l7vs::tcp_thread_message* chk_msg = new l7vs::tcp_thread_message;
+ up_thread_message_que.push(chk_msg);
+ chk_msg->endpoint_info = set_endpoint;
+ up_thread_function_pair func = up_thread_function_array[UP_FUNC_EXIT];
+ chk_msg->message = func.second;
+ };
+
+ l7vs::tcp_data& get_up_thread_message_data(){
+ return up_thread_message_data;
+ };
+
+ void clear_function_array(){
+ for(int i = 0;i <= UP_FUNC_EXIT;i++){
+ up_thread_function_array[i].second = NULL;
+ }
+ };
+ void clear_event_map(){
+ up_thread_module_event_map.clear();
+ };
+
+ void set_up_thread_next_call_function_client_disconnect(){
+ up_thread_next_call_function = up_thread_function_array[UP_FUNC_CLIENT_DISCONNECT];
+ };
+ void set_up_thread_next_call_function_exit(){
+ up_thread_next_call_function = up_thread_function_array[UP_FUNC_EXIT];
+ };
+
+};
+void up_thread_run_ssl_mode_test(){
+
+ BOOST_MESSAGE( "----- up_thread_run ssl mode test start -----" );
+
+ boost::asio::io_service io;
+ l7vs::virtualservice_tcp vs;
+ l7vs::tcp_socket_option_info set_option;
+ //! TCP_NODELAY (false:not set,true:set option)
+ set_option.nodelay_opt = false;
+ //! TCP_NODELAY option value (false:off,true:on)
+ set_option.nodelay_val = false;
+ //! TCP_CORK (false:not set,true:set option)
+ set_option.cork_opt = false;
+ //! TCP_CORK option value (false:off,true:on)
+ set_option.cork_val = false;
+ //! TCP_QUICKACK (false:not set,true:set option)
+ set_option.quickack_opt = false;
+ //! TCP_QUICKACK option value (false:off,true:on)
+ set_option.quickack_val = false;
+ //
+ boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
+ bool set_mode(true);
+ boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
+ bool set_ssl_cache_flag(false);
+ int set_ssl_handshake_time_out = 0;
+ //std::string access_log_file_name = "test";
+ l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
+
+ boost::system::error_code ec;
+
+ std::string test_protocol_name("test protocol");
+ l7vs::test_protocol_module proto_test(test_protocol_name);
+
+ up_thread_run_ssl_mode_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
+
+ test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
+ bool& exit_flag = test_obj.get_exit_flag();
+// bool& session_pause_flag = test_obj.get_session_pause_flag();
+ boost::thread::id& up_thread_id = test_obj.get_up_thread_id();
+ boost::thread::id& down_thread_id = test_obj.get_down_thread_id();
+
+
+// std::bitset<TCP_SESSION_THREAD_STATE_BIT>& thread_state = test_obj.get_thread_state();
+ boost::asio::ssl::stream<boost::asio::ip::tcp::socket>& client_socket = test_obj.get_client_socket();
+
+ test_mirror_server test_server;
+ // accept req
+ test_server.breq_acc_flag = true;
+ // close wait req
+ test_server.breq_close_wait_flag = true;
+ // recv cont
+ test_server.req_recv_cnt = 0;
+ // test server start
+ boost::thread server_thread(boost::bind(&test_mirror_server::run,&test_server));
+ while( !test_server.brun_flag ){
+ sleep(1);
+ }
+
+ boost::asio::ip::tcp::endpoint connect_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
+ client_socket.lowest_layer().connect(connect_end,ec);
+ BOOST_CHECK(!ec);
+ while(!test_server.bconnect_flag){
+ sleep(1);
+ }
+
+ test_obj.test_thread_wait.lock();
+/*
+ thread_state[0] = 0; // UP_THREAD_ALIVE
+ thread_state[1] = 0; // DOWN_THREAD_ALIVE
+ thread_state[2] = 0; // UP_THREAD_ACTIVE
+ thread_state[3] = 0; // DOWN_THREAD_ACTIVE
+ thread_state[4] = 0; // UP_THREAD_LOCK
+ thread_state[5] = 0; // DOWN_THREAD_LOCK
+*/
+ up_thread_id = boost::thread::id();
+ boost::thread test_thread(boost::bind(&up_thread_run_ssl_mode_test_class::test_run,&test_obj));
+ sleep(1);
+ boost::thread::id test_id = test_thread.get_id();
+ boost::thread::id proc_id = boost::this_thread::get_id();
+
+/*
+ BOOST_CHECK(!thread_state.test(0)); // UP_THREAD_ALIVE
+ BOOST_CHECK(!thread_state.test(1)); // DOWN_THREAD_ALIVE
+ BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
+ BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
+ BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
+ BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
+*/
+ BOOST_CHECK(up_thread_id != test_id);
+ test_obj.test_thread_wait.unlock();
+ sleep(1);
+
+ // unit_test [1] up_thread_run ssl mode test thread id update check
+ std::cout << "[1] up_thread_run ssl mode test thread id update check" << std::endl;
+ BOOST_CHECK(up_thread_id == test_id);
+
+ // unit_test [2] up_thread_run ssl mode test down thread wait check
+ std::cout << "[2] up_thread_run ssl mode test down thread wait check" << std::endl;
+/*
+ BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
+ BOOST_CHECK(!thread_state.test(1)); // DOWN_THREAD_ALIVE
+ BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
+ BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
+ BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
+ BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
+*/
+
+ proto_test.handle_session_initialize_res_tag = l7vs::protocol_module_base::FINALIZE;
+ proto_test.handle_session_initialize_in_up_thread_id = boost::thread::id();
+ proto_test.handle_session_initialize_in_down_thread_id = boost::thread::id();
+ proto_test.handle_session_initialize_in_client_endpoint_tcp = boost::asio::ip::tcp::endpoint();
+ proto_test.handle_session_initialize_in_client_endpoint_udp.address(boost::asio::ip::address::from_string("255.255.255.255"));
+ proto_test.handle_session_initialize_in_client_endpoint_udp.port(65535);
+ BOOST_CHECK(proto_test.handle_session_initialize_in_up_thread_id != test_id);
+ BOOST_CHECK(proto_test.handle_session_initialize_in_down_thread_id != proc_id);
+ BOOST_CHECK(proto_test.handle_session_initialize_in_client_endpoint_tcp != connect_end);
+ BOOST_CHECK(proto_test.handle_session_initialize_in_client_endpoint_udp != boost::asio::ip::udp::endpoint());
+ down_thread_id = proc_id;
+// session_pause_flag = true;
+
+ // DOWN_THREAD_ALIVE
+// thread_state[1] = 1;
+ sleep(1);
+
+ // unit_test [3] up_thread_run ssl mode test handle_session_initialize call check
+ std::cout << "[3] up_thread_run ssl mode test handle_session_initialize call check" << std::endl;
+ BOOST_CHECK(proto_test.handle_session_initialize_in_up_thread_id == test_id);
+ BOOST_CHECK(proto_test.handle_session_initialize_in_down_thread_id == proc_id);
+ BOOST_CHECK(proto_test.handle_session_initialize_in_client_endpoint_tcp == connect_end);
+ BOOST_CHECK(proto_test.handle_session_initialize_in_client_endpoint_udp == boost::asio::ip::udp::endpoint());
+
+ // unit_test [4] up_thread_run ssl mode test state update(UP_THREAD_ACTIVE) check
+ std::cout << "[4] up_thread_run ssl mode test state update(UP_THREAD_ACTIVE) check" << std::endl;
+// BOOST_CHECK(thread_state.test(2)); // UP_THREAD_ACTIVE
+
+ // unit_test [5] up_thread_run ssl mode test pause check
+ std::cout << "[5] up_thread_run ssl mode test pause check" << std::endl;
+// BOOST_CHECK(thread_state.test(4)); // UP_THREAD_LOCK
+
+ test_obj.up_thread_exit_process_type = l7vs::tcp_session::MESSAGE_PROC;
+ test_obj.up_thread_exit_call_check = false;
+ test_obj.up_thread_all_socket_close_call_check = false;
+
+// session_pause_flag = false;
+ sleep(1);
+
+ // unit_test [6] up_thread_run ssl mode test restart check
+ std::cout << "[6] up_thread_run ssl mode test restart check" << std::endl;
+// BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
+
+ // unit_test [7] up_thread_run ssl mode test up_thread_next_call_function call (up_thread_exit) check
+ std::cout << "[7] up_thread_run ssl mode test up_thread_next_call_function call (up_thread_exit) check" << std::endl;
+ BOOST_CHECK(test_obj.up_thread_exit_call_check);
+ BOOST_CHECK(test_obj.up_thread_exit_process_type == l7vs::tcp_session::LOCAL_PROC);
+
+ // unit_test [8] up_thread_run ssl mode test main loop exit check
+ std::cout << "[8] up_thread_run ssl mode test main loop exit check" << std::endl;
+ BOOST_CHECK(exit_flag);
+// BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
+
+
+ // unit_test [9] up_thread_run ssl mode test up_thread_all_socket_close_call_check call check
+ std::cout << "[9] up_thread_run ssl mode test up_thread_all_socket_close_call_check call check" << std::endl;
+ BOOST_CHECK(test_obj.up_thread_all_socket_close_call_check);
+
+ // unit_test [10] up_thread_run ssl mode test down thread end wait check
+ std::cout << "[10] up_thread_run ssl mode test down thread wait check" << std::endl;
+/*
+ BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
+ BOOST_CHECK(thread_state.test(1)); // DOWN_THREAD_ALIVE
+ BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
+ BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
+ BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
+ BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
+*/
+
+
+// proto_test.handle_session_finalize_in_up_thread_id = boost::thread::id();
+// proto_test.handle_session_finalize_in_down_thread_id = boost::thread::id();
+// BOOST_CHECK(proto_test.handle_session_finalize_in_up_thread_id != test_id);
+// BOOST_CHECK(proto_test.handle_session_finalize_in_down_thread_id != proc_id);
+// vs.release_session_ptr = NULL;
+// BOOST_CHECK(vs.release_session_ptr != test_id);
+
+// thread_state[1] = 0;
+ sleep(1);
+
+ // unit_test [11] up_thread_run ssl mode test handle_session_finalize call check
+ std::cout << "[11] up_thread_run ssl mode test handle_session_finalize call check" << std::endl;
+ BOOST_CHECK(proto_test.handle_session_finalize_in_up_thread_id == test_id);
+ BOOST_CHECK(proto_test.handle_session_finalize_in_down_thread_id == proc_id);
+
+ // unit_test [12] up_thread_run ssl mode test release_session_id call check
+ std::cout << "[12] up_thread_run ssl mode test release_session_id call check" << std::endl;
+// BOOST_CHECK(vs.release_session_id == test_id);
+
+ // unit_test [13] up_thread_run ssl mode test state update(UP_THREAD_ACTIVE) check
+ std::cout << "[13] up_thread_run state update(UP_THREAD_ACTIVE) check" << std::endl;
+// BOOST_CHECK(!thread_state.test(0)); // UP_THREAD_ACTIVE
+
+ // message call test
+ exit_flag = false;
+// session_pause_flag = false;
+ l7vs::tcp_data& msg_data = test_obj.get_up_thread_message_data();
+ test_obj.test_message_set(connect_end);
+/*
+ thread_state[0] = 0; // UP_THREAD_ALIVE
+ thread_state[1] = 1; // DOWN_THREAD_ALIVE
+ thread_state[2] = 0; // UP_THREAD_ACTIVE
+ thread_state[3] = 0; // DOWN_THREAD_ACTIVE
+ thread_state[4] = 0; // UP_THREAD_LOCK
+ thread_state[5] = 0; // DOWN_THREAD_LOCK
+*/
+ msg_data.set_endpoint(boost::asio::ip::tcp::endpoint());
+ test_obj.up_thread_exit_call_check = false;
+ test_obj.up_thread_exit_process_type = l7vs::tcp_session::LOCAL_PROC;
+ proto_test.handle_session_initialize_res_tag = l7vs::protocol_module_base::CLIENT_DISCONNECT;
+
+ // test thread start
+ test_obj.test_wait = false;
+ sleep(1);
+/*
+ BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
+ BOOST_CHECK(thread_state.test(1)); // DOWN_THREAD_ALIVE
+ BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
+ BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
+ BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
+ BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
+*/
+
+ // unit_test [14] up_thread_run ssl mode test message call check
+ std::cout << "[14] up_thread_run ssl mode test message call check" << std::endl;
+ BOOST_CHECK(test_obj.up_thread_exit_call_check);
+ BOOST_CHECK(test_obj.up_thread_exit_process_type == l7vs::tcp_session::MESSAGE_PROC);
+
+ proto_test.handle_session_initialize_res_tag = l7vs::protocol_module_base::FINALIZE;
+// thread_state[1] = 0;
+ sleep(1);
+
+ // error test not find function map
+ test_obj.clear_function_array();
+ exit_flag = false;
+// session_pause_flag = false;
+// thread_state[1] = 1;
+
+ l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
+ l7vs::Logger::putLogError_id = 0;
+
+ test_obj.test_wait = false;
+ sleep(1);
+
+ // unit_test [15] up_thread_run ssl mode test not find function map error test
+ std::cout << "[15] up_thread_run ssl mode test not find function map error test" << std::endl;
+ BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
+ BOOST_CHECK_EQUAL(15,l7vs::Logger::putLogError_id);
+ std::cout << l7vs::Logger::putLogError_message << std::endl;
+
+// thread_state[1] = 0;
+ sleep(1);
+
+ //error test protocol_module returnd illegal EVENT_TAG
+ test_obj.clear_event_map();
+ exit_flag = false;
+// session_pause_flag = false;
+// thread_state[1] = 1;
+
+ l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
+ l7vs::Logger::putLogError_id = 0;
+
+ test_obj.test_wait = false;
+ sleep(1);
+
+ // unit_test [16] up_thread_run ssl mode test protocol_module returnd illegal EVENT_TAG error test
+ std::cout << "[16] up_thread_run ssl mode test protocol_module returnd illegal EVENT_TAG error test" << std::endl;
+ BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
+ BOOST_CHECK_EQUAL(14,l7vs::Logger::putLogError_id);
+ std::cout << l7vs::Logger::putLogError_message << std::endl;
+
+// thread_state[1] = 0;
+ sleep(1);
+
+
+ // unit_test [17] up_thread_run ssl mode test set non blocking fail check
+ std::cout << "[17] up_thread_run ssl mode test set non blocking fail check" << std::endl;
+ exit_flag = false;
+// session_pause_flag = false;
+// thread_state[1] = 1;
+
+ l7vs::tcp_socket::set_non_blocking_mode_res = false;
+ l7vs::tcp_socket::set_non_blocking_mode_ec = boost::asio::error::bad_descriptor;
+ l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
+ l7vs::Logger::putLogError_id = 0;
+
+ test_obj.test_wait = false;
+ sleep(1);
+
+ BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
+ BOOST_CHECK_EQUAL(11,l7vs::Logger::putLogError_id);
+ std::cout << l7vs::Logger::putLogError_message << std::endl;
+ l7vs::tcp_socket::set_non_blocking_mode_res = true;
+ l7vs::tcp_socket::set_non_blocking_mode_ec.clear();
+
+// thread_state[1] = 0;
+ sleep(1);
+
+ //error test client endpoint get error
+ client_socket.lowest_layer().close(ec);
+ exit_flag = false;
+// session_pause_flag = false;
+// thread_state[1] = 1;
+
+ l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
+ l7vs::Logger::putLogError_id = 0;
+
+ test_obj.test_wait = false;
+ sleep(1);
+
+ // unit_test [18] up_thread_run ssl mode test client endpoint get error test
+ std::cout << "[18] up_thread_run ssl mode test client endpoint get error test" << std::endl;
+ BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
+ BOOST_CHECK_EQUAL(9,l7vs::Logger::putLogError_id);
+ std::cout << l7vs::Logger::putLogError_message << std::endl;
+
+// thread_state[1] = 0;
+ sleep(1);
+
+ //error test protocol module null error
+ test_obj.set_protocol_module(NULL);
+ exit_flag = false;
+// session_pause_flag = false;
+// thread_state[1] = 1;
+
+ l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
+ l7vs::Logger::putLogError_id = 0;
+
+ test_obj.test_wait = false;
+ sleep(1);
+
+ // unit_test [19] up_thread_run ssl mode test protocol module null error test
+ std::cout << "[19] up_thread_run ssl mode test protocol module null error test" << std::endl;
+ BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
+ BOOST_CHECK_EQUAL(8,l7vs::Logger::putLogError_id);
+ std::cout << l7vs::Logger::putLogError_message << std::endl;
+
+// thread_state[1] = 0;
+ sleep(1);
+
+ test_obj.test_end = true;
+ test_obj.test_wait = false;
+ std::cout << "test_thread.join wait" << std::endl;
+ test_thread.join();
+ std::cout << "test_thread.join ok" << std::endl;
+
+
+ test_server.breq_close_wait_flag = false;
+ test_server.bstop_flag = true;
+ std::cout << "server_thread.join wait" << std::endl;
+ server_thread.join();
+ std::cout << "server_thread.join ok" << std::endl;
+
+
+ BOOST_MESSAGE( "----- up_thread_run ssl mode test end -----" );
+
+}
+// endpoint_to_string test
+// endpoint_to_string test class
+class endpoint_to_string_test_class : public l7vs::tcp_session{
+ public:
+ endpoint_to_string_test_class(
+ l7vs::virtualservice_tcp& vs,
+ boost::asio::io_service& session_io,
+ l7vs::tcp_socket_option_info& set_socket_option,
+ boost::asio::ip::tcp::endpoint listen_endpoint,
+ bool ssl_mode,
+ boost::asio::ssl::context& set_ssl_context,
+ bool set_ssl_cache_flag,
+ int set_ssl_handshake_time_out,
+ l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
+ session_io,
+ set_socket_option,
+ listen_endpoint,
+ ssl_mode,
+ set_ssl_context,
+ set_ssl_cache_flag,
+ set_ssl_handshake_time_out,
+ set_access_logger){};
+ ~endpoint_to_string_test_class(){};
+
+ std::string test_call(boost::asio::ip::tcp::endpoint& test_endpoint){
+ return endpoint_to_string(test_endpoint);
+ };
+
+};
+void endpoint_to_string_test(){
+
+ BOOST_MESSAGE( "----- endpoint_to_string test start -----" );
+
+ boost::asio::io_service io;
+ l7vs::virtualservice_tcp vs;
+ l7vs::tcp_socket_option_info set_option;
+ //! TCP_NODELAY (false:not set,true:set option)
+ set_option.nodelay_opt = false;
+ //! TCP_NODELAY option value (false:off,true:on)
+ set_option.nodelay_val = false;
+ //! TCP_CORK (false:not set,true:set option)
+ set_option.cork_opt = false;
+ //! TCP_CORK option value (false:off,true:on)
+ set_option.cork_val = false;
+ //! TCP_QUICKACK (false:not set,true:set option)
+ set_option.quickack_opt = false;
+ //! TCP_QUICKACK option value (false:off,true:on)
+ set_option.quickack_val = false;
+ //
+ boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
+ bool set_mode(true);
+ boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
+ bool set_ssl_cache_flag(false);
+ int set_ssl_handshake_time_out = 0;
+ //std::string access_log_file_name = "test";
+ l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
+
+ boost::system::error_code ec;
+
+ endpoint_to_string_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
+
+ // unit_test [1] endpoint_to_string test IPv4 Address case 1(192.168.0.1:8080) test
+ std::cout << "[1] endpoint_to_string test IPv4 Address case 1(192.168.0.1:8080) test" << std::endl;
+ {
+ boost::asio::ip::tcp::endpoint test_endpoint(boost::asio::ip::address::from_string("192.168.0.1"), 8080);
+ std::string ref("192.168.0.1:8080");
+ std::string test_string = test_obj.test_call(test_endpoint);
+ BOOST_CHECK_EQUAL(ref,test_string);
+ }
+ // unit_test [2] endpoint_to_string test IPv4 Address case 2(0.0.0.0:0) test
+ std::cout << "[2] endpoint_to_string test IPv4 Address case 2(0.0.0.0:0) test" << std::endl;
+ {
+ boost::asio::ip::tcp::endpoint test_endpoint(boost::asio::ip::address::from_string("0.0.0.0"), 0);
+ std::string ref("0.0.0.0:0");
+ std::string test_string = test_obj.test_call(test_endpoint);
+ BOOST_CHECK_EQUAL(ref,test_string);
+ }
+ // unit_test [3] endpoint_to_string test IPv4 Address case 3(255.255.255.255:65535) test
+ std::cout << "[3] endpoint_to_string test IPv4 Address case 3(255.255.255.255:65535) test" << std::endl;
+ { boost::asio::ip::tcp::endpoint test_endpoint(boost::asio::ip::address::from_string("255.255.255.255"), 65535);
+ std::string ref("255.255.255.255:65535");
+ std::string test_string = test_obj.test_call(test_endpoint);
+ BOOST_CHECK_EQUAL(ref,test_string);
+ }
+ // unit_test [4] endpoint_to_string test IPv6 Address case 1([2031:130f:876a::156a]:8080) test
+ std::cout << "[4] endpoint_to_string test IPv6 Address case 1([2031:130f:876a::156a]:8080) test" << std::endl;
+ {
+ boost::asio::ip::tcp::endpoint test_endpoint(boost::asio::ip::address::from_string("2031:130f:876a::156a"), 8080);
+ std::string ref("[2031:130f:876a::156a]:8080");
+ std::string test_string = test_obj.test_call(test_endpoint);
+ BOOST_CHECK_EQUAL(ref,test_string);
+ }
+ // unit_test [5] endpoint_to_string test IPv6 Address case 2([::]:0) test
+ std::cout << "[5] endpoint_to_string test IPv6 Address case 2([::]:0) test" << std::endl;
+ {
+ boost::asio::ip::tcp::endpoint test_endpoint(boost::asio::ip::address::from_string("::"), 0);
+ std::string ref("[::]:0");
+ std::string test_string = test_obj.test_call(test_endpoint);
+ BOOST_CHECK_EQUAL(ref,test_string);
+ }
+ // unit_test [6] endpoint_to_string test IPv6 Address case 3([ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]:65535) test
+ std::cout << "[6] endpoint_to_string test IPv6 Address case 3([ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]:65535) test" << std::endl;
+ {
+ boost::asio::ip::tcp::endpoint test_endpoint(boost::asio::ip::address::from_string("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"), 65535);
+ std::string ref("[ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]:65535");
+ std::string test_string = test_obj.test_call(test_endpoint);
+ BOOST_CHECK_EQUAL(ref,test_string);
+ }
+ // unit_test [7] endpoint_to_string test IPv6 Address case 4([fe80::2%<1st ifname>]:8080) test
+ std::cout << "[7] endpoint_to_string test IPv6 Address case 4([fe80::2%<1st ifname>]:8080) test" << std::endl;
+ {
+ boost::asio::ip::address_v6 v6addr(boost::asio::ip::address_v6::from_string("fe80::2"));
+ v6addr.scope_id(1);
+ boost::asio::ip::tcp::endpoint test_endpoint(v6addr, 8080);
+ BOOST_CHECK( test_endpoint.address().to_v6().scope_id() == 1);
+ BOOST_CHECK(test_endpoint.address().to_v6().is_link_local());
+ char if_name[IF_NAMESIZE];
+ memset(if_name,0,IF_NAMESIZE);
+ if_indextoname(1,if_name);
+ std::string set_if_name(if_name);
+ std::string ref = "[fe80::2%" + set_if_name + "]:8080";
+ std::string test_string = test_obj.test_call(test_endpoint);
+ BOOST_CHECK_EQUAL(ref,test_string);
+ }
+ // unit_test [8] endpoint_to_string test IPv6 Address case 5([::ffff:192.168.0.1]:8080) test
+ std::cout << "[8] endpoint_to_string test IPv6 Address case 5([::ffff:192.168.0.1]:8080) test" << std::endl;
+ {
+ boost::asio::ip::tcp::endpoint test_endpoint(boost::asio::ip::address::from_string("::ffff:192.168.0.1"), 8080);
+ std::string ref("[::ffff:192.168.0.1]:8080");
+ std::string test_string = test_obj.test_call(test_endpoint);
+ BOOST_CHECK_EQUAL(ref,test_string);
+ }
+
+ BOOST_MESSAGE( "----- endpoint_to_string test end -----" );
+}
+
+
+
+
+test_suite* init_unit_test_suite( int argc, char* argv[] ){
+
+ test_suite* ts = BOOST_TEST_SUITE( "l7vs::tcp_socket class test" );
+
+ ts->add( BOOST_TEST_CASE( &constructer_test ) );
+ ts->add( BOOST_TEST_CASE( &initialize_test ) );
+ ts->add( BOOST_TEST_CASE( &initialize_ssl_mode_test ) );
+ ts->add( BOOST_TEST_CASE( &ssl_clear_keep_cache_test ) );
+ ts->add( BOOST_TEST_CASE( &get_client_socket_test) );
+ ts->add( BOOST_TEST_CASE( &handle_ssl_handshake_timer_test) );
+// ts->add( BOOST_TEST_CASE( &is_thread_wait_test) );
+ ts->add( BOOST_TEST_CASE( &set_virtual_service_message_test) );
+ ts->add( BOOST_TEST_CASE( &endpoint_to_string_test ));
+
+ ts->add( BOOST_TEST_CASE( &up_thread_run_test) );
+ ts->add( BOOST_TEST_CASE( &up_thread_run_ssl_mode_test ) );
+ ts->add( BOOST_TEST_CASE( &down_thread_run_test) );
+// ts->add( BOOST_TEST_CASE( &thread_state_update_test) );
+ ts->add( BOOST_TEST_CASE( &up_thread_client_respond_test) );
+ ts->add( BOOST_TEST_CASE( &up_thread_realserver_get_detination_event_test) );
+ ts->add( BOOST_TEST_CASE( &up_thread_sorryserver_get_detination_event_test) );
+
+ ts->add( BOOST_TEST_CASE( &up_thread_all_socket_close_test) );
+ ts->add( BOOST_TEST_CASE( &down_thread_all_socket_close_test) );
+ ts->add( BOOST_TEST_CASE( &up_thread_client_disconnect_test) );
+ ts->add( BOOST_TEST_CASE( &down_thread_client_disconnect_test) );
+ ts->add( BOOST_TEST_CASE( &up_thread_sorryserver_disconnect_test) );
+ ts->add( BOOST_TEST_CASE( &down_thread_sorryserver_disconnect_test) );
+ ts->add( BOOST_TEST_CASE( &up_thread_realserver_connect_event_test) );
+ ts->add( BOOST_TEST_CASE( &up_thread_sorryserver_connect_event_test) );
+ ts->add( BOOST_TEST_CASE( &down_thread_client_connection_chk_event_test) );
+ ts->add( BOOST_TEST_CASE( &up_thread_realserver_connection_fail_event_test) );
+ ts->add( BOOST_TEST_CASE( &up_thread_sorryserver_connection_fail_event_test) );
+
+ ts->add( BOOST_TEST_CASE( &up_thread_client_accept_test ) );
+ ts->add( BOOST_TEST_CASE( &up_thread_client_receive_test) );
+ ts->add( BOOST_TEST_CASE( &down_thread_realserver_receive_test) );
+ ts->add( BOOST_TEST_CASE( &down_thread_sorryserver_receive_test) );
+ ts->add( BOOST_TEST_CASE( &up_thread_realserver_send_test) );
+ ts->add( BOOST_TEST_CASE( &up_thread_sorryserver_send_test) );
+ ts->add( BOOST_TEST_CASE( &down_thread_client_send_test) );
+ ts->add( BOOST_TEST_CASE( &up_thread_realserver_connect_test) );
+ ts->add( BOOST_TEST_CASE( &up_thread_realserver_connect_access_log_test) );
+ ts->add( BOOST_TEST_CASE( &up_thread_sorryserver_connect_test) );
+ ts->add( BOOST_TEST_CASE( &up_thread_realserver_disconnect_test) );
+ ts->add( BOOST_TEST_CASE( &down_thread_realserver_disconnect_test) );
+ ts->add( BOOST_TEST_CASE( &up_thread_all_realserver_disconnect_test) );
+ ts->add( BOOST_TEST_CASE( &down_thread_all_realserver_disconnect_test) );
+
+ ts->add( BOOST_TEST_CASE( &up_thread_exit_test ) );
+ ts->add( BOOST_TEST_CASE( &down_thread_exit_test ) );
+ ts->add( BOOST_TEST_CASE( &up_thread_client_disconnect_event_test ) );
+ ts->add( BOOST_TEST_CASE( &down_thread_client_disconnect_event_test ) );
+ ts->add( BOOST_TEST_CASE( &up_thread_realserver_disconnect_event_test ) );
+ ts->add( BOOST_TEST_CASE( &down_thread_realserver_disconnect_event_test ) );
+ ts->add( BOOST_TEST_CASE( &up_thread_sorryserver_disconnect_event_test ) );
+ ts->add( BOOST_TEST_CASE( &down_thread_sorryserver_disconnect_event_test ) );
+ ts->add( BOOST_TEST_CASE( &up_thread_sorryserver_mod_disconnect_test ) );
+ ts->add( BOOST_TEST_CASE( &down_thread_sorryserver_mod_disconnect_test ) );
+
+ ts->add( BOOST_TEST_CASE( &up_thread_sorry_enable_event_test ) );
+ ts->add( BOOST_TEST_CASE( &up_thread_sorry_disable_event_test ) );
+ ts->add( BOOST_TEST_CASE( &down_thread_sorry_enable_event_test ) );
+ ts->add( BOOST_TEST_CASE( &down_thread_sorry_disable_event_test ) );
+ ts->add( BOOST_TEST_CASE( &up_thread_client_accept_event_test ) );
+ ts->add( BOOST_TEST_CASE( &up_thread_client_respond_event_test ) );
+ ts->add( BOOST_TEST_CASE( &down_thread_client_respond_event_test ) );
framework::master_test_suite().add( ts );
OSDN Git Service
