3 #include <boost/asio.hpp>
4 #include <boost/thread/thread.hpp>
5 #include <boost/function_equal.hpp>
6 #include <boost/test/included/unit_test.hpp>
8 #include "../logger_stb/logger_implement_access.h"
9 #include "../logger_stb/logger.h"
10 #include "dummyclass.h"
11 #include "tcp_socket_option.h"
12 #include "tcp_session.h"
13 #include "tcp_session.cpp"
14 #include "lockfree_queue.h"
15 #include "../../../src/data_buff_base.cpp"
16 #include "../../../src/tcp_data.cpp"
17 #include "../../../src/tcp_realserver_connect_socket_list.cpp"
20 using namespace boost::unit_test_framework;
22 #define UP_THREAD_ALIVE std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0001)
23 #define DOWN_THREAD_ALIVE std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0002)
24 #define UP_THREAD_ACTIVE std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0004)
25 #define DOWN_THREAD_ACTIVE std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0008)
26 #define UP_THREAD_LOCK std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0010)
27 #define DOWN_THREAD_LOCK std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0020)
30 #define DUMMI_SERVER_IP "127.0.0.1"
31 #define DUMMI_SERVER_PORT 7000
33 #define CLIENT_CTX_LOAD_VERIFY_FILE "ca.pem"
34 #define SERVER_CTX_CERTIFICATE_CHAIN_FILE "server.pem"
35 #define SERVER_CTX_PRIVATE_KEY_FILE "server.pem"
36 #define SERVER_CTX_TMP_DH_FILE "dh512.pem"
39 // mutex lock test class
40 class mutex_lock_test : public l7vs::tcp_session{
42 boost::thread::id befor_thread_id;
43 boost::thread::id after_thread_id;
44 l7vs::wr_mutex* pTest_mutex;
45 boost::function< void(void) > test_func;
48 l7vs::virtualservice_tcp& vs,
49 boost::asio::io_service& session_io,
50 l7vs::tcp_socket_option_info& set_socket_option,
51 boost::asio::ip::tcp::endpoint listen_endpoint,
53 boost::asio::ssl::context& set_ssl_context,
54 bool set_ssl_cache_flag,
55 int set_ssl_handshake_time_out,
56 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
63 set_ssl_handshake_time_out,
77 if(pTest_mutex == NULL){
78 std::cout << "Test code Error!! pTest_mutex = NULL" << std::endl;
80 pTest_mutex->wrlock();
85 if(pTest_mutex == NULL){
86 std::cout << "Test code Error!! pTest_mutex = NULL" << std::endl;
88 pTest_mutex->unlock();
92 void set_protocol_module(l7vs::protocol_module_base* test_protocol_module){
93 protocol_module = test_protocol_module;
97 /* bool mutex_trylock(){
98 return pTest_mutex->try_lock();
101 boost::mutex test_thread_wait;
104 boost::mutex::scoped_lock scope_lock(test_thread_wait);
109 //-------------is_thread_wait test---------------------------------
110 void set_is_thread_wait_test(){
111 //pTest_mutex = &thread_state_update_mutex;
112 pTest_mutex2 = &downthread_status_mutex;
113 test_func = boost::bind(&mutex_lock_test::is_thread_wait,this);
116 void is_thread_wait(){
117 befor_thread_id = boost::this_thread::get_id();
118 l7vs::tcp_session::is_thread_wait();
119 after_thread_id = boost::this_thread::get_id();
123 //-------------down_thread_exit test---------------------------------
124 void set_down_thread_exit_test(){
125 pTest_mutex = &exit_flag_update_mutex;
126 test_func = boost::bind(&mutex_lock_test::down_thread_exit,this);
129 void down_thread_exit(){
130 befor_thread_id = boost::this_thread::get_id();
131 l7vs::tcp_session::down_thread_exit(l7vs::tcp_session::LOCAL_PROC);
132 after_thread_id = boost::this_thread::get_id();
135 //-------------up_thread_exit test---------------------------------
136 void set_up_thread_exit_test(){
137 pTest_mutex = &exit_flag_update_mutex;
138 test_func = boost::bind(&mutex_lock_test::up_thread_exit,this);
141 void up_thread_exit(){
142 befor_thread_id = boost::this_thread::get_id();
143 l7vs::tcp_session::up_thread_exit(l7vs::tcp_session::LOCAL_PROC);
144 after_thread_id = boost::this_thread::get_id();
147 //-------------up_thread_client_disconnetc_event test---------------------------------
148 void set_up_thread_client_disconnect_event_test(){
149 pTest_mutex = &module_function_client_disconnect_mutex;
150 test_func = boost::bind(&mutex_lock_test::up_thread_client_disconnect_event,this);
153 void up_thread_client_disconnect_event(){
154 befor_thread_id = boost::this_thread::get_id();
155 l7vs::tcp_session::up_thread_client_disconnect_event(l7vs::tcp_session::LOCAL_PROC);
156 after_thread_id = boost::this_thread::get_id();
159 //-------------down_thread_client_disconnetc_event test---------------------------------
160 void set_down_thread_client_disconnect_event_test(){
161 pTest_mutex = &module_function_client_disconnect_mutex;
162 test_func = boost::bind(&mutex_lock_test::down_thread_client_disconnect_event,this);
165 void down_thread_client_disconnect_event(){
166 befor_thread_id = boost::this_thread::get_id();
167 l7vs::tcp_session::down_thread_client_disconnect_event(l7vs::tcp_session::LOCAL_PROC);
168 after_thread_id = boost::this_thread::get_id();
171 //-------------up_thread_realserver_disconnetc_event test---------------------------------
172 void set_up_thread_realserver_disconnect_event_test(){
173 pTest_mutex = &module_function_realserver_disconnect_mutex;
174 test_func = boost::bind(&mutex_lock_test::up_thread_realserver_disconnect_event,this);
177 void up_thread_realserver_disconnect_event(){
178 befor_thread_id = boost::this_thread::get_id();
179 l7vs::tcp_session::up_thread_realserver_disconnect_event(l7vs::tcp_session::LOCAL_PROC);
180 after_thread_id = boost::this_thread::get_id();
183 //-------------down_thread_realserver_disconnetc_event test---------------------------------
184 void set_down_thread_realserver_disconnect_event_test(){
185 pTest_mutex = &module_function_realserver_disconnect_mutex;
186 test_func = boost::bind(&mutex_lock_test::down_thread_realserver_disconnect_event,this);
189 void down_thread_realserver_disconnect_event(){
190 befor_thread_id = boost::this_thread::get_id();
191 l7vs::tcp_session::down_thread_realserver_disconnect_event(l7vs::tcp_session::LOCAL_PROC);
192 after_thread_id = boost::this_thread::get_id();
195 //-------------up_thread_sorryserver_disconnetc_event test---------------------------------
196 void set_up_thread_sorryserver_disconnect_event_test(){
197 pTest_mutex = &module_function_sorryserver_disconnect_mutex;
198 test_func = boost::bind(&mutex_lock_test::up_thread_sorryserver_disconnect_event,this);
201 void up_thread_sorryserver_disconnect_event(){
202 befor_thread_id = boost::this_thread::get_id();
203 l7vs::tcp_session::up_thread_sorryserver_disconnect_event(l7vs::tcp_session::LOCAL_PROC);
204 after_thread_id = boost::this_thread::get_id();
207 //-------------down_thread_sorryserver_disconnetc_event test---------------------------------
208 void set_down_thread_sorryserver_disconnect_event_test(){
209 pTest_mutex = &module_function_sorryserver_disconnect_mutex;
210 test_func = boost::bind(&mutex_lock_test::down_thread_sorryserver_disconnect_event,this);
213 void down_thread_sorryserver_disconnect_event(){
214 befor_thread_id = boost::this_thread::get_id();
215 l7vs::tcp_session::down_thread_sorryserver_disconnect_event(l7vs::tcp_session::LOCAL_PROC);
216 after_thread_id = boost::this_thread::get_id();
219 //-------------up_thread_sorry_enable_event test---------------------------------
220 void set_up_thread_sorry_enable_event_test(){
221 pTest_mutex = &module_function_sorry_enable_mutex;
222 test_func = boost::bind(&mutex_lock_test::up_thread_sorry_enable_event,this);
225 void up_thread_sorry_enable_event(){
226 befor_thread_id = boost::this_thread::get_id();
227 l7vs::tcp_session::up_thread_sorry_enable_event(l7vs::tcp_session::LOCAL_PROC);
228 after_thread_id = boost::this_thread::get_id();
231 //-------------up_thread_sorry_disable_event test---------------------------------
232 void set_up_thread_sorry_disable_event_test(){
233 pTest_mutex = &module_function_sorry_disable_mutex;
234 test_func = boost::bind(&mutex_lock_test::up_thread_sorry_disable_event,this);
237 void up_thread_sorry_disable_event(){
238 befor_thread_id = boost::this_thread::get_id();
239 l7vs::tcp_session::up_thread_sorry_disable_event(l7vs::tcp_session::LOCAL_PROC);
240 after_thread_id = boost::this_thread::get_id();
242 //-------------down_thread_sorry_enable_event test---------------------------------
243 void set_down_thread_sorry_enable_event_test(){
244 pTest_mutex = &module_function_sorry_enable_mutex;
245 test_func = boost::bind(&mutex_lock_test::down_thread_sorry_enable_event,this);
248 void down_thread_sorry_enable_event(){
249 befor_thread_id = boost::this_thread::get_id();
250 l7vs::tcp_session::down_thread_sorry_enable_event(l7vs::tcp_session::LOCAL_PROC);
251 after_thread_id = boost::this_thread::get_id();
254 //-------------down_thread_sorry_disable_event test---------------------------------
255 void set_down_thread_sorry_disable_event_test(){
256 pTest_mutex = &module_function_sorry_disable_mutex;
257 test_func = boost::bind(&mutex_lock_test::down_thread_sorry_disable_event,this);
260 void down_thread_sorry_disable_event(){
261 befor_thread_id = boost::this_thread::get_id();
262 l7vs::tcp_session::down_thread_sorry_disable_event(l7vs::tcp_session::LOCAL_PROC);
263 after_thread_id = boost::this_thread::get_id();
266 //-------------up_thread_client_respond_event test---------------------------------
267 void set_up_thread_client_respond_event_test(){
268 pTest_mutex = &module_function_response_send_inform_mutex;
269 test_func = boost::bind(&mutex_lock_test::up_thread_client_respond_event,this);
272 void up_thread_client_respond_event(){
273 befor_thread_id = boost::this_thread::get_id();
274 l7vs::tcp_session::up_thread_client_respond_event(l7vs::tcp_session::LOCAL_PROC);
275 after_thread_id = boost::this_thread::get_id();
278 //-------------down_thread_client_respond_event test---------------------------------
279 void set_down_thread_client_respond_event_test(){
280 pTest_mutex = &module_function_response_send_inform_mutex;
281 test_func = boost::bind(&mutex_lock_test::down_thread_client_respond_event,this);
284 void down_thread_client_respond_event(){
285 befor_thread_id = boost::this_thread::get_id();
286 l7vs::tcp_session::down_thread_client_respond_event(l7vs::tcp_session::LOCAL_PROC);
287 after_thread_id = boost::this_thread::get_id();
291 //-------------thread_state_update test---------------------------------
292 void set_thread_state_update_test(){
293 pTest_mutex = &thread_state_update_mutex;
294 test_func = boost::bind(&mutex_lock_test::thread_state_update,this);
297 void thread_state_update(){
298 befor_thread_id = boost::this_thread::get_id();
299 l7vs::tcp_session::thread_state_update(UP_THREAD_ALIVE,true);
300 after_thread_id = boost::this_thread::get_id();
304 //-------------handle_ssl_handshake_timer test---------------------------------
305 void set_handle_ssl_handshake_timer_test(){
306 pTest_mutex = &ssl_handshake_time_out_flag_mutex;
307 test_func = boost::bind(&mutex_lock_test::handle_ssl_handshake_timer,this);
310 void handle_ssl_handshake_timer(){
311 befor_thread_id = boost::this_thread::get_id();
312 boost::system::error_code ec;
313 l7vs::tcp_session::handle_ssl_handshake_timer(ec);
314 after_thread_id = boost::this_thread::get_id();
318 // dummy mirror server
319 #define DUMMI_SERVER_IP "127.0.0.1"
320 #define DUMMI_SERVER_PORT 7000
321 class test_mirror_server{
327 bool breq_close_wait_flag;
329 bool bdisconnect_flag;
330 boost::asio::ip::tcp::endpoint accept_end;
331 boost::asio::ip::tcp::endpoint connect_end;
336 test_mirror_server() :
339 breq_acc_flag(false),
340 breq_close_wait_flag(false),
341 bconnect_flag(false),
342 bdisconnect_flag(false),
343 accept_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT),
344 connect_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT),
350 ~test_mirror_server(){
360 std::cout << "dummy mirror server run start!" << std::endl;
363 bconnect_flag = false;
364 bdisconnect_flag = false;
365 boost::asio::io_service io;
366 boost::asio::ip::tcp::acceptor acc(io,accept_end);
367 boost::system::error_code ec;
369 boost::array<char,MAX_BUFFER_SIZE> buf;
377 boost::asio::ip::tcp::socket con(io);
382 std::cout << "dummy mirror server accept NG!" << std::endl;
385 connect_end = con.remote_endpoint();
386 std::cout << "dummy mirror server accept OK! from " << connect_end << std::endl;
388 breq_acc_flag = false;
391 bconnect_flag = true;
393 for(int i = 0; i < req_recv_cnt ;i++){
394 while(!brecv_triger){
398 brecv_triger = false;
403 receive_size = con.read_some(boost::asio::buffer(buf,MAX_BUFFER_SIZE),ec);
406 if(ec == boost::asio::error::eof || ec == boost::asio::error::connection_reset){
407 std::cout << "dummy mirror server detect client disconnect!" << std::endl;
408 bdisconnect_flag = true;
410 std::cout << "dummy mirror server receive NG!" << std::endl;
413 if(receive_size > 0){
415 con.write_some(boost::asio::buffer(buf,receive_size),ec);
417 std::cout << "dummy mirror server send NG!" << std::endl;
423 std::cout << "dummy mirror server connection close wait start" << std::endl;
424 while(breq_close_wait_flag){
427 std::cout << "dummy mirror server connection close wait end" << std::endl;
437 std::cout << "dummy mirror server run end!" << std::endl;
445 test_client(boost::asio::io_service& io_service, boost::asio::ssl::context& context) :
446 my_socket(io_service,context){
453 //! socket connect mutex
454 connect_mutex.wrlock();
455 //! socket handshake mutex
456 handshake_mutex.wrlock();
457 //! socket read mutex
459 //! socket write mutex
460 write_mutex.wrlock();
461 //! socket close mutex
462 close_mutex.wrlock();
466 void connect_close_only_test_run(){
467 // dummy client start
471 l7vs::rw_scoped_lock scope_lock(connect_mutex);
480 l7vs::rw_scoped_lock scope_lock(close_mutex);
485 void handshake_test_run(){
486 // dummy client start
490 l7vs::rw_scoped_lock scope_lock(connect_mutex);
499 l7vs::rw_scoped_lock scope_lock(handshake_mutex);
501 if(!handshake_test()){
508 l7vs::rw_scoped_lock scope_lock(close_mutex);
516 boost::system::error_code ec;
517 std::cout << "dummy client connect try" << std::endl;
518 boost::asio::ip::tcp::endpoint connect_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
519 my_socket.lowest_layer().connect(connect_end,ec);
522 std::cout << "dummy client connect Error!" << std::endl;
523 std::cout << ec << std::endl;
526 std::cout << "dummy client connect OK" << std::endl;
530 bool handshake_test(){
531 boost::system::error_code ec;
532 std::cout << "dummy client handshake try" << std::endl;
533 my_socket.handshake(boost::asio::ssl::stream_base::client, ec);
536 std::cout << "dummy client handshake Error!" << std::endl;
537 std::cout << ec << std::endl;
540 std::cout << "dummy client handshake OK" << std::endl;
546 boost::system::error_code ec;
547 std::cout << "dummy client write try" << std::endl;
548 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);
551 std::cout << "dummy client send Error!" << std::endl;
552 std::cout << ec << std::endl;
555 send_data_size += write_size;
556 std::cout << "dummy client send OK [" << send_data_size << "]" << std::endl;
561 boost::system::error_code ec;
562 std::cout << "dummy client read try" << std::endl;
563 std::size_t read_size = my_socket.read_some(boost::asio::buffer(data_buff.data() + receive_data_size,MAX_BUFFER_SIZE), ec);
566 std::cout << "dummy client receive Error!" << std::endl;
567 std::cout << ec << std::endl;
570 receive_data_size += read_size;
571 std::cout << "dummy client receive OK [" << receive_data_size << "]" << std::endl;
576 boost::system::error_code ec;
577 std::cout << "dummy client close try" << std::endl;
578 my_socket.lowest_layer().close(ec);
581 std::cout << "dummy client close Error!" << std::endl;
582 std::cout << ec << std::endl;
585 std::cout << "dummy client close OK" << std::endl;
588 boost::asio::ssl::stream<boost::asio::ip::tcp::socket> my_socket;
589 boost::array<char,MAX_BUFFER_SIZE> data_buff;
590 std::size_t receive_data_size;
591 std::size_t send_data_size;
593 //! socket connect mutex
594 l7vs::wr_mutex connect_mutex;
595 //! socket handshake mutex
596 l7vs::wr_mutex handshake_mutex;
597 //! socket read mutex
598 l7vs::wr_mutex read_mutex;
599 //! socket write mutex
600 l7vs::wr_mutex write_mutex;
601 //! socket close mutex
602 l7vs::wr_mutex close_mutex;
611 std::string get_password() const{
612 std::cout << "call get_password" << std::endl;
618 // module event map test base class
619 class module_event_map_test_base_class : public l7vs::tcp_session{
622 std::pair<l7vs::protocol_module_base::EVENT_TAG, UP_THREAD_FUNC_TYPE_TAG> up_module_map_test_data[13];
623 std::pair<UP_THREAD_FUNC_TYPE_TAG , boost::function< void(const l7vs::tcp_session::TCP_PROCESS_TYPE_TAG) > > up_fuc_map_test_data[13];
624 std::pair<l7vs::protocol_module_base::EVENT_TAG, DOWN_THREAD_FUNC_TYPE_TAG> down_module_map_test_data[7];
625 std::pair<DOWN_THREAD_FUNC_TYPE_TAG , boost::function< void(const l7vs::tcp_session::TCP_PROCESS_TYPE_TAG) > > down_fuc_map_test_data[7];
627 // module_event_map_test_base_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){
628 module_event_map_test_base_class(
629 l7vs::virtualservice_tcp& vs,
630 boost::asio::io_service& session_io,
631 l7vs::tcp_socket_option_info& set_socket_option,
632 boost::asio::ip::tcp::endpoint listen_endpoint,
634 boost::asio::ssl::context& set_ssl_context,
635 bool set_ssl_cache_flag,
636 int set_ssl_handshake_time_out,
637 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
644 set_ssl_handshake_time_out,
648 boost::function< void(const l7vs::tcp_session::TCP_PROCESS_TYPE_TAG) > func;
651 up_thread_module_event_map.clear();
652 // up_thread_function_map.clear();
655 up_module_map_test_data[index].first = l7vs::protocol_module_base::ACCEPT;
656 up_module_map_test_data[index].second = l7vs::tcp_session::UP_FUNC_CLIENT_ACCEPT;
657 up_fuc_map_test_data[index].first = up_module_map_test_data[index].second;
658 up_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_UP_FUNC_CLIENT_ACCEPT,this,_1);
659 up_thread_function_array[up_fuc_map_test_data[index].first] = up_fuc_map_test_data[index];
662 up_module_map_test_data[index].first = l7vs::protocol_module_base::CLIENT_DISCONNECT;
663 up_module_map_test_data[index].second = l7vs::tcp_session::UP_FUNC_CLIENT_DISCONNECT;
664 up_fuc_map_test_data[index].first = up_module_map_test_data[index].second;
665 up_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_UP_FUNC_CLIENT_DISCONNECT,this,_1);
666 up_thread_function_array[up_fuc_map_test_data[index].first] = up_fuc_map_test_data[index];
669 up_module_map_test_data[index].first = l7vs::protocol_module_base::CLIENT_RECV;
670 up_module_map_test_data[index].second = l7vs::tcp_session::UP_FUNC_CLIENT_RECEIVE;
671 up_fuc_map_test_data[index].first = up_module_map_test_data[index].second;
672 up_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_UP_FUNC_CLIENT_RECEIVE,this,_1);
673 up_thread_function_array[up_fuc_map_test_data[index].first] = up_fuc_map_test_data[index];
676 up_module_map_test_data[index].first = l7vs::protocol_module_base::CLIENT_RESPONSE_SEND;
677 up_module_map_test_data[index].second = l7vs::tcp_session::UP_FUNC_CLIENT_RESPOND_SEND;
678 up_fuc_map_test_data[index].first = up_module_map_test_data[index].second;
679 up_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_UP_FUNC_CLIENT_RESPOND_SEND,this,_1);
680 up_thread_function_array[up_fuc_map_test_data[index].first] = up_fuc_map_test_data[index];
683 up_module_map_test_data[index].first = l7vs::protocol_module_base::REALSERVER_SELECT;
684 up_module_map_test_data[index].second = l7vs::tcp_session::UP_FUNC_REALSERVER_GET_DEST_EVENT;
685 up_fuc_map_test_data[index].first = up_module_map_test_data[index].second;
686 up_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_UP_FUNC_REALSERVER_GET_DEST_EVENT,this,_1);
687 up_thread_function_array[up_fuc_map_test_data[index].first] = up_fuc_map_test_data[index];
690 up_module_map_test_data[index].first = l7vs::protocol_module_base::REALSERVER_CONNECT;
691 up_module_map_test_data[index].second = l7vs::tcp_session::UP_FUNC_REALSERVER_CONNECT;
692 up_fuc_map_test_data[index].first = up_module_map_test_data[index].second;
693 up_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_UP_FUNC_REALSERVER_CONNECT,this,_1);
694 up_thread_function_array[up_fuc_map_test_data[index].first] = up_fuc_map_test_data[index];
697 up_module_map_test_data[index].first = l7vs::protocol_module_base::REALSERVER_SEND;
698 up_module_map_test_data[index].second = l7vs::tcp_session::UP_FUNC_REALSERVER_SEND;
699 up_fuc_map_test_data[index].first = up_module_map_test_data[index].second;
700 up_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_UP_FUNC_REALSERVER_SEND,this,_1);
701 up_thread_function_array[up_fuc_map_test_data[index].first] = up_fuc_map_test_data[index];
704 up_module_map_test_data[index].first = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
705 up_module_map_test_data[index].second = l7vs::tcp_session::UP_FUNC_REALSERVER_ALL_DISCONNECT;
706 up_fuc_map_test_data[index].first = up_module_map_test_data[index].second;
707 up_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_UP_FUNC_REALSERVER_ALL_DISCONNECT,this,_1);
708 up_thread_function_array[up_fuc_map_test_data[index].first] = up_fuc_map_test_data[index];
711 up_module_map_test_data[index].first = l7vs::protocol_module_base::SORRYSERVER_SELECT;
712 up_module_map_test_data[index].second = l7vs::tcp_session::UP_FUNC_SORRYSERVER_GET_DEST;
713 up_fuc_map_test_data[index].first = up_module_map_test_data[index].second;
714 up_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_UP_FUNC_SORRYSERVER_GET_DEST,this,_1);
715 up_thread_function_array[up_fuc_map_test_data[index].first] = up_fuc_map_test_data[index];
718 up_module_map_test_data[index].first = l7vs::protocol_module_base::SORRYSERVER_CONNECT;
719 up_module_map_test_data[index].second = l7vs::tcp_session::UP_FUNC_SORRYSERVER_CONNECT;
720 up_fuc_map_test_data[index].first = up_module_map_test_data[index].second;
721 up_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_UP_FUNC_SORRYSERVER_CONNECT,this,_1);
722 up_thread_function_array[up_fuc_map_test_data[index].first] = up_fuc_map_test_data[index];
725 up_module_map_test_data[index].first = l7vs::protocol_module_base::SORRYSERVER_SEND;
726 up_module_map_test_data[index].second = l7vs::tcp_session::UP_FUNC_SORRYSERVER_SEND;
727 up_fuc_map_test_data[index].first = up_module_map_test_data[index].second;
728 up_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_UP_FUNC_SORRYSERVER_SEND,this,_1);
729 up_thread_function_array[up_fuc_map_test_data[index].first] = up_fuc_map_test_data[index];
732 up_module_map_test_data[index].first = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
733 up_module_map_test_data[index].second = l7vs::tcp_session::UP_FUNC_SORRYSERVER_DISCONNECT;
734 up_fuc_map_test_data[index].first = up_module_map_test_data[index].second;
735 up_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_UP_FUNC_SORRYSERVER_DISCONNECT,this,_1);
736 up_thread_function_array[up_fuc_map_test_data[index].first] = up_fuc_map_test_data[index];
739 up_module_map_test_data[index].first = l7vs::protocol_module_base::FINALIZE;
740 up_module_map_test_data[index].second = l7vs::tcp_session::UP_FUNC_EXIT;
741 up_fuc_map_test_data[index].first = up_module_map_test_data[index].second;
742 up_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_UP_FUNC_EXIT,this,_1);
743 up_thread_function_array[up_fuc_map_test_data[index].first] = up_fuc_map_test_data[index];
745 for(int i = 0 ; i < 13;i++){
746 up_thread_module_event_map.insert(up_module_map_test_data[i]);
749 down_thread_module_event_map.clear();
750 // down_thread_function_map.clear();
753 down_module_map_test_data[index].first = l7vs::protocol_module_base::CLIENT_DISCONNECT;
754 down_module_map_test_data[index].second = l7vs::tcp_session::DOWN_FUNC_CLIENT_DISCONNECT;
755 down_fuc_map_test_data[index].first = down_module_map_test_data[index].second;
756 down_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_DOWN_FUNC_CLIENT_DISCONNECT,this,_1);
757 down_thread_function_array[down_fuc_map_test_data[index].first] = down_fuc_map_test_data[index];
760 down_module_map_test_data[index].first = l7vs::protocol_module_base::CLIENT_CONNECTION_CHECK;
761 down_module_map_test_data[index].second = l7vs::tcp_session::DOWN_FUNC_CLIENT_CONNECTION_CHK;
762 down_fuc_map_test_data[index].first = down_module_map_test_data[index].second;
763 down_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_DOWN_FUNC_CLIENT_CONNECTION_CHK,this,_1);
764 down_thread_function_array[down_fuc_map_test_data[index].first] = down_fuc_map_test_data[index];
767 down_module_map_test_data[index].first = l7vs::protocol_module_base::REALSERVER_RECV;
768 down_module_map_test_data[index].second = l7vs::tcp_session::DOWN_FUNC_REALSERVER_RECEIVE;
769 down_fuc_map_test_data[index].first = down_module_map_test_data[index].second;
770 down_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_DOWN_FUNC_REALSERVER_RECEIVE,this,_1);
771 down_thread_function_array[down_fuc_map_test_data[index].first] = down_fuc_map_test_data[index];
774 down_module_map_test_data[index].first = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
775 down_module_map_test_data[index].second = l7vs::tcp_session::DOWN_FUNC_REALSERVER_ALL_DISCONNECT;
776 down_fuc_map_test_data[index].first = down_module_map_test_data[index].second;
777 down_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_DOWN_FUNC_REALSERVER_ALL_DISCONNECT,this,_1);
778 down_thread_function_array[down_fuc_map_test_data[index].first] = down_fuc_map_test_data[index];
781 down_module_map_test_data[index].first = l7vs::protocol_module_base::SORRYSERVER_RECV;
782 down_module_map_test_data[index].second = l7vs::tcp_session::DOWN_FUNC_SORRYSERVER_RECEIVE;
783 down_fuc_map_test_data[index].first = down_module_map_test_data[index].second;
784 down_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_DOWN_FUNC_SORRYSERVER_RECEIVE,this,_1);
785 down_thread_function_array[down_fuc_map_test_data[index].first] = down_fuc_map_test_data[index];
788 down_module_map_test_data[index].first = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
789 down_module_map_test_data[index].second = l7vs::tcp_session::DOWN_FUNC_SORRYSERVER_DISCONNECT;
790 down_fuc_map_test_data[index].first = down_module_map_test_data[index].second;
791 down_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_DOWN_FUNC_SORRYSERVER_DISCONNECT,this,_1);
792 down_thread_function_array[down_fuc_map_test_data[index].first] = down_fuc_map_test_data[index];
795 down_module_map_test_data[index].first = l7vs::protocol_module_base::FINALIZE;
796 down_module_map_test_data[index].second = l7vs::tcp_session::DOWN_FUNC_EXIT;
797 down_fuc_map_test_data[index].first = down_module_map_test_data[index].second;
798 down_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_DOWN_FUNC_EXIT,this,_1);
799 down_thread_function_array[down_fuc_map_test_data[index].first] = down_fuc_map_test_data[index];
801 for(int i = 0 ; i < 7;i++){
802 down_thread_module_event_map.insert(down_module_map_test_data[i]);
808 ~module_event_map_test_base_class(){
809 up_thread_module_event_map_clear();
810 up_thread_function_array_clear();
811 down_thread_module_event_map_clear();
812 down_thread_function_array_clear();
815 void set_protocol_module(l7vs::protocol_module_base* test_protocol_module){
816 protocol_module = test_protocol_module;
819 bool chk_up_thread_next_call_function(l7vs::protocol_module_base::EVENT_TAG chk_event){
820 l7vs::tcp_session::UP_THREAD_FUNC_TYPE_TAG fnc_tag = l7vs::tcp_session::UP_FUNC_EXIT;
821 up_call_func_type = fnc_tag;
822 for(int i = 0; i < 13;i++){
823 if( up_module_map_test_data[i].first == chk_event){
824 fnc_tag = up_module_map_test_data[i].second;
826 up_call_func_type = up_module_map_test_data[i+1].second;
828 up_call_func_type = up_module_map_test_data[0].second;
833 if(fnc_tag == up_call_func_type){
837 up_thread_next_call_function.second(LOCAL_PROC);
839 return fnc_tag == up_call_func_type;
842 bool chk_down_thread_next_call_function(l7vs::protocol_module_base::EVENT_TAG chk_event){
843 l7vs::tcp_session::DOWN_THREAD_FUNC_TYPE_TAG fnc_tag = l7vs::tcp_session::DOWN_FUNC_EXIT;
844 down_call_func_type = fnc_tag;
845 for(int i = 0; i < 7;i++){
846 if( down_module_map_test_data[i].first == chk_event){
847 fnc_tag = down_module_map_test_data[i].second;
849 down_call_func_type = down_module_map_test_data[i+1].second;
851 down_call_func_type = down_module_map_test_data[0].second;
856 if(fnc_tag == down_call_func_type){
860 down_thread_next_call_function.second(LOCAL_PROC);
862 return fnc_tag == down_call_func_type;
866 void up_thread_module_event_map_clear(){
867 up_thread_module_event_map.clear();
870 void up_thread_function_array_clear(){
871 for(int i = 0; i <= l7vs::tcp_session::UP_FUNC_EXIT;i++){
872 up_thread_function_array[i].second = (tcp_session_func)NULL;
876 void down_thread_module_event_map_clear(){
877 down_thread_module_event_map.clear();
880 void down_thread_function_array_clear(){
881 for(int i = 0; i <= l7vs::tcp_session::DOWN_FUNC_EXIT;i++){
882 down_thread_function_array[i].second = (tcp_session_func)NULL;
886 void set_up_thread_id(boost::thread::id set_thread_id){
887 up_thread_id = set_thread_id;
889 void set_down_thread_id(boost::thread::id set_thread_id){
890 down_thread_id = set_thread_id;
893 void set_up_thread_data_client_side(l7vs::tcp_data& set_data){
894 up_thread_data_client_side.set_size(set_data.get_size());
895 up_thread_data_client_side.set_send_size(set_data.get_send_size());
896 up_thread_data_client_side.set_data(set_data.get_data());
897 up_thread_data_client_side.set_endpoint(set_data.get_endpoint());
899 l7vs::tcp_data& get_up_thread_data_client_side(){
900 return up_thread_data_client_side;
902 void set_up_thread_data_dest_side(l7vs::tcp_data& set_data){
903 up_thread_data_dest_side.set_size(set_data.get_size());
904 up_thread_data_dest_side.set_send_size(set_data.get_send_size());
905 up_thread_data_dest_side.set_data(set_data.get_data());
906 up_thread_data_dest_side.set_endpoint(set_data.get_endpoint());
908 l7vs::tcp_data& get_up_thread_data_dest_side(){
909 return up_thread_data_dest_side;
911 void set_up_thread_message_data(l7vs::tcp_data& set_data){
912 up_thread_message_data.set_size(set_data.get_size());
913 up_thread_message_data.set_send_size(set_data.get_send_size());
914 up_thread_message_data.set_data(set_data.get_data());
915 up_thread_message_data.set_endpoint(set_data.get_endpoint());
917 l7vs::tcp_data& get_up_thread_message_data(){
918 return up_thread_message_data;
920 void set_down_thread_data_client_side(l7vs::tcp_data& set_data){
921 down_thread_data_client_side.set_size(set_data.get_size());
922 down_thread_data_client_side.set_send_size(set_data.get_send_size());
923 down_thread_data_client_side.set_data(set_data.get_data());
924 down_thread_data_client_side.set_endpoint(set_data.get_endpoint());
926 l7vs::tcp_data& get_down_thread_data_client_side(){
927 return down_thread_data_client_side;
929 void set_down_thread_data_dest_side(l7vs::tcp_data& set_data){
930 down_thread_data_dest_side.set_size(set_data.get_size());
931 down_thread_data_dest_side.set_send_size(set_data.get_send_size());
932 down_thread_data_dest_side.set_data(set_data.get_data());
933 down_thread_data_client_side.set_endpoint(set_data.get_endpoint());
935 l7vs::tcp_data& get_down_thread_data_dest_side(){
936 return down_thread_data_dest_side;
938 void set_down_thread_message_data(l7vs::tcp_data& set_data){
939 down_thread_message_data.set_size(set_data.get_size());
940 down_thread_message_data.set_send_size(set_data.get_send_size());
941 down_thread_message_data.set_data(set_data.get_data());
942 down_thread_message_data.set_endpoint(set_data.get_endpoint());
944 l7vs::tcp_data& get_down_thread_message_data(){
945 return down_thread_message_data;
947 void test_UP_FUNC_CLIENT_ACCEPT(const l7vs::tcp_session::TCP_PROCESS_TYPE_TAG process_type){
948 up_call_func_type = l7vs::tcp_session::UP_FUNC_CLIENT_ACCEPT;
951 void test_UP_FUNC_CLIENT_DISCONNECT(const l7vs::tcp_session::TCP_PROCESS_TYPE_TAG process_type){
952 up_call_func_type = l7vs::tcp_session::UP_FUNC_CLIENT_DISCONNECT;
955 void test_DOWN_FUNC_CLIENT_DISCONNECT(const l7vs::tcp_session::TCP_PROCESS_TYPE_TAG process_type){
956 down_call_func_type = l7vs::tcp_session::DOWN_FUNC_CLIENT_DISCONNECT;
959 void test_DOWN_FUNC_CLIENT_CONNECTION_CHK(const l7vs::tcp_session::TCP_PROCESS_TYPE_TAG process_type){
960 down_call_func_type = l7vs::tcp_session::DOWN_FUNC_CLIENT_CONNECTION_CHK;
964 // void test_UP_FUNC_CLIENT_DISCONNECT_EVENT(const l7vs::tcp_session::TCP_PROCESS_TYPE_TAG process_type){
965 // up_call_func_type = l7vs::tcp_session::UP_FUNC_CLIENT_DISCONNECT_EVENT;
968 void test_UP_FUNC_CLIENT_RECEIVE(const l7vs::tcp_session::TCP_PROCESS_TYPE_TAG process_type){
969 up_call_func_type = l7vs::tcp_session::UP_FUNC_CLIENT_RECEIVE;
972 void test_UP_FUNC_CLIENT_RESPOND_SEND(const l7vs::tcp_session::TCP_PROCESS_TYPE_TAG process_type){
973 up_call_func_type = l7vs::tcp_session::UP_FUNC_CLIENT_RESPOND_SEND;
976 // void test_UP_FUNC_CLIENT_RESPOND_SEND_EVENT(const TCP_PROCESS_TYPE_TAG process_type){
977 // up_call_func_type = l7vs::tcp_session::UP_FUNC_CLIENT_RESPOND_SEND_EVENT;
980 void test_DOWN_FUNC_REALSERVER_RECEIVE(const l7vs::tcp_session::TCP_PROCESS_TYPE_TAG process_type){
981 down_call_func_type = l7vs::tcp_session::DOWN_FUNC_REALSERVER_RECEIVE;
985 void test_UP_FUNC_REALSERVER_GET_DEST_EVENT(const TCP_PROCESS_TYPE_TAG process_type){
986 up_call_func_type = l7vs::tcp_session::UP_FUNC_REALSERVER_GET_DEST_EVENT;
989 void test_UP_FUNC_REALSERVER_CONNECT(const TCP_PROCESS_TYPE_TAG process_type){
990 up_call_func_type = l7vs::tcp_session::UP_FUNC_REALSERVER_CONNECT;
993 // void test_UP_FUNC_REALSERVER_CONNECT_EVENT(const TCP_PROCESS_TYPE_TAG process_type){
994 // up_call_func_type = l7vs::tcp_session::UP_FUNC_REALSERVER_CONNECT_EVENT;
997 // void test_UP_FUNC_REALSERVER_CONNECT_FAIL_EVENT(const TCP_PROCESS_TYPE_TAG process_type){
998 // up_call_func_type = l7vs::tcp_session::UP_FUNC_REALSERVER_CONNECT_FAIL_EVENT;
1001 void test_UP_FUNC_REALSERVER_SEND(const TCP_PROCESS_TYPE_TAG process_type){
1002 up_call_func_type = l7vs::tcp_session::UP_FUNC_REALSERVER_SEND;
1005 // void test_UP_FUNC_REALSERVER_DISCONNECT(const TCP_PROCESS_TYPE_TAG process_type){
1006 // up_call_func_type = l7vs::tcp_session::UP_FUNC_REALSERVER_DISCONNECT;
1009 // void test_UP_FUNC_REALSERVER_DISCONNECT_EVENT(const TCP_PROCESS_TYPE_TAG process_type){
1010 // up_call_func_type = l7vs::tcp_session::UP_FUNC_REALSERVER_DISCONNECT_EVENT;
1013 void test_UP_FUNC_REALSERVER_ALL_DISCONNECT(const TCP_PROCESS_TYPE_TAG process_type){
1014 up_call_func_type = l7vs::tcp_session::UP_FUNC_REALSERVER_ALL_DISCONNECT;
1017 void test_DOWN_FUNC_REALSERVER_ALL_DISCONNECT(const TCP_PROCESS_TYPE_TAG process_type){
1018 down_call_func_type = l7vs::tcp_session::DOWN_FUNC_REALSERVER_ALL_DISCONNECT;
1021 void test_DOWN_FUNC_SORRYSERVER_RECEIVE(const l7vs::tcp_session::TCP_PROCESS_TYPE_TAG process_type){
1022 down_call_func_type = l7vs::tcp_session::DOWN_FUNC_SORRYSERVER_RECEIVE;
1025 void test_UP_FUNC_SORRYSERVER_GET_DEST(const TCP_PROCESS_TYPE_TAG process_type){
1026 up_call_func_type = l7vs::tcp_session::UP_FUNC_SORRYSERVER_GET_DEST;
1029 void test_UP_FUNC_SORRYSERVER_CONNECT(const TCP_PROCESS_TYPE_TAG process_type){
1030 up_call_func_type = l7vs::tcp_session::UP_FUNC_SORRYSERVER_CONNECT;
1033 // void test_UP_FUNC_SORRYSERVER_CONNECT_EVENT(const TCP_PROCESS_TYPE_TAG process_type){
1034 // up_call_func_type = l7vs::tcp_session::UP_FUNC_SORRYSERVER_CONNECT_EVENT;
1037 // void test_UP_FUNC_SORRYSERVER_CONNECT_FAIL_EVENT(const TCP_PROCESS_TYPE_TAG process_type){
1038 // up_call_func_type = l7vs::tcp_session::UP_FUNC_SORRYSERVER_CONNECT_FAIL_EVENT;
1041 void test_UP_FUNC_SORRYSERVER_SEND(const TCP_PROCESS_TYPE_TAG process_type){
1042 up_call_func_type = l7vs::tcp_session::UP_FUNC_SORRYSERVER_SEND;
1045 void test_UP_FUNC_SORRYSERVER_DISCONNECT(const TCP_PROCESS_TYPE_TAG process_type){
1046 up_call_func_type = l7vs::tcp_session::UP_FUNC_SORRYSERVER_DISCONNECT;
1049 void test_DOWN_FUNC_SORRYSERVER_DISCONNECT(const TCP_PROCESS_TYPE_TAG process_type){
1050 down_call_func_type = l7vs::tcp_session::DOWN_FUNC_SORRYSERVER_DISCONNECT;
1053 // void test_UP_FUNC_SORRYSERVER_DISCONNECT_EVENT(const TCP_PROCESS_TYPE_TAG process_type){
1054 // up_call_func_type = l7vs::tcp_session::UP_FUNC_SORRYSERVER_DISCONNECT_EVENT;
1057 // void test_UP_FUNC_SORRY_ENABLE_EVENT(const TCP_PROCESS_TYPE_TAG process_type){
1058 // up_call_func_type = l7vs::tcp_session::UP_FUNC_SORRY_ENABLE_EVENT;
1061 // void test_UP_FUNC_SORRY_DISABLE_EVENT(const TCP_PROCESS_TYPE_TAG process_type){
1062 // up_call_func_type = l7vs::tcp_session::UP_FUNC_SORRY_DISABLE_EVENT;
1065 void test_UP_FUNC_EXIT(const TCP_PROCESS_TYPE_TAG process_type){
1066 up_call_func_type = l7vs::tcp_session::UP_FUNC_EXIT;
1069 void test_DOWN_FUNC_EXIT(const TCP_PROCESS_TYPE_TAG process_type){
1070 down_call_func_type = l7vs::tcp_session::DOWN_FUNC_EXIT;
1073 l7vs::tcp_session::UP_THREAD_FUNC_TYPE_TAG up_call_func_type;
1074 l7vs::tcp_session::DOWN_THREAD_FUNC_TYPE_TAG down_call_func_type;
1081 // constructer test class
1082 class constructer_test_class : public l7vs::tcp_session{
1084 constructer_test_class(
1085 l7vs::virtualservice_tcp& vs,
1086 boost::asio::io_service& session_io,
1087 l7vs::tcp_socket_option_info& set_socket_option,
1088 boost::asio::ip::tcp::endpoint listen_endpoint,
1090 boost::asio::ssl::context& set_ssl_context,
1091 bool set_ssl_cache_flag,
1092 int set_ssl_handshake_time_out,
1093 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
1100 set_ssl_handshake_time_out,
1101 set_access_logger){};
1102 ~constructer_test_class(){};
1103 boost::asio::io_service& get_io(){
1106 l7vs::virtualservice_tcp& get_parent_service(){
1107 return parent_service;
1109 bool get_exit_flag(){
1110 return (bool)exit_flag;
1113 std::bitset<TCP_SESSION_THREAD_STATE_BIT> get_thread_state(){
1114 return thread_state;
1117 l7vs::tcp_session::UPTHREAD_STATUS_TAG& get_up_status(){
1118 return upthread_status;
1121 l7vs::tcp_session::DOWNTHREAD_STATUS_TAG& get_down_status(){
1122 return downthread_status;
1125 l7vs::protocol_module_base* get_protocol_module(){
1126 return protocol_module;
1129 bool get_session_pause_flag(){
1130 return session_pause_flag;
1133 l7vs::tcp_socket& get_client_socket(){
1134 return client_socket;
1136 boost::shared_ptr< l7vs::tcp_socket > get_sorry_socket(){
1137 return sorryserver_socket.second;
1140 l7vs::tcp_ssl_socket& get_client_ssl_socket(){
1141 return client_ssl_socket;
1144 l7vs::tcp_socket_option_info* get_socket_opt_info(){
1145 return &socket_opt_info;
1147 //! virtualservice accept endpoint
1148 boost::asio::ip::tcp::endpoint& get_virtualservice_endpoint(){
1149 return virtualservice_endpoint;
1151 //! access log out put flag
1152 bool get_accesslog_flag(){
1153 return access_log_flag;
1156 l7vs::logger_implement_access* get_access_logger(){
1157 return access_logger;
1160 bool get_ssl_flag(){
1164 boost::asio::ssl::context& get_ssl_context(){
1167 //! ssl session cache flag
1168 bool get_ssl_cache_flag(){
1169 return ssl_cache_flag;
1171 //! handshake timer flag
1172 bool get_ssl_handshake_timer_flag(){
1173 return ssl_handshake_timer_flag;
1175 //! handshake timeout
1176 int get_ssl_handshake_time_out(){
1177 return ssl_handshake_time_out;
1179 //! handshake timeout flag
1180 bool get_ssl_handshake_timeout_flag(){
1181 return ssl_handshake_time_out_flag;
1184 //! up thread raise module event of handle_accept
1185 //! @param[in] process_type is prosecess type
1186 void up_thread_client_accept(const TCP_PROCESS_TYPE_TAG process_type){
1187 up_thread_client_accept_call_check = true;
1189 bool up_thread_client_accept_call_check;
1191 //! up thread raise module event of handle_accept
1192 //! @param[in] process_type is prosecess type
1193 void up_thread_client_accept_event(const TCP_PROCESS_TYPE_TAG process_type){
1194 up_thread_client_accept_event_call_check = true;
1196 bool up_thread_client_accept_event_call_check;
1197 //! up thread receive client side and raise module event of handle_client_recv
1198 //! @param[in] process_type is prosecess type
1199 void up_thread_client_receive(const TCP_PROCESS_TYPE_TAG process_type){
1200 up_thread_client_receive_call_check = true;
1202 bool up_thread_client_receive_call_check;
1203 //! up thread raise client respond send event message for up and down thread
1204 //! @param[in] process_type is prosecess type
1205 void up_thread_client_respond(const TCP_PROCESS_TYPE_TAG process_type){
1206 up_thread_client_respond_call_check = true;
1208 bool up_thread_client_respond_call_check;
1209 //! up thread raise module event of handle_response_send_inform
1210 //! @param[in] process_type is prosecess type
1211 void up_thread_client_respond_event(const TCP_PROCESS_TYPE_TAG process_type){
1212 up_thread_client_respond_event_call_check = true;
1214 bool up_thread_client_respond_event_call_check;
1215 //! up thread close client socket and raise client disconnect event message for up and down thread
1216 //! @param[in] process_type is prosecess type
1217 void up_thread_client_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
1218 up_thread_client_disconnect_call_check = true;
1220 bool up_thread_client_disconnect_call_check;
1221 //! up thread raise module event of handle_client_disconnect
1222 //! @param[in] process_type is prosecess type
1223 void up_thread_client_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){
1224 up_thread_client_disconnect_event_call_check = true;
1226 bool up_thread_client_disconnect_event_call_check;
1227 //! up thread send realserver and raise module event of handle_client_recv
1228 //! @param[in] process_type is prosecess type
1229 void up_thread_realserver_send(const TCP_PROCESS_TYPE_TAG process_type){
1230 up_thread_realserver_send_call_check = true;
1232 bool up_thread_realserver_send_call_check;
1233 //! up thread raise module event of handle_realserver_select
1234 //! @param[in] process_type is prosecess type
1235 void up_thread_realserver_get_destination_event(const TCP_PROCESS_TYPE_TAG process_type){
1236 up_thread_realserver_get_destination_event_call_check = true;
1238 bool up_thread_realserver_get_destination_event_call_check;
1239 //! up thread connect realserver
1240 //! @param[in] process_type is prosecess type
1241 void up_thread_realserver_connect(const TCP_PROCESS_TYPE_TAG process_type){
1242 up_thread_realserver_connect_call_check = true;
1244 bool up_thread_realserver_connect_call_check;
1245 //! up thread raise module event of handle_realserver_connect
1246 //! @param[in] process_type is prosecess type
1247 void up_thread_realserver_connect_event(const TCP_PROCESS_TYPE_TAG process_type){
1248 up_thread_realserver_connect_event_call_check = true;
1250 bool up_thread_realserver_connect_event_call_check;
1251 //! up thread raise module event of handle_realserver_connection_fail
1252 //! @param[in] process_type is prosecess type
1253 void up_thread_realserver_connection_fail_event(const TCP_PROCESS_TYPE_TAG process_type){
1254 up_thread_realserver_connection_fail_event_call_check = true;
1256 bool up_thread_realserver_connection_fail_event_call_check;
1257 //! up thread close realserver socket and raise realserver disconnect event message for up and down thread
1258 //! @param[in] process_type is prosecess type
1259 void up_thread_realserver_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
1260 up_thread_realserver_disconnect_call_check = true;
1262 bool up_thread_realserver_disconnect_call_check;
1263 //! up thread raise module event of handle_realserver_disconnect
1264 //! @param[in] process_type is prosecess type
1265 void up_thread_realserver_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){
1266 up_thread_realserver_disconnect_event_call_check = true;
1268 bool up_thread_realserver_disconnect_event_call_check;
1269 //! up thread close all realserver socket and raise module event of handle_realserver_disconnect
1270 //! @param[in] process_type is prosecess type
1271 void up_thread_all_realserver_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
1272 up_thread_all_realserver_disconnect_call_check = true;
1274 bool up_thread_all_realserver_disconnect_call_check;
1275 //! up thread send sorryserver and raise module event of handle_sorryserver_send
1276 //! @param[in] process_type is prosecess type
1277 void up_thread_sorryserver_send(const TCP_PROCESS_TYPE_TAG process_type){
1278 up_thread_sorryserver_send_call_check = true;
1280 bool up_thread_sorryserver_send_call_check;
1281 //! up thread raise module event of handle_sorryserver_select
1282 //! @param[in] process_type is prosecess type
1283 void up_thread_sorryserver_get_destination_event(const TCP_PROCESS_TYPE_TAG process_type){
1284 up_thread_sorryserver_get_destination_event_call_check = true;
1286 bool up_thread_sorryserver_get_destination_event_call_check;
1287 //! up thread connect sorryserver
1288 //! @param[in] process_type is prosecess type
1289 void up_thread_sorryserver_connect(const TCP_PROCESS_TYPE_TAG process_type){
1290 up_thread_sorryserver_connect_call_check = true;
1292 bool up_thread_sorryserver_connect_call_check;
1293 //! up thread raise module event of handle_sorryserver_connect
1294 //! @param[in] process_type is prosecess type
1295 void up_thread_sorryserver_connect_event(const TCP_PROCESS_TYPE_TAG process_type){
1296 up_thread_sorryserver_connect_event_call_check = true;
1298 bool up_thread_sorryserver_connect_event_call_check;
1299 //! up thread raise module event of handle_sorryserver_connection_fail
1300 //! @param[in] process_type is prosecess type
1301 void up_thread_sorryserver_connection_fail_event(const TCP_PROCESS_TYPE_TAG process_type){
1302 up_thread_sorryserver_connection_fail_event_call_check = true;
1304 bool up_thread_sorryserver_connection_fail_event_call_check;
1305 //! up thread close sorryserver socket and raise sorryserver disconnect event message for up and down thread
1306 //! @param[in] process_type is prosecess type
1307 void up_thread_sorryserver_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
1308 up_thread_sorryserver_disconnect_call_check = true;
1310 bool up_thread_sorryserver_disconnect_call_check;
1312 void up_thread_sorryserver_mod_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
1313 up_thread_sorryserver_mod_disconnect_call_check = true;
1315 bool up_thread_sorryserver_mod_disconnect_call_check;
1317 //! up thread raise module event of handle_sorryserver_disconnect
1318 //! @param[in] process_type is prosecess type
1319 void up_thread_sorryserver_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){
1320 up_thread_sorryserver_disconnect_event_call_check = true;
1322 bool up_thread_sorryserver_disconnect_event_call_check;
1323 //! up thread raise module event of handle_sorry_enable
1324 //! @param[in] process_type is prosecess type
1325 void up_thread_sorry_enable_event(const TCP_PROCESS_TYPE_TAG process_type){
1326 up_thread_sorry_enable_event_call_check = true;
1328 bool up_thread_sorry_enable_event_call_check;
1329 //! up thread raise module event of handle_sorry_disable
1330 //! @param[in] process_type is prosecess type
1331 void up_thread_sorry_disable_event(const TCP_PROCESS_TYPE_TAG process_type){
1332 up_thread_sorry_disable_event_call_check = true;
1334 bool up_thread_sorry_disable_event_call_check;
1335 //! up thread exit main loop
1336 //! @param[in] process_type is prosecess type
1337 void up_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
1338 up_thread_exit_call_check = true;
1340 bool up_thread_exit_call_check;
1341 //! down thread receive from realserver and raise module event of handle_realserver_recv
1342 //! @param[in] process_type is prosecess type
1343 void down_thread_realserver_receive(const TCP_PROCESS_TYPE_TAG process_type){
1344 down_thread_realserver_receive_call_check = true;
1346 bool down_thread_realserver_receive_call_check;
1347 //! down thread close realserver socket and raise realserver disconnect event message for up and down thread
1348 //! @param[in] process_type is prosecess type
1349 void down_thread_realserver_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
1350 down_thread_realserver_disconnect_call_check = true;
1352 bool down_thread_realserver_disconnect_call_check;
1353 //! down thread raise module event of handle_realserver_disconnect
1354 //! @param[in] process_type is prosecess type
1355 void down_thread_realserver_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){
1356 down_thread_realserver_disconnect_event_call_check = true;
1358 bool down_thread_realserver_disconnect_event_call_check;
1359 //! down thread close all realserver socket and raise module event of handle_realserver_disconnect
1360 //! @param[in] process_type is prosecess type
1361 void down_thread_all_realserver_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
1362 down_thread_all_realserver_disconnect_call_check = true;
1364 bool down_thread_all_realserver_disconnect_call_check;
1365 //! down thread raise module event of handle_client_connection_check
1366 //! @param[in] process_type is prosecess type
1367 void down_thread_client_connection_chk_event(const TCP_PROCESS_TYPE_TAG process_type){
1368 down_thread_client_connection_chk_event_call_check = true;
1370 bool down_thread_client_connection_chk_event_call_check;
1371 //! down thread raise module event of handle_response_send_inform
1372 //! @param[in] process_type is prosecess type
1373 void down_thread_client_respond_event(const TCP_PROCESS_TYPE_TAG process_type){
1374 down_thread_client_respond_event_call_check = true;
1376 bool down_thread_client_respond_event_call_check;
1377 //! down thread send for client and raise module event of handle_client_send
1378 //! @param[in] process_type is prosecess type
1379 void down_thread_client_send(const TCP_PROCESS_TYPE_TAG process_type){
1380 down_thread_client_send_call_check = true;
1382 bool down_thread_client_send_call_check;
1383 //! down thread close client socket and raise client disconnect event message for up and down thread
1384 //! @param[in] process_type is prosecess type
1385 void down_thread_client_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
1386 down_thread_client_disconnect_call_check = true;
1388 bool down_thread_client_disconnect_call_check;
1389 //! down thread raise module event of handle_client_disconnect
1390 //! @param[in] process_type is prosecess type
1391 void down_thread_client_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){
1392 down_thread_client_disconnect_event_call_check = true;
1394 bool down_thread_client_disconnect_event_call_check;
1395 //! down thread receive from sorryserver and raise module event of handle_sorryserver_recv
1396 //! @param[in] process_type is prosecess type
1397 void down_thread_sorryserver_receive(const TCP_PROCESS_TYPE_TAG process_type){
1398 down_thread_sorryserver_receive_call_check = true;
1400 bool down_thread_sorryserver_receive_call_check;
1401 //! down thread close sorryserver socket and raise sorryserver disconnect event message for up and down thread
1402 //! @param[in] process_type is prosecess type
1403 void down_thread_sorryserver_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
1404 down_thread_sorryserver_disconnect_call_check = true;
1406 bool down_thread_sorryserver_disconnect_call_check;
1408 void down_thread_sorryserver_mod_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
1409 down_thread_sorryserver_mod_disconnect_call_check = true;
1411 bool down_thread_sorryserver_mod_disconnect_call_check;
1412 //! down thread raise module event of handle_sorryserver_disconnect
1413 //! @param[in] process_type is prosecess type
1414 void down_thread_sorryserver_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){
1415 down_thread_sorryserver_disconnect_event_call_check = true;
1417 bool down_thread_sorryserver_disconnect_event_call_check;
1418 //! down thread raise module event of handle_sorry_enable
1419 //! @param[in] process_type is prosecess type
1420 void down_thread_sorry_enable_event(const TCP_PROCESS_TYPE_TAG process_type){
1421 down_thread_sorry_enable_event_call_check = true;
1423 bool down_thread_sorry_enable_event_call_check;
1424 //! down thread raise module event of handle_sorry_disable
1425 //! @param[in] process_type is prosecess type
1426 void down_thread_sorry_disable_event(const TCP_PROCESS_TYPE_TAG process_type){
1427 down_thread_sorry_disable_event_call_check = true;
1429 bool down_thread_sorry_disable_event_call_check;
1430 //! down thread exit main loop
1431 //! @param[in] process_type is prosecess type
1432 void down_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
1433 down_thread_exit_call_check = true;
1435 bool down_thread_exit_call_check;
1439 void check_up_thread_module_event_map(){
1440 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::INITIALIZE) == up_thread_module_event_map.end());
1441 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::ACCEPT)->second == l7vs::tcp_session::UP_FUNC_CLIENT_ACCEPT);
1442 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::CLIENT_RECV)->second == l7vs::tcp_session::UP_FUNC_CLIENT_RECEIVE);
1443 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::REALSERVER_SELECT)->second == l7vs::tcp_session::UP_FUNC_REALSERVER_GET_DEST_EVENT);
1444 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::REALSERVER_CONNECT)->second == l7vs::tcp_session::UP_FUNC_REALSERVER_CONNECT);
1445 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::REALSERVER_SEND)->second == l7vs::tcp_session::UP_FUNC_REALSERVER_SEND);
1446 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::SORRYSERVER_SELECT)->second == l7vs::tcp_session::UP_FUNC_SORRYSERVER_GET_DEST);
1447 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::SORRYSERVER_CONNECT)->second == l7vs::tcp_session::UP_FUNC_SORRYSERVER_CONNECT);
1448 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::SORRYSERVER_SEND)->second == l7vs::tcp_session::UP_FUNC_SORRYSERVER_SEND);
1449 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::REALSERVER_RECV) == up_thread_module_event_map.end());
1450 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::SORRYSERVER_RECV) == up_thread_module_event_map.end());
1451 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::CLIENT_SELECT) == up_thread_module_event_map.end());
1452 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::CLIENT_CONNECTION_CHECK) == up_thread_module_event_map.end());
1453 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::CLIENT_SEND) == up_thread_module_event_map.end());
1454 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::CLIENT_RESPONSE_SEND)->second == l7vs::tcp_session::UP_FUNC_CLIENT_RESPOND_SEND);
1455 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::REALSERVER_DISCONNECT)->second == l7vs::tcp_session::UP_FUNC_REALSERVER_ALL_DISCONNECT);
1456 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::SORRYSERVER_DISCONNECT)->second == l7vs::tcp_session::UP_FUNC_SORRYSERVER_MOD_DISCONNECT);
1457 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::CLIENT_DISCONNECT)->second == l7vs::tcp_session::UP_FUNC_CLIENT_DISCONNECT);
1458 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::REALSERVER_CLOSE) == up_thread_module_event_map.end());
1459 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::FINALIZE)->second == l7vs::tcp_session::UP_FUNC_EXIT);
1460 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::STOP) == up_thread_module_event_map.end());
1462 void check_down_thread_module_event_map(){
1463 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::INITIALIZE) == down_thread_module_event_map.end());
1464 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::ACCEPT) == down_thread_module_event_map.end());
1465 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::CLIENT_RECV) == down_thread_module_event_map.end());
1466 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::REALSERVER_SELECT) == down_thread_module_event_map.end());
1467 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::REALSERVER_CONNECT) == down_thread_module_event_map.end());
1468 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::REALSERVER_SEND) == down_thread_module_event_map.end());
1469 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::SORRYSERVER_SELECT) == down_thread_module_event_map.end());
1470 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::SORRYSERVER_CONNECT) == down_thread_module_event_map.end());
1471 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::SORRYSERVER_SEND) == down_thread_module_event_map.end());
1472 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::REALSERVER_RECV)->second == l7vs::tcp_session::DOWN_FUNC_REALSERVER_RECEIVE);
1473 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::SORRYSERVER_RECV)->second == l7vs::tcp_session::DOWN_FUNC_SORRYSERVER_RECEIVE);
1474 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::CLIENT_SELECT) == down_thread_module_event_map.end());
1475 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::CLIENT_CONNECTION_CHECK)->second == l7vs::tcp_session::DOWN_FUNC_CLIENT_CONNECTION_CHK);
1476 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::CLIENT_SEND)->second == l7vs::tcp_session::DOWN_FUNC_CLIENT_SEND);
1477 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::CLIENT_RESPONSE_SEND) == down_thread_module_event_map.end());
1478 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::REALSERVER_DISCONNECT)->second == l7vs::tcp_session::DOWN_FUNC_REALSERVER_ALL_DISCONNECT);
1479 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::SORRYSERVER_DISCONNECT)->second == l7vs::tcp_session::DOWN_FUNC_SORRYSERVER_MOD_DISCONNECT);
1480 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::CLIENT_DISCONNECT)->second == l7vs::tcp_session::DOWN_FUNC_CLIENT_DISCONNECT);
1481 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::REALSERVER_CLOSE) == down_thread_module_event_map.end());
1482 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::FINALIZE)->second == l7vs::tcp_session::DOWN_FUNC_EXIT);
1483 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::STOP) == down_thread_module_event_map.end());
1486 void check_up_thread_function_map(){
1487 up_thread_function_pair check_it;
1489 // UP_FUNC_CLIENT_ACCEPT up_thread_client_accept function
1490 check_it = up_thread_function_array[UP_FUNC_CLIENT_ACCEPT];
1491 BOOST_CHECK(check_it.second != NULL);
1492 up_thread_client_accept_call_check = false;
1493 check_it.second(LOCAL_PROC);
1494 BOOST_CHECK(up_thread_client_accept_call_check);
1497 // UP_FUNC_CLIENT_ACCEPT_EVENT up_thread_client_accept_event function
1498 check_it = up_thread_function_array[UP_FUNC_CLIENT_ACCEPT_EVENT];
1499 BOOST_CHECK(check_it.second != NULL);
1500 up_thread_client_accept_event_call_check = false;
1501 check_it.second(LOCAL_PROC);
1502 BOOST_CHECK(up_thread_client_accept_event_call_check);
1504 // UP_FUNC_CLIENT_DISCONNECT up_thread_client_disconnect function
1505 check_it = up_thread_function_array[UP_FUNC_CLIENT_DISCONNECT];
1506 BOOST_CHECK(check_it.second != NULL);
1507 up_thread_client_disconnect_call_check = false;
1508 check_it.second(LOCAL_PROC);
1509 BOOST_CHECK(up_thread_client_disconnect_call_check);
1511 // UP_FUNC_CLIENT_DISCONNECT_EVENT up_thread_client_disconnect_event function
1512 check_it = up_thread_function_array[UP_FUNC_CLIENT_DISCONNECT_EVENT];
1513 BOOST_CHECK(check_it.second != NULL);
1514 up_thread_client_disconnect_event_call_check = false;
1515 check_it.second(LOCAL_PROC);
1516 BOOST_CHECK(up_thread_client_disconnect_event_call_check);
1518 // UP_FUNC_CLIENT_RECEIVE up_thread_client_receive function
1519 check_it = up_thread_function_array[UP_FUNC_CLIENT_RECEIVE];
1520 BOOST_CHECK(check_it.second != NULL);
1521 up_thread_client_receive_call_check = false;
1522 check_it.second(LOCAL_PROC);
1523 BOOST_CHECK(up_thread_client_receive_call_check);
1525 // UP_FUNC_CLIENT_RESPOND_SEND up_thread_client_respond function
1526 check_it = up_thread_function_array[UP_FUNC_CLIENT_RESPOND_SEND];
1527 BOOST_CHECK(check_it.second != NULL);
1528 up_thread_client_respond_call_check = false;
1529 check_it.second(LOCAL_PROC);
1530 BOOST_CHECK(up_thread_client_respond_call_check);
1532 // UP_FUNC_CLIENT_RESPOND_SEND_EVENT up_thread_client_respond_event function
1533 check_it = up_thread_function_array[UP_FUNC_CLIENT_RESPOND_SEND_EVENT];
1534 BOOST_CHECK(check_it.second != NULL);
1535 up_thread_client_respond_event_call_check = false;
1536 check_it.second(LOCAL_PROC);
1537 BOOST_CHECK(up_thread_client_respond_event_call_check);
1539 // UP_FUNC_REALSERVER_GET_DEST_EVENT up_thread_realserver_get_destination_event function
1540 check_it = up_thread_function_array[UP_FUNC_REALSERVER_GET_DEST_EVENT];
1541 BOOST_CHECK(check_it.second != NULL);
1542 up_thread_realserver_get_destination_event_call_check = false;
1543 check_it.second(LOCAL_PROC);
1544 BOOST_CHECK(up_thread_realserver_get_destination_event_call_check);
1546 // UP_FUNC_REALSERVER_CONNECT up_thread_realserver_connect function
1547 check_it = up_thread_function_array[UP_FUNC_REALSERVER_CONNECT];
1548 BOOST_CHECK(check_it.second != NULL);
1549 up_thread_realserver_connect_call_check = false;
1550 check_it.second(LOCAL_PROC);
1551 BOOST_CHECK(up_thread_realserver_connect_call_check);
1553 // UP_FUNC_REALSERVER_CONNECT_EVENT up_thread_realserver_connect_event function
1554 check_it = up_thread_function_array[UP_FUNC_REALSERVER_CONNECT_EVENT];
1555 BOOST_CHECK(check_it.second != NULL);
1556 up_thread_realserver_connect_event_call_check = false;
1557 check_it.second(LOCAL_PROC);
1558 BOOST_CHECK(up_thread_realserver_connect_event_call_check);
1560 // UP_FUNC_REALSERVER_CONNECT_FAIL_EVENT up_thread_realserver_connection_fail_event function
1561 check_it = up_thread_function_array[UP_FUNC_REALSERVER_CONNECT_FAIL_EVENT];
1562 BOOST_CHECK(check_it.second != NULL);
1563 up_thread_realserver_connection_fail_event_call_check = false;
1564 check_it.second(LOCAL_PROC);
1565 BOOST_CHECK(up_thread_realserver_connection_fail_event_call_check);
1567 // UP_FUNC_REALSERVER_SEND up_thread_realserver_send function
1568 check_it = up_thread_function_array[UP_FUNC_REALSERVER_SEND];
1569 BOOST_CHECK(check_it.second != NULL);
1570 up_thread_realserver_send_call_check = false;
1571 check_it.second(LOCAL_PROC);
1572 BOOST_CHECK(up_thread_realserver_send_call_check);
1574 // UP_FUNC_REALSERVER_DISCONNECT up_thread_realserver_disconnect function
1575 check_it = up_thread_function_array[UP_FUNC_REALSERVER_DISCONNECT];
1576 BOOST_CHECK(check_it.second != NULL);
1577 up_thread_realserver_disconnect_call_check = false;
1578 check_it.second(LOCAL_PROC);
1579 BOOST_CHECK(up_thread_realserver_disconnect_call_check);
1581 // UP_FUNC_REALSERVER_DISCONNECT_EVENT up_thread_realserver_disconnect_event function
1582 check_it = up_thread_function_array[UP_FUNC_REALSERVER_DISCONNECT_EVENT];
1583 BOOST_CHECK(check_it.second != NULL);
1584 up_thread_realserver_disconnect_event_call_check = false;
1585 check_it.second(LOCAL_PROC);
1586 BOOST_CHECK(up_thread_realserver_disconnect_event_call_check);
1588 // UP_FUNC_REALSERVER_ALL_DISCONNECT up_thread_all_realserver_disconnect function
1589 check_it = up_thread_function_array[UP_FUNC_REALSERVER_ALL_DISCONNECT];
1590 BOOST_CHECK(check_it.second != NULL);
1591 up_thread_all_realserver_disconnect_call_check = false;
1592 check_it.second(LOCAL_PROC);
1593 BOOST_CHECK(up_thread_all_realserver_disconnect_call_check);
1595 // UP_FUNC_SORRYSERVER_GET_DEST up_thread_sorryserver_get_destination_event function
1596 check_it = up_thread_function_array[UP_FUNC_SORRYSERVER_GET_DEST];
1597 BOOST_CHECK(check_it.second != NULL);
1598 up_thread_sorryserver_get_destination_event_call_check = false;
1599 check_it.second(LOCAL_PROC);
1600 BOOST_CHECK(up_thread_sorryserver_get_destination_event_call_check);
1602 // UP_FUNC_SORRYSERVER_CONNECT up_thread_sorryserver_connect function
1603 check_it = up_thread_function_array[UP_FUNC_SORRYSERVER_CONNECT];
1604 BOOST_CHECK(check_it.second != NULL);
1605 up_thread_sorryserver_connect_call_check = false;
1606 check_it.second(LOCAL_PROC);
1607 BOOST_CHECK(up_thread_sorryserver_connect_call_check);
1609 // UP_FUNC_SORRYSERVER_CONNECT_EVENT up_thread_sorryserver_connect_event function
1610 check_it = up_thread_function_array[UP_FUNC_SORRYSERVER_CONNECT_EVENT];
1611 BOOST_CHECK(check_it.second != NULL);
1612 up_thread_sorryserver_connect_event_call_check = false;
1613 check_it.second(LOCAL_PROC);
1614 BOOST_CHECK(up_thread_sorryserver_connect_event_call_check);
1616 // UP_FUNC_SORRYSERVER_CONNECT_FAIL_EVENT up_thread_sorryserver_connection_fail_event function
1617 check_it = up_thread_function_array[UP_FUNC_SORRYSERVER_CONNECT_FAIL_EVENT];
1618 BOOST_CHECK(check_it.second != NULL);
1619 up_thread_sorryserver_connection_fail_event_call_check = false;
1620 check_it.second(LOCAL_PROC);
1621 BOOST_CHECK(up_thread_sorryserver_connection_fail_event_call_check);
1623 // UP_FUNC_SORRYSERVER_SEND up_thread_sorryserver_send function
1624 check_it = up_thread_function_array[UP_FUNC_SORRYSERVER_SEND];
1625 BOOST_CHECK(check_it.second != NULL);
1626 up_thread_sorryserver_send_call_check = false;
1627 check_it.second(LOCAL_PROC);
1628 BOOST_CHECK(up_thread_sorryserver_send_call_check);
1630 // UP_FUNC_SORRYSERVER_DISCONNECT up_thread_sorryserver_disconnect function
1631 check_it = up_thread_function_array[UP_FUNC_SORRYSERVER_DISCONNECT];
1632 BOOST_CHECK(check_it.second != NULL);
1633 up_thread_sorryserver_disconnect_call_check = false;
1634 check_it.second(LOCAL_PROC);
1635 BOOST_CHECK(up_thread_sorryserver_disconnect_call_check);
1637 // UP_FUNC_SORRYSERVER_MOD_DISCONNECT up_thread_sorryserver_mod_disconnect function
1638 check_it = up_thread_function_array[UP_FUNC_SORRYSERVER_MOD_DISCONNECT];
1639 BOOST_CHECK(check_it.second != NULL);
1640 up_thread_sorryserver_mod_disconnect_call_check = false;
1641 check_it.second(LOCAL_PROC);
1642 BOOST_CHECK(up_thread_sorryserver_mod_disconnect_call_check);
1644 // UP_FUNC_SORRYSERVER_DISCONNECT_EVENT up_thread_sorryserver_disconnect_event function
1645 check_it = up_thread_function_array[UP_FUNC_SORRYSERVER_DISCONNECT_EVENT];
1646 BOOST_CHECK(check_it.second != NULL);
1647 up_thread_sorryserver_disconnect_event_call_check = false;
1648 check_it.second(LOCAL_PROC);
1649 BOOST_CHECK(up_thread_sorryserver_disconnect_event_call_check);
1651 // UP_FUNC_SORRY_ENABLE_EVENT up_thread_sorry_enable_event function
1652 check_it = up_thread_function_array[UP_FUNC_SORRY_ENABLE_EVENT];
1653 BOOST_CHECK(check_it.second == NULL);
1655 // UP_FUNC_SORRY_DISABLE_EVENT up_thread_sorry_disable_event function
1656 check_it = up_thread_function_array[UP_FUNC_SORRY_DISABLE_EVENT];
1657 BOOST_CHECK(check_it.second == NULL);
1659 // UP_FUNC_EXIT up_thread_exit function
1660 check_it = up_thread_function_array[UP_FUNC_EXIT];
1661 BOOST_CHECK(check_it.second != NULL);
1662 up_thread_exit_call_check = false;
1663 check_it.second(LOCAL_PROC);
1664 BOOST_CHECK(up_thread_exit_call_check);
1668 void check_down_thread_function_map(){
1669 down_thread_function_pair check_it;
1671 // DOWN_FUNC_CLIENT_DISCONNECT down_thread_client_disconnect function
1672 check_it = down_thread_function_array[DOWN_FUNC_CLIENT_DISCONNECT];
1673 BOOST_CHECK(check_it.second != NULL);
1674 down_thread_client_disconnect_call_check = false;
1675 check_it.second(LOCAL_PROC);
1676 BOOST_CHECK(down_thread_client_disconnect_call_check);
1678 // DOWN_FUNC_CLIENT_DISCONNECT_EVENT down_thread_client_disconnect_event function
1679 check_it = down_thread_function_array[DOWN_FUNC_CLIENT_DISCONNECT_EVENT];
1680 BOOST_CHECK(check_it.second != NULL);
1681 down_thread_client_disconnect_event_call_check = false;
1682 check_it.second(LOCAL_PROC);
1683 BOOST_CHECK(down_thread_client_disconnect_event_call_check);
1685 // DOWN_FUNC_CLIENT_CONNECTION_CHK down_thread_client_connection_chk_event function
1686 check_it = down_thread_function_array[DOWN_FUNC_CLIENT_CONNECTION_CHK];
1687 BOOST_CHECK(check_it.second != NULL);
1688 down_thread_client_connection_chk_event_call_check = false;
1689 check_it.second(LOCAL_PROC);
1690 BOOST_CHECK(down_thread_client_connection_chk_event_call_check);
1692 // DOWN_FUNC_CLIENT_SEND down_thread_client_send function
1693 check_it = down_thread_function_array[DOWN_FUNC_CLIENT_SEND];
1694 BOOST_CHECK(check_it.second != NULL);
1695 down_thread_client_send_call_check = false;
1696 check_it.second(LOCAL_PROC);
1697 BOOST_CHECK(down_thread_client_send_call_check);
1699 // DOWN_FUNC_CLIENT_RESPOND_SEND_EVENT down_thread_client_respond_event function
1700 check_it = down_thread_function_array[DOWN_FUNC_CLIENT_RESPOND_SEND_EVENT];
1701 BOOST_CHECK(check_it.second == NULL);
1703 // DOWN_FUNC_REALSERVER_RECEIVE down_thread_realserver_receive function
1704 check_it = down_thread_function_array[DOWN_FUNC_REALSERVER_RECEIVE];
1705 BOOST_CHECK(check_it.second != NULL);
1706 down_thread_realserver_receive_call_check = false;
1707 check_it.second(LOCAL_PROC);
1708 BOOST_CHECK(down_thread_realserver_receive_call_check);
1710 // DOWN_FUNC_REALSERVER_DISCONNECT down_thread_realserver_disconnect function
1711 check_it = down_thread_function_array[DOWN_FUNC_REALSERVER_DISCONNECT];
1712 BOOST_CHECK(check_it.second != NULL);
1713 down_thread_realserver_disconnect_call_check = false;
1714 check_it.second(LOCAL_PROC);
1715 BOOST_CHECK(down_thread_realserver_disconnect_call_check);
1717 // DOWN_FUNC_REALSERVER_DISCONNECT_EVENT down_thread_realserver_disconnect_event function
1718 check_it = down_thread_function_array[DOWN_FUNC_REALSERVER_DISCONNECT_EVENT];
1719 BOOST_CHECK(check_it.second != NULL);
1720 down_thread_realserver_disconnect_event_call_check = false;
1721 check_it.second(LOCAL_PROC);
1722 BOOST_CHECK(down_thread_realserver_disconnect_event_call_check);
1724 // DOWN_FUNC_REALSERVER_ALL_DISCONNECT down_thread_all_realserver_disconnect function
1725 check_it = down_thread_function_array[DOWN_FUNC_REALSERVER_ALL_DISCONNECT];
1726 BOOST_CHECK(check_it.second != NULL);
1727 down_thread_all_realserver_disconnect_call_check = false;
1728 check_it.second(LOCAL_PROC);
1729 BOOST_CHECK(down_thread_all_realserver_disconnect_call_check);
1731 // DOWN_FUNC_SORRYSERVER_RECEIVE down_thread_sorryserver_receive function
1732 check_it = down_thread_function_array[DOWN_FUNC_SORRYSERVER_RECEIVE];
1733 BOOST_CHECK(check_it.second != NULL);
1734 down_thread_sorryserver_receive_call_check = false;
1735 check_it.second(LOCAL_PROC);
1736 BOOST_CHECK(down_thread_sorryserver_receive_call_check);
1738 // DOWN_FUNC_SORRYSERVER_DISCONNECT down_thread_sorryserver_disconnect function
1739 check_it = down_thread_function_array[DOWN_FUNC_SORRYSERVER_DISCONNECT];
1740 BOOST_CHECK(check_it.second != NULL);
1741 down_thread_sorryserver_disconnect_call_check = false;
1742 check_it.second(LOCAL_PROC);
1743 BOOST_CHECK(down_thread_sorryserver_disconnect_call_check);
1745 // DOWN_FUNC_SORRYSERVER_MOD_DISCONNECT down_thread_sorryserver_mod_disconnect function
1746 check_it = down_thread_function_array[DOWN_FUNC_SORRYSERVER_MOD_DISCONNECT];
1747 BOOST_CHECK(check_it.second != NULL);
1748 down_thread_sorryserver_mod_disconnect_call_check = false;
1749 check_it.second(LOCAL_PROC);
1750 BOOST_CHECK(down_thread_sorryserver_mod_disconnect_call_check);
1752 // DOWN_FUNC_SORRYSERVER_DISCONNECT_EVENT down_thread_sorryserver_disconnect_event function
1753 check_it = down_thread_function_array[DOWN_FUNC_SORRYSERVER_DISCONNECT_EVENT];
1754 BOOST_CHECK(check_it.second != NULL);
1755 down_thread_sorryserver_disconnect_event_call_check = false;
1756 check_it.second(LOCAL_PROC);
1757 BOOST_CHECK(down_thread_sorryserver_disconnect_event_call_check);
1759 // DOWN_FUNC_SORRY_ENABLE_EVENT down_thread_sorry_enable_event function
1760 check_it = down_thread_function_array[DOWN_FUNC_SORRY_ENABLE_EVENT];
1761 BOOST_CHECK(check_it.second == NULL);
1763 // DOWN_FUNC_SORRY_DISABLE_EVENT down_thread_sorry_disable_event function
1764 check_it = down_thread_function_array[DOWN_FUNC_SORRY_DISABLE_EVENT];
1765 BOOST_CHECK(check_it.second == NULL);
1767 // DOWN_FUNC_EXIT down_thread_exit function
1768 check_it = down_thread_function_array[DOWN_FUNC_EXIT];
1769 BOOST_CHECK(check_it.second != NULL);
1770 down_thread_exit_call_check = false;
1771 check_it.second(LOCAL_PROC);
1772 BOOST_CHECK(down_thread_exit_call_check);
1776 void check_up_thread_message_down_thread_function_map(){
1777 std::map< DOWN_THREAD_FUNC_TYPE_TAG, tcp_session_func >::iterator check_it;
1779 // DOWN_FUNC_CLIENT_DISCONNECT down_thread_client_disconnect function
1780 check_it = up_thread_message_down_thread_function_map.find(DOWN_FUNC_CLIENT_DISCONNECT);
1781 BOOST_CHECK(check_it == up_thread_message_down_thread_function_map.end());
1783 // DOWN_FUNC_CLIENT_DISCONNECT_EVENT down_thread_client_disconnect_event function
1784 check_it = up_thread_message_down_thread_function_map.find(DOWN_FUNC_CLIENT_DISCONNECT_EVENT);
1785 BOOST_CHECK(check_it != up_thread_message_down_thread_function_map.end());
1786 down_thread_client_disconnect_event_call_check = false;
1787 check_it->second(LOCAL_PROC);
1788 BOOST_CHECK(down_thread_client_disconnect_event_call_check);
1790 // DOWN_FUNC_CLIENT_CONNECTION_CHK down_thread_client_connection_chk_event function
1791 check_it = up_thread_message_down_thread_function_map.find(DOWN_FUNC_CLIENT_CONNECTION_CHK);
1792 BOOST_CHECK(check_it == up_thread_message_down_thread_function_map.end());
1794 // DOWN_FUNC_CLIENT_SEND down_thread_client_send function
1795 check_it = up_thread_message_down_thread_function_map.find(DOWN_FUNC_CLIENT_SEND);
1796 BOOST_CHECK(check_it == up_thread_message_down_thread_function_map.end());
1798 // DOWN_FUNC_CLIENT_RESPOND_SEND_EVENT down_thread_client_respond_event function
1799 check_it = up_thread_message_down_thread_function_map.find(DOWN_FUNC_CLIENT_RESPOND_SEND_EVENT);
1800 BOOST_CHECK(check_it != up_thread_message_down_thread_function_map.end());
1801 down_thread_client_respond_event_call_check = false;
1802 check_it->second(LOCAL_PROC);
1803 BOOST_CHECK(down_thread_client_respond_event_call_check);
1805 // DOWN_FUNC_REALSERVER_RECEIVE down_thread_realserver_receive function
1806 check_it = up_thread_message_down_thread_function_map.find(DOWN_FUNC_REALSERVER_RECEIVE);
1807 BOOST_CHECK(check_it == up_thread_message_down_thread_function_map.end());
1809 // DOWN_FUNC_REALSERVER_DISCONNECT down_thread_realserver_disconnect function
1810 check_it = up_thread_message_down_thread_function_map.find(DOWN_FUNC_REALSERVER_DISCONNECT);
1811 BOOST_CHECK(check_it == up_thread_message_down_thread_function_map.end());
1813 // DOWN_FUNC_REALSERVER_DISCONNECT_EVENT down_thread_realserver_disconnect_event function
1814 check_it = up_thread_message_down_thread_function_map.find(DOWN_FUNC_REALSERVER_DISCONNECT_EVENT);
1815 BOOST_CHECK(check_it != up_thread_message_down_thread_function_map.end());
1816 down_thread_realserver_disconnect_event_call_check = false;
1817 check_it->second(LOCAL_PROC);
1818 BOOST_CHECK(down_thread_realserver_disconnect_event_call_check);
1820 // DOWN_FUNC_REALSERVER_ALL_DISCONNECT down_thread_all_realserver_disconnect function
1821 check_it = up_thread_message_down_thread_function_map.find(DOWN_FUNC_REALSERVER_ALL_DISCONNECT);
1822 BOOST_CHECK(check_it == up_thread_message_down_thread_function_map.end());
1824 // DOWN_FUNC_SORRYSERVER_RECEIVE down_thread_sorryserver_receive function
1825 check_it = up_thread_message_down_thread_function_map.find(DOWN_FUNC_SORRYSERVER_RECEIVE);
1826 BOOST_CHECK(check_it == up_thread_message_down_thread_function_map.end());
1828 // DOWN_FUNC_SORRYSERVER_DISCONNECT down_thread_sorryserver_disconnect function
1829 check_it = up_thread_message_down_thread_function_map.find(DOWN_FUNC_SORRYSERVER_DISCONNECT);
1830 BOOST_CHECK(check_it == up_thread_message_down_thread_function_map.end());
1832 // DOWN_FUNC_SORRYSERVER_DISCONNECT_EVENT down_thread_sorryserver_disconnect_event function
1833 check_it = up_thread_message_down_thread_function_map.find(DOWN_FUNC_SORRYSERVER_DISCONNECT_EVENT);
1834 BOOST_CHECK(check_it != up_thread_message_down_thread_function_map.end());
1835 down_thread_sorryserver_disconnect_event_call_check = false;
1836 check_it->second(LOCAL_PROC);
1837 BOOST_CHECK(down_thread_sorryserver_disconnect_event_call_check);
1839 // DOWN_FUNC_SORRY_ENABLE_EVENT down_thread_sorry_enable_event function
1840 check_it = up_thread_message_down_thread_function_map.find(DOWN_FUNC_SORRY_ENABLE_EVENT);
1841 BOOST_CHECK(check_it == up_thread_message_down_thread_function_map.end());
1843 // DOWN_FUNC_SORRY_DISABLE_EVENT down_thread_sorry_disable_event function
1844 check_it = up_thread_message_down_thread_function_map.find(DOWN_FUNC_SORRY_DISABLE_EVENT);
1845 BOOST_CHECK(check_it == up_thread_message_down_thread_function_map.end());
1847 // DOWN_FUNC_EXIT down_thread_exit function
1848 check_it = up_thread_message_down_thread_function_map.find(DOWN_FUNC_EXIT);
1849 BOOST_CHECK(check_it == up_thread_message_down_thread_function_map.end());
1852 void check_down_thread_message_up_thread_function_map(){
1853 std::map< UP_THREAD_FUNC_TYPE_TAG, tcp_session_func >::iterator check_it;
1855 // UP_FUNC_CLIENT_ACCEPT up_thread_client_accept_event function
1856 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_CLIENT_ACCEPT);
1857 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1859 // UP_FUNC_CLIENT_DISCONNECT up_thread_client_disconnect function
1860 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_CLIENT_DISCONNECT);
1861 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1863 // UP_FUNC_CLIENT_DISCONNECT_EVENT up_thread_client_disconnect_event function
1864 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_CLIENT_DISCONNECT_EVENT);
1865 BOOST_CHECK(check_it != down_thread_message_up_thread_function_map.end());
1866 up_thread_client_disconnect_event_call_check = false;
1867 check_it->second(LOCAL_PROC);
1868 BOOST_CHECK(up_thread_client_disconnect_event_call_check);
1870 // UP_FUNC_CLIENT_RECEIVE up_thread_client_receive function
1871 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_CLIENT_RECEIVE);
1872 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1874 // UP_FUNC_CLIENT_RESPOND_SEND up_thread_client_respond function
1875 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_CLIENT_RESPOND_SEND);
1876 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1878 // UP_FUNC_CLIENT_RESPOND_SEND_EVENT up_thread_client_respond_event function
1879 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_CLIENT_RESPOND_SEND_EVENT);
1880 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1882 // UP_FUNC_REALSERVER_GET_DEST_EVENT up_thread_realserver_get_distination_event function
1883 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_REALSERVER_GET_DEST_EVENT);
1884 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1886 // UP_FUNC_REALSERVER_CONNECT up_thread_realserver_connect function
1887 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_REALSERVER_CONNECT);
1888 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1890 // UP_FUNC_REALSERVER_CONNECT_EVENT _event function
1891 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_REALSERVER_CONNECT_EVENT);
1892 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1894 // UP_FUNC_REALSERVER_CONNECT_FAIL_EVENT up_thread_realserver_connection_fail_event function
1895 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_REALSERVER_CONNECT_FAIL_EVENT);
1896 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1898 // UP_FUNC_REALSERVER_SEND up_thread_realserver_send function
1899 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_REALSERVER_SEND);
1900 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1902 // UP_FUNC_REALSERVER_DISCONNECT up_thread_realserver_disconnect function
1903 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_REALSERVER_DISCONNECT);
1904 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1906 // UP_FUNC_REALSERVER_DISCONNECT_EVENT up_thread_realserver_disconnect_event function
1907 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_REALSERVER_DISCONNECT_EVENT);
1908 BOOST_CHECK(check_it != down_thread_message_up_thread_function_map.end());
1909 up_thread_realserver_disconnect_event_call_check = false;
1910 check_it->second(LOCAL_PROC);
1911 BOOST_CHECK(up_thread_realserver_disconnect_event_call_check);
1913 // UP_FUNC_REALSERVER_ALL_DISCONNECT up_thread_all_realserver_disconnect function
1914 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_REALSERVER_ALL_DISCONNECT);
1915 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1917 // UP_FUNC_SORRYSERVER_GET_DEST up_thread_sorryserver_get_destination_event function
1918 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_SORRYSERVER_GET_DEST);
1919 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1921 // UP_FUNC_SORRYSERVER_CONNECT up_thread_sorryserver_connect function
1922 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_SORRYSERVER_CONNECT);
1923 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1925 // UP_FUNC_SORRYSERVER_CONNECT_EVENT up_thread_sorryserver_connect_event function
1926 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_SORRYSERVER_CONNECT_EVENT);
1927 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1929 // UP_FUNC_SORRYSERVER_CONNECT_FAIL_EVENT up_thread_sorryserver_connection_fail_event function
1930 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_SORRYSERVER_CONNECT_FAIL_EVENT);
1931 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1933 // UP_FUNC_SORRYSERVER_SEND up_thread_sorryserver_send function
1934 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_SORRYSERVER_SEND);
1935 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1937 // UP_FUNC_SORRYSERVER_DISCONNECT up_thread_sorryserver_disconnect function
1938 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_SORRYSERVER_DISCONNECT);
1939 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1941 // UP_FUNC_SORRYSERVER_DISCONNECT_EVENT up_thread_sorryserver_disconnect_event function
1942 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_SORRYSERVER_DISCONNECT_EVENT);
1943 BOOST_CHECK(check_it != down_thread_message_up_thread_function_map.end());
1944 up_thread_sorryserver_disconnect_event_call_check = false;
1945 check_it->second(LOCAL_PROC);
1946 BOOST_CHECK(up_thread_sorryserver_disconnect_event_call_check);
1948 // UP_FUNC_SORRY_ENABLE_EVENT up_thread_sorry_enable_event function
1949 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_SORRY_ENABLE_EVENT);
1950 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1952 // UP_FUNC_SORRY_DISABLE_EVENT up_thread_sorry_disable_event function
1953 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_SORRY_DISABLE_EVENT);
1954 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1956 // UP_FUNC_EXIT up_thread_exit function
1957 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_EXIT);
1958 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1961 void check_virtual_service_message_up_thread_function_map(){
1962 std::map< TCP_VIRTUAL_SERVICE_MESSAGE_TAG, tcp_session_func >::iterator check_it;
1963 // SORRY_STATE_ENABLE up_thread_sorry_enable_event function
1964 check_it = virtual_service_message_up_thread_function_map.find(SORRY_STATE_ENABLE);
1965 BOOST_CHECK(check_it != virtual_service_message_up_thread_function_map.end());
1966 up_thread_sorry_enable_event_call_check = false;
1967 check_it->second(LOCAL_PROC);
1968 BOOST_CHECK(up_thread_sorry_enable_event_call_check);
1970 // SORRY_STATE_DISABLE up_thread_sorry_disable_event function
1971 check_it = virtual_service_message_up_thread_function_map.find(SORRY_STATE_DISABLE);
1972 BOOST_CHECK(check_it != virtual_service_message_up_thread_function_map.end());
1973 up_thread_sorry_disable_event_call_check = false;
1974 check_it->second(LOCAL_PROC);
1975 BOOST_CHECK(up_thread_sorry_disable_event_call_check);
1977 // SESSION_END up_thread_exit function
1978 check_it = virtual_service_message_up_thread_function_map.find(SESSION_END);
1979 BOOST_CHECK(check_it != virtual_service_message_up_thread_function_map.end());
1980 up_thread_exit_call_check = false;
1981 check_it->second(LOCAL_PROC);
1982 BOOST_CHECK(up_thread_exit_call_check);
1984 // SESSION_PAUSE_ON non function
1985 check_it = virtual_service_message_up_thread_function_map.find(SESSION_PAUSE_ON);
1986 BOOST_CHECK(check_it == virtual_service_message_up_thread_function_map.end());
1988 // SESSION_PAUSE_OFF non function
1989 check_it = virtual_service_message_up_thread_function_map.find(SESSION_PAUSE_OFF);
1990 BOOST_CHECK(check_it == virtual_service_message_up_thread_function_map.end());
1993 void check_virtual_service_message_down_thread_function_map(){
1994 std::map< TCP_VIRTUAL_SERVICE_MESSAGE_TAG, tcp_session_func >::iterator check_it;
1995 // SORRY_STATE_ENABLE down_thread_sorry_enable_event function
1996 check_it = virtual_service_message_down_thread_function_map.find(SORRY_STATE_ENABLE);
1997 BOOST_CHECK(check_it != virtual_service_message_down_thread_function_map.end());
1998 down_thread_sorry_enable_event_call_check = false;
1999 check_it->second(LOCAL_PROC);
2000 BOOST_CHECK(down_thread_sorry_enable_event_call_check);
2002 // SORRY_STATE_DISABLE down_thread_sorry_disable_event function
2003 check_it = virtual_service_message_down_thread_function_map.find(SORRY_STATE_DISABLE);
2004 BOOST_CHECK(check_it != virtual_service_message_down_thread_function_map.end());
2005 down_thread_sorry_disable_event_call_check = false;
2006 check_it->second(LOCAL_PROC);
2007 BOOST_CHECK(down_thread_sorry_disable_event_call_check);
2009 // SESSION_END down_thread_exit function
2010 check_it = virtual_service_message_down_thread_function_map.find(SESSION_END);
2011 BOOST_CHECK(check_it != virtual_service_message_down_thread_function_map.end());
2012 down_thread_exit_call_check = false;
2013 check_it->second(LOCAL_PROC);
2014 BOOST_CHECK(down_thread_exit_call_check);
2016 // SESSION_PAUSE_ON non function
2017 check_it = virtual_service_message_down_thread_function_map.find(SESSION_PAUSE_ON);
2018 BOOST_CHECK(check_it == virtual_service_message_down_thread_function_map.end());
2020 // SESSION_PAUSE_OFF non function
2021 check_it = virtual_service_message_down_thread_function_map.find(SESSION_PAUSE_OFF);
2022 BOOST_CHECK(check_it == virtual_service_message_down_thread_function_map.end());
2025 void constructer_test(){
2026 BOOST_MESSAGE( "----- constructer test start -----" );
2028 l7vs::virtualservice_tcp vs;
2029 boost::asio::io_service io;
2030 l7vs::tcp_socket_option_info set_option;
2031 //! TCP_NODELAY (false:not set,true:set option)
2032 set_option.nodelay_opt = true;
2033 //! TCP_NODELAY option value (false:off,true:on)
2034 set_option.nodelay_val = true;
2035 //! TCP_CORK (false:not set,true:set option)
2036 set_option.cork_opt = true;
2037 //! TCP_CORK option value (false:off,true:on)
2038 set_option.cork_val = true;
2039 //! TCP_QUICKACK (false:not set,true:set option)
2040 set_option.quickack_opt = true;
2041 //! TCP_QUICKACK option value (false:off,true:on)
2042 set_option.quickack_val = true;
2044 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
2045 bool set_mode(true);
2046 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
2047 bool set_ssl_cache_flag(true);
2048 int set_ssl_handshake_time_out = 111;
2049 std::string access_log_file_name = "test";
2050 l7vs::logger_implement_access* plogger = new l7vs::logger_implement_access(access_log_file_name);
2052 constructer_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
2054 // unit_test [1] constructer initialize member check
2055 std::cout << "[1] constructer initialize member check" << std::endl;
2056 BOOST_CHECK_EQUAL(&io , &test_obj.get_io());
2057 BOOST_CHECK_EQUAL(&vs,&test_obj.get_parent_service());
2058 BOOST_CHECK(!test_obj.get_exit_flag());
2059 // std::bitset<TCP_SESSION_THREAD_STATE_BIT> ref;
2061 // BOOST_CHECK_EQUAL(ref,test_obj.get_thread_state());
2062 BOOST_CHECK_EQUAL(0, test_obj.get_up_status());
2063 BOOST_CHECK_EQUAL(0, test_obj.get_down_status());
2064 BOOST_CHECK_EQUAL((void*)NULL,test_obj.get_protocol_module());
2065 // BOOST_CHECK(!test_obj.get_session_pause_flag());
2066 BOOST_CHECK_EQUAL(&io , &(test_obj.get_client_socket().get_socket().get_io_service()));
2067 BOOST_CHECK_EQUAL(&io , &(test_obj.get_sorry_socket()->get_socket().get_io_service()));
2068 // unit_test [2] constructer set up_thread_module_event_map check
2069 std::cout << "[2] constructer set up_thread_module_event_map check" << std::endl;
2070 test_obj.check_up_thread_module_event_map();
2071 // unit_test [3] constructer set down_thread_module_event_map check
2072 std::cout << "[3] constructer set down_thread_module_event_map check" << std::endl;
2073 test_obj.check_down_thread_module_event_map();
2074 // unit_test [4] constructer set up_thread_function_map check
2075 std::cout << "[4] constructer set up_thread_function_map check" << std::endl;
2076 test_obj.check_up_thread_function_map();
2077 // unit_test [5] constructer set down_thread_function_map check
2078 std::cout << "[5] constructer set down_thread_function_map check" << std::endl;
2079 test_obj.check_down_thread_function_map();
2080 // unit_test [6] constructer set up_thread_message_down_thread_function_map check
2081 std::cout << "[6] constructer set up_thread_message_down_thread_function_map check" << std::endl;
2082 test_obj.check_up_thread_message_down_thread_function_map();
2083 // unit_test [7] constructer set down_thread_message_up_thread_function_map check
2084 std::cout << "[7] constructer set down_thread_message_up_thread_function_map check" << std::endl;
2085 test_obj.check_down_thread_message_up_thread_function_map();
2086 // unit_test [8] constructer set virtual_service_message_up_thread_function_map check
2087 std::cout << "[8] constructer set virtual_service_message_up_thread_function_map check" << std::endl;
2088 test_obj.check_virtual_service_message_up_thread_function_map();
2089 // unit_test [9] constructer set virtual_service_message_down_thread_function_map check
2090 std::cout << "[9] constructer set virtual_service_message_down_thread_function_map check" << std::endl;
2091 test_obj.check_virtual_service_message_down_thread_function_map();
2093 // unit_test [10] constructer set socket option check
2094 std::cout << "[10] constructer set socket option check" << std::endl;
2096 BOOST_CHECK_EQUAL(test_obj.get_socket_opt_info()->nodelay_opt , set_option.nodelay_opt);
2097 BOOST_CHECK_EQUAL(test_obj.get_socket_opt_info()->nodelay_val , set_option.nodelay_val);
2098 // unit_test [11] constructer set socket option check
2099 std::cout << "[11] constructer set socket option check" << std::endl;
2101 BOOST_CHECK_EQUAL(test_obj.get_socket_opt_info()->cork_opt , set_option.cork_opt);
2102 BOOST_CHECK_EQUAL(test_obj.get_socket_opt_info()->cork_val , set_option.cork_val);
2103 // unit_test [12] constructer set socket option check
2104 std::cout << "[12] constructer set socket option check" << std::endl;
2106 BOOST_CHECK_EQUAL(test_obj.get_socket_opt_info()->quickack_opt , set_option.quickack_opt);
2107 BOOST_CHECK_EQUAL(test_obj.get_socket_opt_info()->quickack_val , set_option.quickack_val);
2109 // unit_test [13] constructer client socket set socket option check
2110 std::cout << "[13] constructer client socket set socket option check" << std::endl;
2112 BOOST_CHECK_EQUAL(test_obj.get_client_socket().opt_info.nodelay_opt , set_option.nodelay_opt);
2113 BOOST_CHECK_EQUAL(test_obj.get_client_socket().opt_info.nodelay_val , set_option.nodelay_val);
2115 BOOST_CHECK_EQUAL(test_obj.get_client_socket().opt_info.cork_opt , set_option.cork_opt);
2116 BOOST_CHECK_EQUAL(test_obj.get_client_socket().opt_info.cork_val , set_option.cork_val);
2118 BOOST_CHECK_EQUAL(test_obj.get_client_socket().opt_info.quickack_opt , set_option.quickack_opt);
2119 BOOST_CHECK_EQUAL(test_obj.get_client_socket().opt_info.quickack_val , set_option.quickack_val);
2121 // unit_test [14] constructer sorry socket set socket option check
2122 std::cout << "[14] constructer sorry socket set socket option check" << std::endl;
2124 BOOST_CHECK_EQUAL(test_obj.get_sorry_socket()->opt_info.nodelay_opt , set_option.nodelay_opt);
2125 BOOST_CHECK_EQUAL(test_obj.get_sorry_socket()->opt_info.nodelay_val , set_option.nodelay_val);
2127 BOOST_CHECK_EQUAL(test_obj.get_sorry_socket()->opt_info.cork_opt , set_option.cork_opt);
2128 BOOST_CHECK_EQUAL(test_obj.get_sorry_socket()->opt_info.cork_val , set_option.cork_val);
2130 BOOST_CHECK_EQUAL(test_obj.get_sorry_socket()->opt_info.quickack_opt , set_option.quickack_opt);
2131 BOOST_CHECK_EQUAL(test_obj.get_sorry_socket()->opt_info.quickack_val , set_option.quickack_val);
2133 // unit_test [15] constructer client ssl socket set socket option check
2134 std::cout << "[15] constructer client ssl socket set socket option check" << std::endl;
2136 BOOST_CHECK_EQUAL(test_obj.get_client_ssl_socket().opt_info.nodelay_opt , set_option.nodelay_opt);
2137 BOOST_CHECK_EQUAL(test_obj.get_client_ssl_socket().opt_info.nodelay_val , set_option.nodelay_val);
2139 BOOST_CHECK_EQUAL(test_obj.get_client_ssl_socket().opt_info.cork_opt , set_option.cork_opt);
2140 BOOST_CHECK_EQUAL(test_obj.get_client_ssl_socket().opt_info.cork_val , set_option.cork_val);
2142 BOOST_CHECK_EQUAL(test_obj.get_client_ssl_socket().opt_info.quickack_opt , set_option.quickack_opt);
2143 BOOST_CHECK_EQUAL(test_obj.get_client_ssl_socket().opt_info.quickack_val , set_option.quickack_val);
2145 // unit_test [16] virtualservice_endpoint initialize check
2146 std::cout << "[16] virtualservice_endpoint initialize check" << std::endl;
2147 BOOST_CHECK_EQUAL(test_obj.get_virtualservice_endpoint() , listen_endpoint);
2149 // unit_test [17] accesslog_flag initialize check
2150 std::cout << "[17] accesslog_flag initialize check" << std::endl;
2151 BOOST_CHECK_EQUAL(test_obj.get_accesslog_flag() , false);
2153 // unit_test [18] access_loger initialize check
2154 std::cout << "[18] access_loger initialize check" << std::endl;
2155 BOOST_CHECK_EQUAL(test_obj.get_access_logger() , plogger);
2157 // unit_test [19] ssl_flag initialize check
2158 std::cout << "[18] ssl_flag initialize check" << std::endl;
2159 BOOST_CHECK_EQUAL(test_obj.get_ssl_flag() , set_mode);
2161 // unit_test [20] ssl_context initialize check
2162 std::cout << "[20] ssl_context initialize check" << std::endl;
2163 BOOST_CHECK_EQUAL(&(test_obj.get_ssl_context()) , &set_context);
2165 // unit_test [21] ssl_cache_flag initialize check
2166 std::cout << "[21] ssl_cache_flag initialize check" << std::endl;
2167 BOOST_CHECK_EQUAL(test_obj.get_ssl_cache_flag() , set_ssl_cache_flag);
2169 // unit_test [22] ssl_handshake_timer_flag initialize check
2170 std::cout << "[21] ssl_handshake_timer_flag initialize check" << std::endl;
2171 BOOST_CHECK_EQUAL(test_obj.get_ssl_handshake_timer_flag() , false);
2173 // unit_test [23] ssl_handshake_time_out initialize check
2174 std::cout << "[23] ssl_handshake_time_out initialize check" << std::endl;
2175 BOOST_CHECK_EQUAL(test_obj.get_ssl_handshake_time_out() , set_ssl_handshake_time_out);
2177 // unit_test [23] ssl_handshake_timeout_flag initialize check
2178 std::cout << "[23] ssl_handshake_timeout_flag initialize check" << std::endl;
2179 BOOST_CHECK_EQUAL(test_obj.get_ssl_handshake_timeout_flag() , false);
2184 BOOST_MESSAGE( "----- constructer test end -----" );
2188 // initialize test class
2189 class initialize_test_class : public l7vs::tcp_session{
2191 initialize_test_class(
2192 l7vs::virtualservice_tcp& vs,
2193 boost::asio::io_service& session_io,
2194 l7vs::tcp_socket_option_info& set_socket_option,
2195 boost::asio::ip::tcp::endpoint listen_endpoint,
2197 boost::asio::ssl::context& set_ssl_context,
2198 bool set_ssl_cache_flag,
2199 int set_ssl_handshake_time_out,
2200 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
2207 set_ssl_handshake_time_out,
2208 set_access_logger){};
2211 ~initialize_test_class(){};
2212 bool& get_exit_flag(){
2213 return (bool&)exit_flag;
2215 boost::thread::id& get_up_thread_id(){
2216 return up_thread_id;
2218 boost::thread::id& get_down_thread_id(){
2219 return down_thread_id;
2222 std::bitset<TCP_SESSION_THREAD_STATE_BIT>& get_thread_state(){
2223 return thread_state;
2226 l7vs::tcp_session::UPTHREAD_STATUS_TAG get_up_status(){
2227 return upthread_status;
2229 l7vs::tcp_session::DOWNTHREAD_STATUS_TAG get_down_status(){
2230 return downthread_status;
2232 void set_up_status(int s){
2235 upthread_status = l7vs::tcp_session::UPTHREAD_SLEEP;
2238 upthread_status = l7vs::tcp_session::UPTHREAD_ALIVE;
2241 upthread_status = l7vs::tcp_session::UPTHREAD_ACTIVE;
2244 upthread_status = l7vs::tcp_session::UPTHREAD_LOCK;
2248 void set_down_status(int s){
2251 downthread_status = l7vs::tcp_session::DOWNTHREAD_SLEEP;
2254 downthread_status = l7vs::tcp_session::DOWNTHREAD_ALIVE;
2257 downthread_status = l7vs::tcp_session::DOWNTHREAD_ACTIVE;
2260 downthread_status = l7vs::tcp_session::DOWNTHREAD_LOCK;
2265 l7vs::protocol_module_base* get_protocol_module(){
2266 return protocol_module;
2269 bool& get_session_pause_flag(){
2270 return session_pause_flag;
2273 l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_up_thread_message_que(){
2274 return up_thread_message_que;
2276 l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_down_thread_message_que(){
2277 return down_thread_message_que;
2280 int get_upstream_buffer_size(){
2281 return upstream_buffer_size;
2284 int get_downstream_buffer_size(){
2285 return downstream_buffer_size;
2289 void initialize_test(){
2290 BOOST_MESSAGE( "----- initialize test start -----" );
2292 l7vs::virtualservice_tcp vs;
2293 boost::asio::io_service io;
2294 l7vs::tcp_socket_option_info set_option;
2295 //! TCP_NODELAY (false:not set,true:set option)
2296 set_option.nodelay_opt = false;
2297 //! TCP_NODELAY option value (false:off,true:on)
2298 set_option.nodelay_val = false;
2299 //! TCP_CORK (false:not set,true:set option)
2300 set_option.cork_opt = false;
2301 //! TCP_CORK option value (false:off,true:on)
2302 set_option.cork_val = false;
2303 //! TCP_QUICKACK (false:not set,true:set option)
2304 set_option.quickack_opt = false;
2305 //! TCP_QUICKACK option value (false:off,true:on)
2306 set_option.quickack_val = false;
2308 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
2309 bool set_mode(false);
2310 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
2311 bool set_ssl_cache_flag(false);
2312 int set_ssl_handshake_time_out = 0;
2313 //std::string access_log_file_name = "test";
2314 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
2316 initialize_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
2319 std::string test_protocol_name("test protocol");
2320 l7vs::test_protocol_module proto_test(test_protocol_name);
2321 vs.get_protocol_module_res = &proto_test;
2323 test_obj.get_exit_flag() = true;
2324 test_obj.get_up_thread_id() = boost::this_thread::get_id();
2325 test_obj.get_down_thread_id() = boost::this_thread::get_id();
2326 // test_obj.get_thread_state().set();
2327 test_obj.set_up_status(1);
2328 test_obj.set_down_status(1);
2329 BOOST_CHECK(test_obj.get_protocol_module() != &proto_test);
2330 // test_obj.get_session_pause_flag() = true;
2331 l7vs::tcp_thread_message* test_msg_up = new l7vs::tcp_thread_message;
2332 l7vs::tcp_thread_message* test_msg_dw = new l7vs::tcp_thread_message;
2333 test_obj.get_up_thread_message_que().push(test_msg_up);
2334 BOOST_CHECK(!test_obj.get_up_thread_message_que().empty());
2335 test_obj.get_down_thread_message_que().push(test_msg_dw);
2336 BOOST_CHECK(!test_obj.get_down_thread_message_que().empty());
2338 l7vs::session_result_message res_msg = test_obj.initialize();
2340 // unit_test [1] initialize exit flag check
2341 std::cout << "[1] initialize exit flag check" << std::endl;
2342 BOOST_CHECK(!test_obj.get_exit_flag());
2344 // unit_test [2] initialize up thread id check
2345 std::cout << "[2] initialize up thread id check" << std::endl;
2346 BOOST_CHECK(test_obj.get_up_thread_id() == boost::thread::id());
2348 // unit_test [3] initialize down thread id check
2349 std::cout << "[3] initialize down thread id check" << std::endl;
2350 BOOST_CHECK(test_obj.get_down_thread_id() == boost::thread::id());
2352 // unit_test [4] initialize thread state check
2353 std::cout << "[4] initialize thread state check" << std::endl;
2354 // BOOST_CHECK(test_obj.get_thread_state().none());
2355 BOOST_CHECK(test_obj.get_up_status() == 0);
2356 BOOST_CHECK(test_obj.get_down_status() == 0);
2358 // unit_test [5] initialize session pause flag check
2359 std::cout << "[5] initialize session pause flag check" << std::endl;
2360 // BOOST_CHECK(!test_obj.get_session_pause_flag());
2362 // unit_test [6] initialize up thread message que check
2363 std::cout << "[6] initialize up thread message que check" << std::endl;
2364 BOOST_CHECK(test_obj.get_up_thread_message_que().empty());
2367 // unit_test [7] initialize down thread message que check
2368 std::cout << "[7] initialize down thread message que check" << std::endl;
2369 BOOST_CHECK(test_obj.get_down_thread_message_que().empty());
2372 // unit_test [8] initialize get protocol module pointer check
2373 std::cout << "[8] initialize get protocol module pointer check" << std::endl;
2374 BOOST_CHECK(test_obj.get_protocol_module() == &proto_test);
2376 // unit_test [9] initialize session_result_message flag check
2377 std::cout << "[9] initialize session_result_message flag check" << std::endl;
2378 BOOST_CHECK(!res_msg.flag);
2380 // unit_test [10] initialize upstream_buffer_size load cf check
2381 std::cout << "[10] initialize upstream_buffer_size load cf check" << std::endl;
2382 BOOST_CHECK_EQUAL(test_obj.get_upstream_buffer_size() , 7777);
2384 // unit_test [11] initialize downstream_buffer_size load cf check
2385 std::cout << "[11] initialize downstream_buffer_size load cf check" << std::endl;
2386 BOOST_CHECK_EQUAL(test_obj.get_downstream_buffer_size() , 8888);
2388 // unit_test [12] initialize protocol_module NULL error check
2389 std::cout << "[12] initialize protocol_module NULL error check" << std::endl;
2390 vs.get_protocol_module_res = NULL;
2391 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
2392 l7vs::Logger::putLogError_id = 0;
2393 res_msg = test_obj.initialize();
2394 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
2395 BOOST_CHECK_EQUAL(5,l7vs::Logger::putLogError_id);
2396 std::cout << l7vs::Logger::putLogError_message << std::endl;
2397 BOOST_CHECK(res_msg.flag);
2398 std::cout << res_msg.message << std::endl;
2400 BOOST_MESSAGE( "----- initialize test end -----" );
2404 // get_client_socket test
2405 // get_client_socket test class
2406 class get_client_socket_test_class : public l7vs::tcp_session{
2408 // get_client_socket_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){};
2409 get_client_socket_test_class(
2410 l7vs::virtualservice_tcp& vs,
2411 boost::asio::io_service& session_io,
2412 l7vs::tcp_socket_option_info& set_socket_option,
2413 boost::asio::ip::tcp::endpoint listen_endpoint,
2415 boost::asio::ssl::context& set_ssl_context,
2416 bool set_ssl_cache_flag,
2417 int set_ssl_handshake_time_out,
2418 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
2425 set_ssl_handshake_time_out,
2426 set_access_logger){};
2430 ~get_client_socket_test_class(){};
2431 l7vs::tcp_socket& get_client_tcp_socket(){
2432 return client_socket;
2434 l7vs::tcp_ssl_socket& get_client_ssl_tcp_socket(){
2435 return client_ssl_socket;
2440 void get_client_socket_test(){
2441 BOOST_MESSAGE( "----- get_client_socket test start -----" );
2445 // boost::asio::io_service io;
2446 // l7vs::virtualservice_tcp vs;
2447 // get_client_socket_test_class test_obj(vs,io);
2448 l7vs::virtualservice_tcp vs;
2449 boost::asio::io_service io;
2450 l7vs::tcp_socket_option_info set_option;
2451 //! TCP_NODELAY (false:not set,true:set option)
2452 set_option.nodelay_opt = false;
2453 //! TCP_NODELAY option value (false:off,true:on)
2454 set_option.nodelay_val = false;
2455 //! TCP_CORK (false:not set,true:set option)
2456 set_option.cork_opt = false;
2457 //! TCP_CORK option value (false:off,true:on)
2458 set_option.cork_val = false;
2459 //! TCP_QUICKACK (false:not set,true:set option)
2460 set_option.quickack_opt = false;
2461 //! TCP_QUICKACK option value (false:off,true:on)
2462 set_option.quickack_val = false;
2464 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
2465 bool set_mode(false);
2466 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
2467 bool set_ssl_cache_flag(false);
2468 int set_ssl_handshake_time_out = 0;
2469 //std::string access_log_file_name = "test";
2470 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
2472 get_client_socket_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
2475 l7vs::tcp_socket& ref_tcp_socket = test_obj.get_client_tcp_socket();
2476 boost::asio::ip::tcp::socket& ref_socket = ref_tcp_socket.my_socket;
2477 boost::asio::ip::tcp::socket& chk_socket = test_obj.get_client_socket();
2479 // unit_test [1] get_client_socket check
2480 std::cout << "[1] get_client_socket check" << std::endl;
2481 BOOST_CHECK_EQUAL(&ref_socket,&chk_socket);
2484 l7vs::tcp_ssl_socket& ref_tcp_ssl_socket = test_obj.get_client_ssl_tcp_socket();
2485 ssl_socket& ref_ssl_socket = ref_tcp_ssl_socket.get_socket();
2486 ssl_socket& chk_ssl_socket = test_obj.get_client_ssl_socket();
2488 // unit_test [2] get_client_ssl_socket check
2489 std::cout << "[2] get_client_ssl_socket check" << std::endl;
2490 BOOST_CHECK_EQUAL(&ref_ssl_socket,&chk_ssl_socket);
2492 BOOST_MESSAGE( "----- get_client_socket test end -----" );
2496 // handle_ssl_handshake_timer test
2497 // handle_ssl_handshake_timer test class
2498 class handle_ssl_handshake_timer_test_class : public l7vs::tcp_session{
2500 // handle_ssl_handshake_timer_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){};
2501 handle_ssl_handshake_timer_test_class(
2502 l7vs::virtualservice_tcp& vs,
2503 boost::asio::io_service& session_io,
2504 l7vs::tcp_socket_option_info& set_socket_option,
2505 boost::asio::ip::tcp::endpoint listen_endpoint,
2507 boost::asio::ssl::context& set_ssl_context,
2508 bool set_ssl_cache_flag,
2509 int set_ssl_handshake_time_out,
2510 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
2517 set_ssl_handshake_time_out,
2518 set_access_logger){};
2520 ~handle_ssl_handshake_timer_test_class(){};
2521 bool& get_ssl_handshake_time_out_flag(){
2522 return ssl_handshake_time_out_flag;
2524 void test_call(const boost::system::error_code& error){
2525 l7vs::tcp_session::handle_ssl_handshake_timer(error);
2528 void handle_ssl_handshake_timer_test(){
2530 BOOST_MESSAGE( "----- handle_ssl_handshake_timer test start -----" );
2532 // boost::asio::io_service io;
2533 // l7vs::virtualservice_tcp vs;
2534 // up_thread_exit_test_class test_obj(vs,io);
2536 l7vs::virtualservice_tcp vs;
2537 boost::asio::io_service io;
2538 l7vs::tcp_socket_option_info set_option;
2539 //! TCP_NODELAY (false:not set,true:set option)
2540 set_option.nodelay_opt = false;
2541 //! TCP_NODELAY option value (false:off,true:on)
2542 set_option.nodelay_val = false;
2543 //! TCP_CORK (false:not set,true:set option)
2544 set_option.cork_opt = false;
2545 //! TCP_CORK option value (false:off,true:on)
2546 set_option.cork_val = false;
2547 //! TCP_QUICKACK (false:not set,true:set option)
2548 set_option.quickack_opt = false;
2549 //! TCP_QUICKACK option value (false:off,true:on)
2550 set_option.quickack_val = false;
2552 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
2553 bool set_mode(false);
2554 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
2555 bool set_ssl_cache_flag(false);
2556 int set_ssl_handshake_time_out = 0;
2557 //std::string access_log_file_name = "test";
2558 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
2560 handle_ssl_handshake_timer_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
2562 // unit_test [1] ssl_handshake_time_out_flag update check
2563 std::cout << "[1] ssl_handshake_time_out_flag update check" << std::endl;
2565 bool& ref_flag = test_obj.get_ssl_handshake_time_out_flag();
2569 boost::system::error_code test_call_ec;
2570 test_obj.test_call(test_call_ec);
2572 BOOST_CHECK(ref_flag);
2574 mutex_lock_test test_lock_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
2576 test_lock_obj.set_handle_ssl_handshake_timer_test();
2578 test_lock_obj.test_thread_wait.lock();
2579 boost::thread::id proc_id = boost::this_thread::get_id();
2580 test_lock_obj.befor_thread_id = proc_id;
2581 test_lock_obj.after_thread_id = proc_id;
2582 test_lock_obj.mutex_lock();
2584 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
2586 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
2587 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
2589 boost::thread::id test_id = test_thread.get_id();
2591 BOOST_CHECK(test_id != proc_id);
2594 test_lock_obj.test_thread_wait.unlock();
2597 // unit_test [2] set_handle_ssl_handshake_timer_test thread block test (mutex lock)
2598 std::cout << "[2] set_handle_ssl_handshake_timer_test thread block test (mutex lock)" << std::endl;
2599 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
2600 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
2602 test_lock_obj.mutex_unlock();
2605 // unit_test [3] set_handle_ssl_handshake_timer_test thread run test (mutex unlock)
2606 std::cout << "[3] set_handle_ssl_handshake_timer_test thread run test (mutex unlock)" << std::endl;
2607 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
2608 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
2610 BOOST_MESSAGE( "----- handle_ssl_handshake_timer test end -----" );
2615 // is_thread_wait test
2616 // is_thread_wait test class
2617 class is_thread_wait_test_class : public l7vs::tcp_session{
2619 // is_thread_wait_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){};
2620 is_thread_wait_test_class(
2621 l7vs::virtualservice_tcp& vs,
2622 boost::asio::io_service& session_io,
2623 l7vs::tcp_socket_option_info& set_socket_option,
2624 boost::asio::ip::tcp::endpoint listen_endpoint,
2626 boost::asio::ssl::context& set_ssl_context,
2627 bool set_ssl_cache_flag,
2628 int set_ssl_handshake_time_out,
2629 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
2636 set_ssl_handshake_time_out,
2637 set_access_logger){};
2642 ~is_thread_wait_test_class(){};
2644 std::bitset<TCP_SESSION_THREAD_STATE_BIT>& get_thread_state(){
2645 return thread_state;
2647 l7vs::tcp_session::UPTHREAD_STATUS_TAG get_up_status(){
2648 return upthread_status;
2650 l7vs::tcp_session::DOWNTHREAD_STATUS_TAG get_down_status(){
2651 return downthread_status;
2654 void is_thread_wait_test(){
2655 BOOST_MESSAGE( "----- is_thread_wait test start -----" );
2657 // boost::asio::io_service io;
2658 // l7vs::virtualservice_tcp vs;
2659 // is_thread_wait_test_class test_obj(vs,io);
2660 l7vs::virtualservice_tcp vs;
2661 boost::asio::io_service io;
2662 l7vs::tcp_socket_option_info set_option;
2663 //! TCP_NODELAY (false:not set,true:set option)
2664 set_option.nodelay_opt = false;
2665 //! TCP_NODELAY option value (false:off,true:on)
2666 set_option.nodelay_val = false;
2667 //! TCP_CORK (false:not set,true:set option)
2668 set_option.cork_opt = false;
2669 //! TCP_CORK option value (false:off,true:on)
2670 set_option.cork_val = false;
2671 //! TCP_QUICKACK (false:not set,true:set option)
2672 set_option.quickack_opt = false;
2673 //! TCP_QUICKACK option value (false:off,true:on)
2674 set_option.quickack_val = false;
2676 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
2677 bool set_mode(false);
2678 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
2679 bool set_ssl_cache_flag(false);
2680 int set_ssl_handshake_time_out = 0;
2681 //std::string access_log_file_name = "test";
2682 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
2684 is_thread_wait_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
2686 std::bitset<TCP_SESSION_THREAD_STATE_BIT>& test_bitset = test_obj.get_thread_state();
2688 test_bitset.reset();
2689 BOOST_CHECK(test_bitset.none());
2690 BOOST_CHECK(!test_obj.is_thread_wait());
2692 // unit_test [1] is_thread_wait return check
2693 std::cout << "[1] is_thread_wait return check" << std::endl;
2696 test_bitset.reset();
2697 BOOST_CHECK(test_bitset.none());
2698 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0001);
2699 BOOST_CHECK(!test_obj.is_thread_wait());
2701 // DOWN_THREAD_ALIVE
2702 test_bitset.reset();
2703 BOOST_CHECK(test_bitset.none());
2704 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0002);
2705 BOOST_CHECK(!test_obj.is_thread_wait());
2708 test_bitset.reset();
2709 BOOST_CHECK(test_bitset.none());
2710 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0004);
2711 BOOST_CHECK(!test_obj.is_thread_wait());
2713 // DOWN_THREAD_ACTIVE
2714 test_bitset.reset();
2715 BOOST_CHECK(test_bitset.none());
2716 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0008);
2717 BOOST_CHECK(!test_obj.is_thread_wait());
2720 test_bitset.reset();
2721 BOOST_CHECK(test_bitset.none());
2722 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0010);
2723 BOOST_CHECK(!test_obj.is_thread_wait());
2726 test_bitset.reset();
2727 BOOST_CHECK(test_bitset.none());
2728 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0020);
2729 BOOST_CHECK(!test_obj.is_thread_wait());
2731 // UP_THREAD_LOCK & DOWN_THREAD_LOCK
2732 test_bitset.reset();
2733 BOOST_CHECK(test_bitset.none());
2734 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0010);
2735 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0020);
2736 BOOST_CHECK(test_obj.is_thread_wait());
2738 // UP_THREAD_ALIVE DOWN_THREAD_ALIVE UP_THREAD_ACTIVE DOWN_THREAD_ACTIVE
2739 test_bitset.reset();
2740 BOOST_CHECK(test_bitset.none());
2741 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0001);
2742 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0002);
2743 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0004);
2744 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0008);
2745 BOOST_CHECK(!test_obj.is_thread_wait());
2747 // UP_THREAD_ALIVE DOWN_THREAD_ALIVE UP_THREAD_ACTIVE DOWN_THREAD_ACTIVE UP_THREAD_LOCK
2748 test_bitset.reset();
2749 BOOST_CHECK(test_bitset.none());
2750 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0001);
2751 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0002);
2752 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0004);
2753 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0008);
2754 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0010);
2755 BOOST_CHECK(!test_obj.is_thread_wait());
2757 // UP_THREAD_ALIVE DOWN_THREAD_ALIVE UP_THREAD_ACTIVE DOWN_THREAD_ACTIVE DOWN_THREAD_LOCK
2758 test_bitset.reset();
2759 BOOST_CHECK(test_bitset.none());
2760 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0001);
2761 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0002);
2762 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0004);
2763 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0008);
2764 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0020);
2765 BOOST_CHECK(!test_obj.is_thread_wait());
2767 // UP_THREAD_ALIVE DOWN_THREAD_ALIVE UP_THREAD_ACTIVE DOWN_THREAD_ACTIVE UP_THREAD_LOCK DOWN_THREAD_LOCK
2768 test_bitset.reset();
2769 BOOST_CHECK(test_bitset.none());
2770 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0001);
2771 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0002);
2772 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0004);
2773 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0008);
2774 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0010);
2775 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0020);
2776 BOOST_CHECK(test_obj.is_thread_wait());
2778 //mutex_lock_test test_lock_obj(vs,io);
2779 mutex_lock_test test_lock_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
2782 test_lock_obj.set_up_thread_exit_test();
2784 test_lock_obj.test_thread_wait.lock();
2785 boost::thread::id proc_id = boost::this_thread::get_id();
2786 test_lock_obj.befor_thread_id = proc_id;
2787 test_lock_obj.after_thread_id = proc_id;
2788 test_lock_obj.mutex_lock();
2790 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
2792 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
2793 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
2795 boost::thread::id test_id = test_thread.get_id();
2797 BOOST_CHECK(test_id != proc_id);
2800 test_lock_obj.test_thread_wait.unlock();
2803 // unit_test [2] is_thread_wait thread block test (mutex lock)
2804 std::cout << "[2] is_thread_wait thread block test (mutex lock)" << std::endl;
2805 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
2806 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
2808 test_lock_obj.mutex_unlock();
2811 // unit_test [3] is_thread_wait thread run test (mutex unlock)
2812 std::cout << "[3] is_thread_wait thread run test (mutex unlock)" << std::endl;
2813 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
2814 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
2816 BOOST_MESSAGE( "----- is_thread_wait test end -----" );
2820 // set_virtual_service_message test
2821 // set_virtual_service_message test class
2822 class set_virtual_service_message_test_class : public l7vs::tcp_session{
2824 // set_virtual_service_message_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){};
2825 set_virtual_service_message_test_class(
2826 l7vs::virtualservice_tcp& vs,
2827 boost::asio::io_service& session_io,
2828 l7vs::tcp_socket_option_info& set_socket_option,
2829 boost::asio::ip::tcp::endpoint listen_endpoint,
2831 boost::asio::ssl::context& set_ssl_context,
2832 bool set_ssl_cache_flag,
2833 int set_ssl_handshake_time_out,
2834 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
2841 set_ssl_handshake_time_out,
2842 set_access_logger){};
2847 ~set_virtual_service_message_test_class(){};
2850 bool& get_session_pause_flag(){
2851 return session_pause_flag;
2855 bool& get_access_log_flag(){
2856 return access_log_flag;
2859 l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_up_thread_message_que(){
2860 return up_thread_message_que;
2863 l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_down_thread_message_que(){
2864 return down_thread_message_que;
2867 std::map< TCP_VIRTUAL_SERVICE_MESSAGE_TAG, tcp_session_func>& get_virtual_service_message_up_thread_function_map(){
2868 return virtual_service_message_up_thread_function_map;
2871 std::map< TCP_VIRTUAL_SERVICE_MESSAGE_TAG, tcp_session_func>& get_virtual_service_message_down_thread_function_map(){
2872 return virtual_service_message_down_thread_function_map;
2875 void up_thread_sorry_enable_event(const TCP_PROCESS_TYPE_TAG process_type){
2876 up_thread_sorry_enable_event_call_check = true;
2878 bool up_thread_sorry_enable_event_call_check;
2880 void up_thread_sorry_disable_event(const TCP_PROCESS_TYPE_TAG process_type){
2881 up_thread_sorry_disable_event_call_check = true;
2883 bool up_thread_sorry_disable_event_call_check;
2885 void up_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
2886 up_thread_exit_call_check = true;
2888 bool up_thread_exit_call_check;
2890 void down_thread_sorry_enable_event(const TCP_PROCESS_TYPE_TAG process_type){
2891 down_thread_sorry_enable_event_call_check = true;
2893 bool down_thread_sorry_enable_event_call_check;
2895 void down_thread_sorry_disable_event(const TCP_PROCESS_TYPE_TAG process_type){
2896 down_thread_sorry_disable_event_call_check = true;
2898 bool down_thread_sorry_disable_event_call_check;
2900 void down_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
2901 down_thread_exit_call_check = true;
2903 bool down_thread_exit_call_check;
2905 void set_virtual_service_message_test(){
2906 BOOST_MESSAGE( "----- set_virtual_service_message test start -----" );
2908 // boost::asio::io_service io;
2909 // l7vs::virtualservice_tcp vs;
2910 // set_virtual_service_message_test_class test_obj(vs,io);
2911 l7vs::virtualservice_tcp vs;
2912 boost::asio::io_service io;
2913 l7vs::tcp_socket_option_info set_option;
2914 //! TCP_NODELAY (false:not set,true:set option)
2915 set_option.nodelay_opt = false;
2916 //! TCP_NODELAY option value (false:off,true:on)
2917 set_option.nodelay_val = false;
2918 //! TCP_CORK (false:not set,true:set option)
2919 set_option.cork_opt = false;
2920 //! TCP_CORK option value (false:off,true:on)
2921 set_option.cork_val = false;
2922 //! TCP_QUICKACK (false:not set,true:set option)
2923 set_option.quickack_opt = false;
2924 //! TCP_QUICKACK option value (false:off,true:on)
2925 set_option.quickack_val = false;
2927 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
2928 bool set_mode(false);
2929 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
2930 bool set_ssl_cache_flag(false);
2931 int set_ssl_handshake_time_out = 0;
2932 //std::string access_log_file_name = "test";
2933 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
2935 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);
2938 // bool& ref_pause_flag = test_obj.get_session_pause_flag();
2939 bool& ref_access_log_flag = test_obj.get_access_log_flag();
2940 l7vs::lockfree_queue<l7vs::tcp_thread_message>& ref_up_msg_que = test_obj.get_up_thread_message_que();
2941 l7vs::lockfree_queue<l7vs::tcp_thread_message>& ref_dw_msg_que = test_obj.get_down_thread_message_que();
2942 l7vs::tcp_thread_message* up_msg;
2943 l7vs::tcp_thread_message* dw_msg;
2944 std::map< l7vs::tcp_session::TCP_VIRTUAL_SERVICE_MESSAGE_TAG, boost::function< void(l7vs::tcp_session::TCP_PROCESS_TYPE_TAG) > >& ref_vs_up_msg_map = test_obj.get_virtual_service_message_up_thread_function_map();
2945 std::map< l7vs::tcp_session::TCP_VIRTUAL_SERVICE_MESSAGE_TAG, boost::function< void(l7vs::tcp_session::TCP_PROCESS_TYPE_TAG) > >& ref_vs_dw_msg_map = test_obj.get_virtual_service_message_down_thread_function_map();
2947 // unit_test [1] set_virtual_service_message SORRY_STATE_ENABLE
2948 std::cout << "[1] set_virtual_service_message SORRY_STATE_ENABLE" << std::endl;
2950 while( !ref_up_msg_que.empty() ){
2951 up_msg = ref_up_msg_que.pop();
2954 BOOST_CHECK(ref_up_msg_que.empty());
2955 while( !ref_dw_msg_que.empty() ){
2956 dw_msg =ref_dw_msg_que.pop();
2959 BOOST_CHECK(ref_dw_msg_que.empty());
2961 test_obj.set_virtual_service_message(l7vs::tcp_session::SORRY_STATE_ENABLE);
2963 BOOST_CHECK(!ref_up_msg_que.empty());
2964 up_msg = ref_up_msg_que.pop();
2965 BOOST_CHECK(ref_up_msg_que.empty());
2966 test_obj.up_thread_sorry_enable_event_call_check = false;
2967 up_msg->message(l7vs::tcp_session::LOCAL_PROC);
2968 BOOST_CHECK(test_obj.up_thread_sorry_enable_event_call_check);
2971 BOOST_CHECK(!ref_dw_msg_que.empty());
2972 dw_msg = ref_dw_msg_que.pop();
2973 BOOST_CHECK(ref_dw_msg_que.empty());
2974 test_obj.down_thread_sorry_enable_event_call_check = false;
2975 dw_msg->message(l7vs::tcp_session::LOCAL_PROC);
2976 BOOST_CHECK(test_obj.down_thread_sorry_enable_event_call_check);
2979 // unit_test [2] set_virtual_service_message SORRY_STATE_DISABLE
2980 std::cout << "[2] set_virtual_service_message SORRY_STATE_DISABLE" << std::endl;
2982 while( !ref_up_msg_que.empty() ){
2983 up_msg = ref_up_msg_que.pop();
2986 BOOST_CHECK(ref_up_msg_que.empty());
2987 while( !ref_dw_msg_que.empty() ){
2988 dw_msg =ref_dw_msg_que.pop();
2991 BOOST_CHECK(ref_dw_msg_que.empty());
2993 test_obj.set_virtual_service_message(l7vs::tcp_session::SORRY_STATE_DISABLE);
2995 BOOST_CHECK(!ref_up_msg_que.empty());
2996 up_msg = ref_up_msg_que.pop();
2997 BOOST_CHECK(ref_up_msg_que.empty());
2998 test_obj.up_thread_sorry_disable_event_call_check = false;
2999 up_msg->message(l7vs::tcp_session::LOCAL_PROC);
3000 BOOST_CHECK(test_obj.up_thread_sorry_disable_event_call_check);
3003 BOOST_CHECK(!ref_dw_msg_que.empty());
3004 dw_msg = ref_dw_msg_que.pop();
3005 BOOST_CHECK(ref_dw_msg_que.empty());
3006 test_obj.down_thread_sorry_disable_event_call_check = false;
3007 dw_msg->message(l7vs::tcp_session::LOCAL_PROC);
3008 BOOST_CHECK(test_obj.down_thread_sorry_disable_event_call_check);
3011 // unit_test [3] set_virtual_service_message SESSION_END
3012 std::cout << "[3] set_virtual_service_message SESSION_END" << std::endl;
3014 while( !ref_up_msg_que.empty() ){
3015 up_msg = ref_up_msg_que.pop();
3018 BOOST_CHECK(ref_up_msg_que.empty());
3019 while( !ref_dw_msg_que.empty() ){
3020 dw_msg =ref_dw_msg_que.pop();
3023 BOOST_CHECK(ref_dw_msg_que.empty());
3025 test_obj.set_virtual_service_message(l7vs::tcp_session::SESSION_END);
3027 BOOST_CHECK(!ref_up_msg_que.empty());
3028 up_msg = ref_up_msg_que.pop();
3029 BOOST_CHECK(ref_up_msg_que.empty());
3030 test_obj.up_thread_exit_call_check = false;
3031 up_msg->message(l7vs::tcp_session::LOCAL_PROC);
3032 BOOST_CHECK(test_obj.up_thread_exit_call_check);
3035 BOOST_CHECK(!ref_dw_msg_que.empty());
3036 dw_msg = ref_dw_msg_que.pop();
3037 BOOST_CHECK(ref_dw_msg_que.empty());
3038 test_obj.down_thread_exit_call_check = false;
3039 dw_msg->message(l7vs::tcp_session::LOCAL_PROC);
3040 BOOST_CHECK(test_obj.down_thread_exit_call_check);
3043 // unit_test [4] set_virtual_service_message SESSION_PAUSE_ON
3044 std::cout << "[4] set_virtual_service_message SESSION_PAUSE_ON" << std::endl;
3045 // ref_pause_flag = false;
3046 test_obj.set_virtual_service_message(l7vs::tcp_session::SESSION_PAUSE_ON);
3047 // BOOST_CHECK(ref_pause_flag);
3049 // unit_test [5] set_virtual_service_message SESSION_PAUSE_OFF
3050 std::cout << "[5] set_virtual_service_message SESSION_PAUSE_OFF" << std::endl;
3051 // ref_pause_flag = true;
3052 test_obj.set_virtual_service_message(l7vs::tcp_session::SESSION_PAUSE_OFF);
3053 // BOOST_CHECK(!ref_pause_flag);
3055 // unit_test [6] set_virtual_service_message ACCESS_LOG_ON
3056 std::cout << "[6] set_virtual_service_message ACCESS_LOG__ON" << std::endl;
3057 ref_access_log_flag = false;
3058 test_obj.set_virtual_service_message(l7vs::tcp_session::ACCESS_LOG_ON);
3059 BOOST_CHECK(ref_access_log_flag);
3061 // unit_test [7] set_virtual_service_message ACCESS_LOG_OFF
3062 std::cout << "[7] set_virtual_service_message ACCESS_LOG_OFF" << std::endl;
3063 ref_access_log_flag = true;
3064 test_obj.set_virtual_service_message(l7vs::tcp_session::ACCESS_LOG_OFF);
3065 BOOST_CHECK(!ref_access_log_flag);
3067 // unit_test [8] set_virtual_service_message up thread map find not message error
3068 std::cout << "[8] set_virtual_service_message up thread map find not message error" << std::endl;
3069 ref_vs_up_msg_map.clear();
3070 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
3071 l7vs::Logger::putLogError_id = 0;
3072 while( !ref_up_msg_que.empty() ){
3073 up_msg = ref_up_msg_que.pop();
3076 BOOST_CHECK(ref_up_msg_que.empty());
3077 while( !ref_dw_msg_que.empty() ){
3078 dw_msg =ref_dw_msg_que.pop();
3081 BOOST_CHECK(ref_dw_msg_que.empty());
3083 test_obj.set_virtual_service_message(l7vs::tcp_session::SORRY_STATE_ENABLE);
3085 BOOST_CHECK(ref_up_msg_que.empty());
3086 BOOST_CHECK(!ref_dw_msg_que.empty());
3088 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
3089 BOOST_CHECK_EQUAL(6,l7vs::Logger::putLogError_id);
3090 std::cout << l7vs::Logger::putLogError_message << std::endl;
3092 // unit_test [9] set_virtual_service_message up thread map find not message error
3093 std::cout << "[9] set_virtual_service_message up thread map find not message error" << std::endl;
3094 ref_vs_dw_msg_map.clear();
3095 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
3096 l7vs::Logger::putLogError_id = 0;
3097 ref_vs_dw_msg_map.clear();
3098 BOOST_CHECK(ref_up_msg_que.empty());
3099 while( !ref_dw_msg_que.empty() ){
3100 dw_msg =ref_dw_msg_que.pop();
3103 BOOST_CHECK(ref_dw_msg_que.empty());
3105 test_obj.set_virtual_service_message(l7vs::tcp_session::SORRY_STATE_ENABLE);
3107 BOOST_CHECK(ref_up_msg_que.empty());
3108 BOOST_CHECK(ref_dw_msg_que.empty());
3110 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
3111 BOOST_CHECK_EQUAL(7,l7vs::Logger::putLogError_id);
3112 std::cout << l7vs::Logger::putLogError_message << std::endl;
3114 BOOST_MESSAGE( "----- set_virtual_service_message test end -----" );
3118 // up_thread_run test class
3119 class up_thread_run_test_class : public l7vs::tcp_session{
3121 // up_thread_run_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){
3122 up_thread_run_test_class(
3123 l7vs::virtualservice_tcp& vs,
3124 boost::asio::io_service& session_io,
3125 l7vs::tcp_socket_option_info& set_socket_option,
3126 boost::asio::ip::tcp::endpoint listen_endpoint,
3128 boost::asio::ssl::context& set_ssl_context,
3129 bool set_ssl_cache_flag,
3130 int set_ssl_handshake_time_out,
3131 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
3138 set_ssl_handshake_time_out,
3143 ~up_thread_run_test_class(){};
3144 bool& get_exit_flag(){
3145 return (bool&)exit_flag;
3149 bool& get_session_pause_flag(){
3150 return session_pause_flag;
3155 std::bitset<TCP_SESSION_THREAD_STATE_BIT>& get_thread_state(){
3156 return thread_state;
3159 l7vs::tcp_session::UPTHREAD_STATUS_TAG& get_up_status(){
3160 return upthread_status;
3162 l7vs::tcp_session::DOWNTHREAD_STATUS_TAG& get_down_status(){
3163 return downthread_status;
3165 void set_up_status(int s){
3168 upthread_status = l7vs::tcp_session::UPTHREAD_SLEEP;
3171 upthread_status = l7vs::tcp_session::UPTHREAD_ALIVE;
3174 upthread_status = l7vs::tcp_session::UPTHREAD_ACTIVE;
3177 upthread_status = l7vs::tcp_session::UPTHREAD_LOCK;
3181 void set_down_status(int s){
3184 downthread_status = l7vs::tcp_session::DOWNTHREAD_SLEEP;
3187 downthread_status = l7vs::tcp_session::DOWNTHREAD_ALIVE;
3190 downthread_status = l7vs::tcp_session::DOWNTHREAD_ACTIVE;
3193 downthread_status = l7vs::tcp_session::DOWNTHREAD_LOCK;
3198 boost::mutex test_thread_wait;
3200 boost::mutex::scoped_lock scope_lock(test_thread_wait);
3202 std::cout << "up_thread_run test call" << std::endl;
3211 void set_protocol_module(l7vs::protocol_module_base* set_proto){
3212 protocol_module = set_proto;
3215 l7vs::tcp_socket& get_client_socket(){
3216 return client_socket;
3219 boost::thread::id& get_up_thread_id(){
3220 return up_thread_id;
3223 boost::thread::id& get_down_thread_id(){
3224 return down_thread_id;
3227 void up_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
3228 up_thread_exit_process_type = process_type;
3229 l7vs::tcp_session::up_thread_exit(process_type);
3230 up_thread_exit_call_check = true;
3232 TCP_PROCESS_TYPE_TAG up_thread_exit_process_type;
3233 bool up_thread_exit_call_check;
3235 void up_thread_all_socket_close(void){
3236 up_thread_all_socket_close_call_check = true;
3238 bool up_thread_all_socket_close_call_check;
3240 void test_message_set(boost::asio::ip::tcp::endpoint set_endpoint){
3241 l7vs::tcp_thread_message* chk_msg = new l7vs::tcp_thread_message;
3242 up_thread_message_que.push(chk_msg);
3243 chk_msg->endpoint_info = set_endpoint;
3244 up_thread_function_pair func = up_thread_function_array[UP_FUNC_EXIT];
3245 chk_msg->message = func.second;
3248 l7vs::tcp_data& get_up_thread_message_data(){
3249 return up_thread_message_data;
3252 void clear_function_array(){
3253 for(int i = 0;i <= UP_FUNC_EXIT;i++){
3254 up_thread_function_array[i].second = NULL;
3257 void clear_event_map(){
3258 up_thread_module_event_map.clear();
3261 void set_up_thread_next_call_function_client_disconnect(){
3262 up_thread_next_call_function = up_thread_function_array[UP_FUNC_CLIENT_DISCONNECT];
3264 void set_up_thread_next_call_function_exit(){
3265 up_thread_next_call_function = up_thread_function_array[UP_FUNC_EXIT];
3269 void up_thread_run_test(){
3271 BOOST_MESSAGE( "----- up_thread_run test start -----" );
3273 boost::asio::io_service io;
3274 l7vs::virtualservice_tcp vs;
3275 l7vs::tcp_socket_option_info set_option;
3276 //! TCP_NODELAY (false:not set,true:set option)
3277 set_option.nodelay_opt = false;
3278 //! TCP_NODELAY option value (false:off,true:on)
3279 set_option.nodelay_val = false;
3280 //! TCP_CORK (false:not set,true:set option)
3281 set_option.cork_opt = false;
3282 //! TCP_CORK option value (false:off,true:on)
3283 set_option.cork_val = false;
3284 //! TCP_QUICKACK (false:not set,true:set option)
3285 set_option.quickack_opt = false;
3286 //! TCP_QUICKACK option value (false:off,true:on)
3287 set_option.quickack_val = false;
3289 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
3290 bool set_mode(false);
3291 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
3292 bool set_ssl_cache_flag(false);
3293 int set_ssl_handshake_time_out = 0;
3294 //std::string access_log_file_name = "test";
3295 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
3297 boost::system::error_code ec;
3299 std::string test_protocol_name("test protocol");
3300 l7vs::test_protocol_module proto_test(test_protocol_name);
3302 up_thread_run_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
3304 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
3305 bool& exit_flag = test_obj.get_exit_flag();
3306 // bool& session_pause_flag = test_obj.get_session_pause_flag();
3307 boost::thread::id& up_thread_id = test_obj.get_up_thread_id();
3308 boost::thread::id& down_thread_id = test_obj.get_down_thread_id();
3311 // std::bitset<TCP_SESSION_THREAD_STATE_BIT>& thread_state = test_obj.get_thread_state();
3312 l7vs::tcp_socket& client_socket = test_obj.get_client_socket();
3314 test_mirror_server test_server;
3316 test_server.breq_acc_flag = true;
3318 test_server.breq_close_wait_flag = true;
3320 test_server.req_recv_cnt = 0;
3321 // test server start
3322 boost::thread server_thread(boost::bind(&test_mirror_server::run,&test_server));
3323 while( !test_server.brun_flag ){
3327 boost::asio::ip::tcp::endpoint connect_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
3328 client_socket.get_socket().connect(connect_end,ec);
3330 while(!test_server.bconnect_flag){
3334 test_obj.test_thread_wait.lock();
3336 thread_state[0] = 0; // UP_THREAD_ALIVE
3337 thread_state[1] = 0; // DOWN_THREAD_ALIVE
3338 thread_state[2] = 0; // UP_THREAD_ACTIVE
3339 thread_state[3] = 0; // DOWN_THREAD_ACTIVE
3340 thread_state[4] = 0; // UP_THREAD_LOCK
3341 thread_state[5] = 0; // DOWN_THREAD_LOCK
3343 up_thread_id = boost::thread::id();
3344 boost::thread test_thread(boost::bind(&up_thread_run_test_class::test_run,&test_obj));
3346 boost::thread::id test_id = test_thread.get_id();
3347 boost::thread::id proc_id = boost::this_thread::get_id();
3350 BOOST_CHECK(!thread_state.test(0)); // UP_THREAD_ALIVE
3351 BOOST_CHECK(!thread_state.test(1)); // DOWN_THREAD_ALIVE
3352 BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
3353 BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
3354 BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
3355 BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
3357 BOOST_CHECK(test_obj.get_up_status() == 0);
3358 BOOST_CHECK(test_obj.get_down_status() == 0);
3359 BOOST_CHECK(up_thread_id != test_id);
3360 test_obj.test_thread_wait.unlock();
3363 // unit_test [1] up_thread_run thread id update check
3364 std::cout << "[1] up_thread_run thread id update check" << std::endl;
3365 BOOST_CHECK(up_thread_id == test_id);
3367 // unit_test [2] up_thread_run down thread wait check
3368 std::cout << "[2] up_thread_run down thread wait check" << std::endl;
3370 BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
3371 BOOST_CHECK(!thread_state.test(1)); // DOWN_THREAD_ALIVE
3372 BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
3373 BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
3374 BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
3375 BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
3377 BOOST_CHECK(test_obj.get_up_status() == 1);
3378 BOOST_CHECK(test_obj.get_down_status() == 0);
3380 proto_test.handle_session_initialize_res_tag = l7vs::protocol_module_base::FINALIZE;
3381 proto_test.handle_session_initialize_in_up_thread_id = boost::thread::id();
3382 proto_test.handle_session_initialize_in_down_thread_id = boost::thread::id();
3383 proto_test.handle_session_initialize_in_client_endpoint_tcp = boost::asio::ip::tcp::endpoint();
3384 proto_test.handle_session_initialize_in_client_endpoint_udp.address(boost::asio::ip::address::from_string("255.255.255.255"));
3385 proto_test.handle_session_initialize_in_client_endpoint_udp.port(65535);
3386 BOOST_CHECK(proto_test.handle_session_initialize_in_up_thread_id != test_id);
3387 BOOST_CHECK(proto_test.handle_session_initialize_in_down_thread_id != proc_id);
3388 BOOST_CHECK(proto_test.handle_session_initialize_in_client_endpoint_tcp != connect_end);
3389 BOOST_CHECK(proto_test.handle_session_initialize_in_client_endpoint_udp != boost::asio::ip::udp::endpoint());
3390 down_thread_id = proc_id;
3391 // session_pause_flag = true;
3393 // DOWN_THREAD_ALIVE
3394 // thread_state[1] = 1;
3395 test_obj.set_down_status(1);
3398 // unit_test [3] up_thread_run handle_session_initialize call check
3399 std::cout << "[3] up_thread_run handle_session_initialize call check" << std::endl;
3400 BOOST_CHECK(proto_test.handle_session_initialize_in_up_thread_id == test_id);
3401 BOOST_CHECK(proto_test.handle_session_initialize_in_down_thread_id == proc_id);
3402 BOOST_CHECK(proto_test.handle_session_initialize_in_client_endpoint_tcp == connect_end);
3403 BOOST_CHECK(proto_test.handle_session_initialize_in_client_endpoint_udp == boost::asio::ip::udp::endpoint());
3405 // unit_test [4] up_thread_run state update(UP_THREAD_ACTIVE) check
3406 std::cout << "[4] up_thread_run state update(UP_THREAD_ACTIVE) check" << std::endl;
3407 // BOOST_CHECK(thread_state.test(2)); // UP_THREAD_ACTIVE
3408 BOOST_CHECK(test_obj.get_up_status() == 2); // UP_THREAD_ACTIVE
3410 // unit_test [5] up_thread_run pause check
3411 std::cout << "[5] up_thread_run pause check" << std::endl;
3412 // BOOST_CHECK(thread_state.test(4)); // UP_THREAD_LOCK
3414 test_obj.up_thread_exit_process_type = l7vs::tcp_session::MESSAGE_PROC;
3415 test_obj.up_thread_exit_call_check = false;
3416 test_obj.up_thread_all_socket_close_call_check = false;
3418 // session_pause_flag = false;
3421 // unit_test [6] up_thread_run restart check
3422 std::cout << "[6] up_thread_run restart check" << std::endl;
3423 // BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
3425 // unit_test [7] up_thread_run up_thread_next_call_function call (up_thread_exit) check
3426 std::cout << "[7] up_thread_run up_thread_next_call_function call (up_thread_exit) check" << std::endl;
3427 BOOST_CHECK(test_obj.up_thread_exit_call_check);
3428 BOOST_CHECK(test_obj.up_thread_exit_process_type == l7vs::tcp_session::LOCAL_PROC);
3430 // unit_test [8] up_thread_run main loop exit check
3431 std::cout << "[8] up_thread_run main loop exit check" << std::endl;
3432 BOOST_CHECK(exit_flag);
3433 // BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
3436 // unit_test [9] up_thread_run up_thread_all_socket_close_call_check call check
3437 std::cout << "[9] up_thread_run up_thread_all_socket_close_call_check call check" << std::endl;
3438 BOOST_CHECK(test_obj.up_thread_all_socket_close_call_check);
3440 // unit_test [10] up_thread_run down thread end wait check
3441 std::cout << "[10] up_thread_run down thread wait check" << std::endl;
3443 BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
3444 BOOST_CHECK(thread_state.test(1)); // DOWN_THREAD_ALIVE
3445 BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
3446 BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
3447 BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
3448 BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
3451 BOOST_CHECK(test_obj.get_up_status() == 1); // UP_THREAD_ALIVE
3452 BOOST_CHECK(test_obj.get_down_status() == 1); // DOWN_THREAD_ALIVE
3454 // proto_test.handle_session_finalize_in_up_thread_id = boost::thread::id();
3455 // proto_test.handle_session_finalize_in_down_thread_id = boost::thread::id();
3456 // BOOST_CHECK(proto_test.handle_session_finalize_in_up_thread_id != test_id);
3457 // BOOST_CHECK(proto_test.handle_session_finalize_in_down_thread_id != proc_id);
3458 // vs.release_session_ptr = NULL;
3459 // BOOST_CHECK(vs.release_session_ptr != test_id);
3461 // thread_state[1] = 0;
3464 // unit_test [11] up_thread_run handle_session_finalize call check
3465 std::cout << "[11] up_thread_run handle_session_finalize call check" << std::endl;
3466 BOOST_CHECK(proto_test.handle_session_finalize_in_up_thread_id == test_id);
3467 BOOST_CHECK(proto_test.handle_session_finalize_in_down_thread_id == proc_id);
3469 // unit_test [12] up_thread_run release_session_id call check
3470 std::cout << "[12] up_thread_run release_session_id call check" << std::endl;
3471 // BOOST_CHECK(vs.release_session_id == test_id);
3473 // unit_test [13] up_thread_run state update(UP_THREAD_ACTIVE) check
3474 std::cout << "[13] up_thread_run state update(UP_THREAD_ACTIVE) check" << std::endl;
3475 // BOOST_CHECK(!thread_state.test(0)); // UP_THREAD_ACTIVE
3477 // message call test
3479 // session_pause_flag = false;
3480 l7vs::tcp_data& msg_data = test_obj.get_up_thread_message_data();
3481 test_obj.test_message_set(connect_end);
3483 thread_state[0] = 0; // UP_THREAD_ALIVE
3484 thread_state[1] = 1; // DOWN_THREAD_ALIVE
3485 thread_state[2] = 0; // UP_THREAD_ACTIVE
3486 thread_state[3] = 0; // DOWN_THREAD_ACTIVE
3487 thread_state[4] = 0; // UP_THREAD_LOCK
3488 thread_state[5] = 0; // DOWN_THREAD_LOCK
3490 msg_data.set_endpoint(boost::asio::ip::tcp::endpoint());
3491 test_obj.up_thread_exit_call_check = false;
3492 test_obj.up_thread_exit_process_type = l7vs::tcp_session::LOCAL_PROC;
3493 proto_test.handle_session_initialize_res_tag = l7vs::protocol_module_base::CLIENT_DISCONNECT;
3495 // test thread start
3496 test_obj.test_wait = false;
3499 BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
3500 BOOST_CHECK(thread_state.test(1)); // DOWN_THREAD_ALIVE
3501 BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
3502 BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
3503 BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
3504 BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
3507 // unit_test [14] up_thread_run message call check
3508 std::cout << "[14] up_thread_run message call check" << std::endl;
3509 BOOST_CHECK(test_obj.up_thread_exit_call_check);
3510 BOOST_CHECK(test_obj.up_thread_exit_process_type == l7vs::tcp_session::MESSAGE_PROC);
3512 proto_test.handle_session_initialize_res_tag = l7vs::protocol_module_base::FINALIZE;
3513 // thread_state[1] = 0;
3516 // error test not find function map
3517 test_obj.clear_function_array();
3519 // session_pause_flag = false;
3520 // thread_state[1] = 1;
3522 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
3523 l7vs::Logger::putLogError_id = 0;
3525 test_obj.test_wait = false;
3528 // unit_test [15] up_thread_run not find function map error test
3529 std::cout << "[15] up_thread_run not find function map error test" << std::endl;
3530 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
3531 BOOST_CHECK_EQUAL(15,l7vs::Logger::putLogError_id);
3532 std::cout << l7vs::Logger::putLogError_message << std::endl;
3534 // thread_state[1] = 0;
3537 //error test protocol_module returnd illegal EVENT_TAG
3538 test_obj.clear_event_map();
3540 // session_pause_flag = false;
3541 // thread_state[1] = 1;
3543 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
3544 l7vs::Logger::putLogError_id = 0;
3546 test_obj.test_wait = false;
3549 // unit_test [16] up_thread_run protocol_module returnd illegal EVENT_TAG error test
3550 std::cout << "[16] up_thread_run protocol_module returnd illegal EVENT_TAG error test" << std::endl;
3551 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
3552 BOOST_CHECK_EQUAL(14,l7vs::Logger::putLogError_id);
3553 std::cout << l7vs::Logger::putLogError_message << std::endl;
3555 // thread_state[1] = 0;
3559 // unit_test [17] up_thread_run set non blocking fail check
3560 std::cout << "[17] up_thread_run set non blocking fail check" << std::endl;
3562 // session_pause_flag = false;
3563 // thread_state[1] = 1;
3565 l7vs::tcp_socket::set_non_blocking_mode_res = false;
3566 l7vs::tcp_socket::set_non_blocking_mode_ec = boost::asio::error::bad_descriptor;
3567 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
3568 l7vs::Logger::putLogError_id = 0;
3570 test_obj.test_wait = false;
3573 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
3574 BOOST_CHECK_EQUAL(11,l7vs::Logger::putLogError_id);
3575 std::cout << l7vs::Logger::putLogError_message << std::endl;
3576 l7vs::tcp_socket::set_non_blocking_mode_res = true;
3577 l7vs::tcp_socket::set_non_blocking_mode_ec.clear();
3579 // thread_state[1] = 0;
3582 //error test client endpoint get error
3583 client_socket.get_socket().close(ec);
3585 // session_pause_flag = false;
3586 // thread_state[1] = 1;
3588 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
3589 l7vs::Logger::putLogError_id = 0;
3591 test_obj.test_wait = false;
3594 // unit_test [18] up_thread_run client endpoint get error test
3595 std::cout << "[18] up_thread_run client endpoint get error test" << std::endl;
3596 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
3597 BOOST_CHECK_EQUAL(9,l7vs::Logger::putLogError_id);
3598 std::cout << l7vs::Logger::putLogError_message << std::endl;
3600 // thread_state[1] = 0;
3603 //error test protocol module null error
3604 test_obj.set_protocol_module(NULL);
3606 // session_pause_flag = false;
3607 // thread_state[1] = 1;
3609 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
3610 l7vs::Logger::putLogError_id = 0;
3612 test_obj.test_wait = false;
3615 // unit_test [19] up_thread_run protocol module null error test
3616 std::cout << "[19] up_thread_run protocol module null error test" << std::endl;
3617 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
3618 BOOST_CHECK_EQUAL(8,l7vs::Logger::putLogError_id);
3619 std::cout << l7vs::Logger::putLogError_message << std::endl;
3621 // thread_state[1] = 0;
3624 test_obj.test_end = true;
3625 test_obj.test_wait = false;
3626 std::cout << "test_thread.join wait" << std::endl;
3628 std::cout << "test_thread.join ok" << std::endl;
3631 test_server.breq_close_wait_flag = false;
3632 test_server.bstop_flag = true;
3633 std::cout << "server_thread.join wait" << std::endl;
3634 server_thread.join();
3635 std::cout << "server_thread.join ok" << std::endl;
3638 BOOST_MESSAGE( "----- up_thread_run test end -----" );
3645 // down_thread_run test class
3646 class down_thread_run_test_class : public l7vs::tcp_session{
3648 // down_thread_run_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){
3649 down_thread_run_test_class(
3650 l7vs::virtualservice_tcp& vs,
3651 boost::asio::io_service& session_io,
3652 l7vs::tcp_socket_option_info& set_socket_option,
3653 boost::asio::ip::tcp::endpoint listen_endpoint,
3655 boost::asio::ssl::context& set_ssl_context,
3656 bool set_ssl_cache_flag,
3657 int set_ssl_handshake_time_out,
3658 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
3665 set_ssl_handshake_time_out,
3670 ~down_thread_run_test_class(){};
3671 bool& get_exit_flag(){
3672 return (bool&)exit_flag;
3676 bool& get_session_pause_flag(){
3677 return session_pause_flag;
3682 std::bitset<TCP_SESSION_THREAD_STATE_BIT>& get_thread_state(){
3683 return thread_state;
3687 boost::mutex test_thread_wait;
3689 boost::mutex::scoped_lock scope_lock(test_thread_wait);
3699 void set_protocol_module(l7vs::protocol_module_base* set_proto){
3700 protocol_module = set_proto;
3703 boost::thread::id& get_down_thread_id(){
3704 return down_thread_id;
3707 void down_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
3708 down_thread_exit_process_type = process_type;
3709 l7vs::tcp_session::down_thread_exit(process_type);
3710 down_thread_exit_call_check = true;
3712 TCP_PROCESS_TYPE_TAG down_thread_exit_process_type;
3713 bool down_thread_exit_call_check;
3715 void down_thread_all_socket_close(void){
3716 down_thread_all_socket_close_call_check = true;
3718 bool down_thread_all_socket_close_call_check;
3720 void test_message_set(boost::asio::ip::tcp::endpoint set_endpoint){
3721 l7vs::tcp_thread_message* chk_msg = new l7vs::tcp_thread_message;
3722 down_thread_message_que.push(chk_msg);
3723 chk_msg->endpoint_info = set_endpoint;
3724 down_thread_function_pair func = down_thread_function_array[DOWN_FUNC_EXIT];
3725 chk_msg->message = func.second;
3728 l7vs::tcp_data& get_down_thread_message_data(){
3729 return down_thread_message_data;
3732 void clear_function_array(){
3733 for(int i = 0;i < DOWN_FUNC_EXIT;i++){
3734 down_thread_function_array[i].second = NULL;
3738 void down_thread_realserver_receive(const TCP_PROCESS_TYPE_TAG process_type){
3739 down_thread_realserver_receive_call_check = true;
3740 down_thread_realserver_receive_process_type = process_type;
3743 bool down_thread_realserver_receive_call_check;
3744 TCP_PROCESS_TYPE_TAG down_thread_realserver_receive_process_type;
3746 void set_down_thread_connect_socket_list(){
3747 for(int i = 0 ; i < 1024;i++){
3748 std::pair<boost::asio::ip::tcp::endpoint,tcp_socket_ptr > push_element;
3749 boost::asio::ip::tcp::endpoint set_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), i);
3750 push_element.first = set_end;
3751 down_thread_connect_socket_list.push_back(push_element);
3752 //std::cout << push_element.first << std::endl;
3754 if(down_thread_connect_socket_list.empty()){
3755 std::cout << "down_thread_connect_socket_list.empty!" << std::endl;
3759 bool check_down_thread_receive_realserver_socket_list(){
3761 std::list<socket_element>::iterator cur_it = down_thread_receive_realserver_socket_list.begin();
3762 for(int i = 0 ; i < 1024;i++){
3763 if(cur_it == down_thread_receive_realserver_socket_list.end()){
3764 std::cout << "DEBUG index[";
3766 std::cout << "] not element" << std::endl;
3770 boost::asio::ip::tcp::endpoint set_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), i);
3771 if(cur_it->first != set_end){
3772 int port = (int)cur_it->first.port();
3774 std::cout << "DEBUG index[";
3776 std::cout << "] port[";
3778 std::cout << "]" << std::endl;
3786 void down_thread_run_test(){
3788 BOOST_MESSAGE( "----- down_thread_run test start -----" );
3790 boost::asio::io_service io;
3791 l7vs::virtualservice_tcp vs;
3792 l7vs::tcp_socket_option_info set_option;
3793 //! TCP_NODELAY (false:not set,true:set option)
3794 set_option.nodelay_opt = false;
3795 //! TCP_NODELAY option value (false:off,true:on)
3796 set_option.nodelay_val = false;
3797 //! TCP_CORK (false:not set,true:set option)
3798 set_option.cork_opt = false;
3799 //! TCP_CORK option value (false:off,true:on)
3800 set_option.cork_val = false;
3801 //! TCP_QUICKACK (false:not set,true:set option)
3802 set_option.quickack_opt = false;
3803 //! TCP_QUICKACK option value (false:off,true:on)
3804 set_option.quickack_val = false;
3806 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
3807 bool set_mode(false);
3808 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
3809 bool set_ssl_cache_flag(false);
3810 int set_ssl_handshake_time_out = 0;
3811 //std::string access_log_file_name = "test";
3812 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
3814 boost::system::error_code ec;
3816 std::string test_protocol_name("test protocol");
3817 l7vs::test_protocol_module proto_test(test_protocol_name);
3819 // down_thread_run_test_class test_obj(vs,io);
3820 down_thread_run_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
3822 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
3823 bool& exit_flag = test_obj.get_exit_flag();
3824 // bool& session_pause_flag = test_obj.get_session_pause_flag();
3825 boost::thread::id& down_thread_id = test_obj.get_down_thread_id();
3828 boost::asio::ip::tcp::endpoint connect_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
3829 // std::bitset<TCP_SESSION_THREAD_STATE_BIT>& thread_state = test_obj.get_thread_state();
3831 test_obj.test_thread_wait.lock();
3833 thread_state[0] = 1; // UP_THREAD_ALIVE
3834 thread_state[1] = 0; // DOWN_THREAD_ALIVE
3835 thread_state[2] = 0; // UP_THREAD_ACTIVE
3836 thread_state[3] = 0; // DOWN_THREAD_ACTIVE
3837 thread_state[4] = 0; // UP_THREAD_LOCK
3838 thread_state[5] = 0; // DOWN_THREAD_LOCK
3840 down_thread_id = boost::thread::id();
3841 boost::thread test_thread(boost::bind(&down_thread_run_test_class::test_run,&test_obj));
3843 boost::thread::id test_id = test_thread.get_id();
3844 boost::thread::id proc_id = boost::this_thread::get_id();
3847 BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
3848 BOOST_CHECK(!thread_state.test(1)); // DOWN_THREAD_ALIVE
3849 BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
3850 BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
3851 BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
3852 BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
3854 BOOST_CHECK(down_thread_id != test_id);
3855 test_obj.test_thread_wait.unlock();
3858 // unit_test [1] down_thread_run thread id update check
3859 std::cout << "[1] down_thread_run thread id update check" << std::endl;
3860 BOOST_CHECK(down_thread_id == test_id);
3862 // unit_test [2] down_thread_run up thread active wait check
3863 std::cout << "[2] down_thread_run up thread active wait check" << std::endl;
3865 BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
3866 BOOST_CHECK(thread_state.test(1)); // DOWN_THREAD_ALIVE
3867 BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
3868 BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
3869 BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
3870 BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
3873 // session_pause_flag = true;
3876 // thread_state[2] = 1;
3879 // unit_test [3] down_thread_run state update(DOWN_THREAD_ACTIVE) check
3880 std::cout << "[3] down_thread_run state update(DOWN_THREAD_ACTIVE) check" << std::endl;
3881 // BOOST_CHECK(thread_state.test(3)); // DOWN_THREAD_ACTIVE
3883 // unit_test [4] down_thread_run pause check
3884 std::cout << "[4] down_thread_run pause check" << std::endl;
3885 // BOOST_CHECK(thread_state.test(5)); // DOWN_THREAD_LOCK
3887 test_obj.down_thread_realserver_receive_call_check = false;
3888 test_obj.down_thread_realserver_receive_process_type = l7vs::tcp_session::MESSAGE_PROC;
3889 test_obj.down_thread_all_socket_close_call_check = false;
3891 test_obj.set_down_thread_connect_socket_list();
3893 // session_pause_flag = false;
3896 // unit_test [5] down_thread_run restart check
3897 std::cout << "[5] down_thread_run restart check" << std::endl;
3898 // BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
3901 // unit_test [6] down_thread_run connect realserver set receive list check
3902 std::cout << "[6] down_thread_run connect realserver set receive list check" << std::endl;
3903 BOOST_CHECK(test_obj.check_down_thread_receive_realserver_socket_list());
3905 // unit_test [7] down_thread_run down_thread_next_call_function call (down_thread_realserver_receive) check
3906 std::cout << "[7] down_thread_run down_thread_next_call_function call (down_thread_realserver_receive) check" << std::endl;
3907 BOOST_CHECK(test_obj.down_thread_realserver_receive_call_check);
3908 BOOST_CHECK(test_obj.down_thread_realserver_receive_process_type == l7vs::tcp_session::LOCAL_PROC);
3910 // unit_test [8] down_thread_run main loop exit check
3911 std::cout << "[8] down_thread_run main loop exit check" << std::endl;
3912 BOOST_CHECK(exit_flag);
3913 // BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
3915 // unit_test [9] down_thread_run down_thread_all_socket_close_call_check call check
3916 std::cout << "[9] down_thread_run down_thread_all_socket_close_call_check call check" << std::endl;
3917 BOOST_CHECK(test_obj.down_thread_all_socket_close_call_check);
3919 // unit_test [10] down_thread_run state update(DOWN_THREAD_ACTIVE) check
3920 std::cout << "[10] down_thread_run state update(DOWN_THREAD_ACTIVE) check" << std::endl;
3921 // BOOST_CHECK(!thread_state.test(1)); // DOWN_THREAD_ACTIVE
3923 // message call test
3925 // session_pause_flag = false;
3926 l7vs::tcp_data& msg_data = test_obj.get_down_thread_message_data();
3927 test_obj.test_message_set(connect_end);
3929 thread_state[0] = 1; // UP_THREAD_ALIVE
3930 thread_state[2] = 1; // UP_THREAD_ACTIVE
3932 msg_data.set_endpoint(boost::asio::ip::tcp::endpoint());
3933 test_obj.down_thread_exit_call_check = false;
3934 test_obj.down_thread_exit_process_type = l7vs::tcp_session::LOCAL_PROC;
3936 // test thread start
3937 test_obj.test_wait = false;
3940 // unit_test [11] down_thread_run message call check
3941 std::cout << "[11] down_thread_run message call check" << std::endl;
3942 BOOST_CHECK(test_obj.down_thread_exit_call_check);
3943 BOOST_CHECK(test_obj.down_thread_exit_process_type == l7vs::tcp_session::MESSAGE_PROC);
3945 // error test not find function map
3946 test_obj.clear_function_array();
3948 // session_pause_flag = true;
3950 thread_state[0] = 1; // UP_THREAD_ALIVE
3951 thread_state[2] = 1; // UP_THREAD_ACTIVE
3954 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
3955 l7vs::Logger::putLogError_id = 0;
3957 test_obj.test_wait = false;
3960 // unit_test [12] down_thread_run not find function map error test
3961 std::cout << "[12] down_thread_run not find function map error test" << std::endl;
3962 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
3963 BOOST_CHECK_EQUAL(16,l7vs::Logger::putLogError_id);
3964 std::cout << l7vs::Logger::putLogError_message << std::endl;
3967 test_obj.test_end = true;
3968 test_obj.test_wait = false;
3972 BOOST_MESSAGE( "----- down_thread_run test end -----" );
3978 // thread_state_update test
3979 // thread_state_update test class
3980 class thread_state_update_test_class : public l7vs::tcp_session{
3982 // thread_state_update_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){};
3983 thread_state_update_test_class(
3984 l7vs::virtualservice_tcp& vs,
3985 boost::asio::io_service& session_io,
3986 l7vs::tcp_socket_option_info& set_socket_option,
3987 boost::asio::ip::tcp::endpoint listen_endpoint,
3989 boost::asio::ssl::context& set_ssl_context,
3990 bool set_ssl_cache_flag,
3991 int set_ssl_handshake_time_out,
3992 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
3999 set_ssl_handshake_time_out,
4000 set_access_logger){};
4004 ~thread_state_update_test_class(){};
4005 std::bitset<TCP_SESSION_THREAD_STATE_BIT>& get_thread_state(){
4006 return thread_state;
4009 void test_call(const std::bitset<TCP_SESSION_THREAD_STATE_BIT> thread_flag,const bool regist){
4010 thread_state_update(thread_flag,regist);
4013 void thread_state_update_test(){
4015 BOOST_MESSAGE( "----- thread_state_update test start -----" );
4017 // boost::asio::io_service io;
4018 // l7vs::virtualservice_tcp vs;
4019 // thread_state_update_test_class test_obj(vs,io);
4020 l7vs::virtualservice_tcp vs;
4021 boost::asio::io_service io;
4022 l7vs::tcp_socket_option_info set_option;
4023 //! TCP_NODELAY (false:not set,true:set option)
4024 set_option.nodelay_opt = false;
4025 //! TCP_NODELAY option value (false:off,true:on)
4026 set_option.nodelay_val = false;
4027 //! TCP_CORK (false:not set,true:set option)
4028 set_option.cork_opt = false;
4029 //! TCP_CORK option value (false:off,true:on)
4030 set_option.cork_val = false;
4031 //! TCP_QUICKACK (false:not set,true:set option)
4032 set_option.quickack_opt = false;
4033 //! TCP_QUICKACK option value (false:off,true:on)
4034 set_option.quickack_val = false;
4036 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
4037 bool set_mode(false);
4038 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
4039 bool set_ssl_cache_flag(false);
4040 int set_ssl_handshake_time_out = 0;
4041 //std::string access_log_file_name = "test";
4042 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
4044 thread_state_update_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
4049 std::bitset<TCP_SESSION_THREAD_STATE_BIT>& thread_state = test_obj.get_thread_state();
4051 thread_state[0] = 0; // UP_THREAD_ALIVE
4052 thread_state[1] = 0; // DOWN_THREAD_ALIVE
4053 thread_state[2] = 0; // UP_THREAD_ACTIVE
4054 thread_state[3] = 0; // DOWN_THREAD_ACTIVE
4055 thread_state[4] = 0; // UP_THREAD_LOCK
4056 thread_state[5] = 0; // DOWN_THREAD_LOCK
4057 BOOST_CHECK(!thread_state.test(0)); // UP_THREAD_ALIVE
4058 BOOST_CHECK(!thread_state.test(1)); // DOWN_THREAD_ALIVE
4059 BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
4060 BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
4061 BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
4062 BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
4065 // unit_test [1] thread_state_update set flag test
4066 std::cout << "[1] thread_state_update set flag test" << std::endl;
4067 test_obj.test_call(UP_THREAD_ALIVE,true);
4068 BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
4069 BOOST_CHECK(!thread_state.test(1)); // DOWN_THREAD_ALIVE
4070 BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
4071 BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
4072 BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
4073 BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
4075 test_obj.test_call(DOWN_THREAD_ALIVE,true);
4076 BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
4077 BOOST_CHECK(thread_state.test(1)); // DOWN_THREAD_ALIVE
4078 BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
4079 BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
4080 BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
4081 BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
4083 test_obj.test_call(UP_THREAD_ACTIVE,true);
4084 BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
4085 BOOST_CHECK(thread_state.test(1)); // DOWN_THREAD_ALIVE
4086 BOOST_CHECK(thread_state.test(2)); // UP_THREAD_ACTIVE
4087 BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
4088 BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
4089 BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
4091 test_obj.test_call(DOWN_THREAD_ACTIVE,true);
4092 BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
4093 BOOST_CHECK(thread_state.test(1)); // DOWN_THREAD_ALIVE
4094 BOOST_CHECK(thread_state.test(2)); // UP_THREAD_ACTIVE
4095 BOOST_CHECK(thread_state.test(3)); // DOWN_THREAD_ACTIVE
4096 BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
4097 BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
4099 test_obj.test_call(UP_THREAD_LOCK,true);
4100 BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
4101 BOOST_CHECK(thread_state.test(1)); // DOWN_THREAD_ALIVE
4102 BOOST_CHECK(thread_state.test(2)); // UP_THREAD_ACTIVE
4103 BOOST_CHECK(thread_state.test(3)); // DOWN_THREAD_ACTIVE
4104 BOOST_CHECK(thread_state.test(4)); // UP_THREAD_LOCK
4105 BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
4107 test_obj.test_call(DOWN_THREAD_LOCK,true);
4108 BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
4109 BOOST_CHECK(thread_state.test(1)); // DOWN_THREAD_ALIVE
4110 BOOST_CHECK(thread_state.test(2)); // UP_THREAD_ACTIVE
4111 BOOST_CHECK(thread_state.test(3)); // DOWN_THREAD_ACTIVE
4112 BOOST_CHECK(thread_state.test(4)); // UP_THREAD_LOCK
4113 BOOST_CHECK(thread_state.test(5)); // DOWN_THREAD_LOCK
4115 // unit_test [2] thread_state_update reset flag test
4116 std::cout << "[2] thread_state_update reset flag test" << std::endl;
4117 test_obj.test_call(UP_THREAD_ALIVE,false);
4118 BOOST_CHECK(!thread_state.test(0)); // UP_THREAD_ALIVE
4119 BOOST_CHECK(thread_state.test(1)); // DOWN_THREAD_ALIVE
4120 BOOST_CHECK(thread_state.test(2)); // UP_THREAD_ACTIVE
4121 BOOST_CHECK(thread_state.test(3)); // DOWN_THREAD_ACTIVE
4122 BOOST_CHECK(thread_state.test(4)); // UP_THREAD_LOCK
4123 BOOST_CHECK(thread_state.test(5)); // DOWN_THREAD_LOCK
4125 test_obj.test_call(DOWN_THREAD_ALIVE,false);
4126 BOOST_CHECK(!thread_state.test(0)); // UP_THREAD_ALIVE
4127 BOOST_CHECK(!thread_state.test(1)); // DOWN_THREAD_ALIVE
4128 BOOST_CHECK(thread_state.test(2)); // UP_THREAD_ACTIVE
4129 BOOST_CHECK(thread_state.test(3)); // DOWN_THREAD_ACTIVE
4130 BOOST_CHECK(thread_state.test(4)); // UP_THREAD_LOCK
4131 BOOST_CHECK(thread_state.test(5)); // DOWN_THREAD_LOCK
4133 test_obj.test_call(UP_THREAD_ACTIVE,false);
4134 BOOST_CHECK(!thread_state.test(0)); // UP_THREAD_ALIVE
4135 BOOST_CHECK(!thread_state.test(1)); // DOWN_THREAD_ALIVE
4136 BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
4137 BOOST_CHECK(thread_state.test(3)); // DOWN_THREAD_ACTIVE
4138 BOOST_CHECK(thread_state.test(4)); // UP_THREAD_LOCK
4139 BOOST_CHECK(thread_state.test(5)); // DOWN_THREAD_LOCK
4141 test_obj.test_call(DOWN_THREAD_ACTIVE,false);
4142 BOOST_CHECK(!thread_state.test(0)); // UP_THREAD_ALIVE
4143 BOOST_CHECK(!thread_state.test(1)); // DOWN_THREAD_ALIVE
4144 BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
4145 BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
4146 BOOST_CHECK(thread_state.test(4)); // UP_THREAD_LOCK
4147 BOOST_CHECK(thread_state.test(5)); // DOWN_THREAD_LOCK
4149 test_obj.test_call(UP_THREAD_LOCK,false);
4150 BOOST_CHECK(!thread_state.test(0)); // UP_THREAD_ALIVE
4151 BOOST_CHECK(!thread_state.test(1)); // DOWN_THREAD_ALIVE
4152 BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
4153 BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
4154 BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
4155 BOOST_CHECK(thread_state.test(5)); // DOWN_THREAD_LOCK
4157 test_obj.test_call(DOWN_THREAD_LOCK,false);
4158 BOOST_CHECK(!thread_state.test(0)); // UP_THREAD_ALIVE
4159 BOOST_CHECK(!thread_state.test(1)); // DOWN_THREAD_ALIVE
4160 BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
4161 BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
4162 BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
4163 BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
4165 boost::thread::id proc_id = boost::this_thread::get_id();
4166 // mutex_lock_test test_lock_obj(vs,io);
4167 mutex_lock_test test_lock_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
4169 test_lock_obj.set_thread_state_update_test();
4171 test_lock_obj.test_thread_wait.lock();
4172 test_lock_obj.befor_thread_id = proc_id;
4173 test_lock_obj.after_thread_id = proc_id;
4174 test_lock_obj.mutex_lock();
4176 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
4178 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
4179 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
4181 boost::thread::id test_id = test_thread.get_id();
4182 BOOST_CHECK(test_id != proc_id);
4185 test_lock_obj.test_thread_wait.unlock();
4188 // unit_test [3] thread_state_update thread block test (mutex lock)
4189 std::cout << "[3] thread_state_update thread block test (mutex lock)" << std::endl;
4190 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
4191 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
4193 test_lock_obj.mutex_unlock();
4196 // unit_test [4] thread_state_update thread run test (mutex unlock)
4197 std::cout << "[4] thread_state_update thread run test (mutex unlock)" << std::endl;
4198 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
4199 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
4201 BOOST_MESSAGE( "----- thread_state_update test end -----" );
4207 // up_thread_exit test
4208 // up_thread_exit test class
4209 class up_thread_exit_test_class : public l7vs::tcp_session{
4211 // up_thread_exit_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){};
4212 up_thread_exit_test_class(
4213 l7vs::virtualservice_tcp& vs,
4214 boost::asio::io_service& session_io,
4215 l7vs::tcp_socket_option_info& set_socket_option,
4216 boost::asio::ip::tcp::endpoint listen_endpoint,
4218 boost::asio::ssl::context& set_ssl_context,
4219 bool set_ssl_cache_flag,
4220 int set_ssl_handshake_time_out,
4221 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
4228 set_ssl_handshake_time_out,
4229 set_access_logger){};
4230 ~up_thread_exit_test_class(){};
4231 bool& get_exit_flag(){
4232 return (bool&)exit_flag;
4235 l7vs::tcp_session::up_thread_exit(LOCAL_PROC);
4238 void up_thread_exit_test(){
4240 BOOST_MESSAGE( "----- up_thread_exit test start -----" );
4242 // boost::asio::io_service io;
4243 // l7vs::virtualservice_tcp vs;
4244 // up_thread_exit_test_class test_obj(vs,io);
4245 l7vs::virtualservice_tcp vs;
4246 boost::asio::io_service io;
4247 l7vs::tcp_socket_option_info set_option;
4248 //! TCP_NODELAY (false:not set,true:set option)
4249 set_option.nodelay_opt = false;
4250 //! TCP_NODELAY option value (false:off,true:on)
4251 set_option.nodelay_val = false;
4252 //! TCP_CORK (false:not set,true:set option)
4253 set_option.cork_opt = false;
4254 //! TCP_CORK option value (false:off,true:on)
4255 set_option.cork_val = false;
4256 //! TCP_QUICKACK (false:not set,true:set option)
4257 set_option.quickack_opt = false;
4258 //! TCP_QUICKACK option value (false:off,true:on)
4259 set_option.quickack_val = false;
4261 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
4262 bool set_mode(false);
4263 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
4264 bool set_ssl_cache_flag(false);
4265 int set_ssl_handshake_time_out = 0;
4266 //std::string access_log_file_name = "test";
4267 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
4269 up_thread_exit_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
4271 // unit_test [1] up_thread_exit update exit_flag
4272 std::cout << "[1] up_thread_exit update exit_flag" << std::endl;
4275 bool& ref_exit_flag = test_obj.get_exit_flag();
4277 ref_exit_flag = false;
4279 test_obj.test_call();
4281 BOOST_CHECK(ref_exit_flag);
4284 // mutex_lock_test test_lock_obj(vs,io);
4285 mutex_lock_test test_lock_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
4287 test_lock_obj.set_up_thread_exit_test();
4290 test_lock_obj.test_thread_wait.lock();
4291 boost::thread::id proc_id = boost::this_thread::get_id();
4292 test_lock_obj.befor_thread_id = proc_id;
4293 test_lock_obj.after_thread_id = proc_id;
4294 test_lock_obj.mutex_lock();
4296 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
4298 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
4299 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
4301 boost::thread::id test_id = test_thread.get_id();
4303 BOOST_CHECK(test_id != proc_id);
4306 test_lock_obj.test_thread_wait.unlock();
4309 // unit_test [2] up_thread_exit thread block test (mutex lock)
4310 std::cout << "[2] up_thread_exit thread block test (mutex lock)" << std::endl;
4311 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
4312 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
4314 test_lock_obj.mutex_unlock();
4317 // unit_test [3] up_thread_exit thread run test (mutex unlock)
4318 std::cout << "[3] up_thread_exit thread run test (mutex unlock)" << std::endl;
4319 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
4320 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
4323 // // unit_test [4] up_thread_exit thread run after mutex unlock test
4324 // std::cout << "[4] up_thread_exit thread run after mutex unlock test" << std::endl;
4325 // BOOST_CHECK(test_lock_obj.mutex_trylock());
4326 // test_lock_obj.mutex_unlock();
4328 BOOST_MESSAGE( "----- up_thread_exit test end -----" );
4331 // down_thread_exit test
4332 // down_thread_exit test class
4333 class down_thread_exit_test_class : public l7vs::tcp_session{
4335 // down_thread_exit_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){};
4336 down_thread_exit_test_class(
4337 l7vs::virtualservice_tcp& vs,
4338 boost::asio::io_service& session_io,
4339 l7vs::tcp_socket_option_info& set_socket_option,
4340 boost::asio::ip::tcp::endpoint listen_endpoint,
4342 boost::asio::ssl::context& set_ssl_context,
4343 bool set_ssl_cache_flag,
4344 int set_ssl_handshake_time_out,
4345 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
4352 set_ssl_handshake_time_out,
4353 set_access_logger){};
4355 ~down_thread_exit_test_class(){};
4356 bool& get_exit_flag(){
4357 return (bool&)exit_flag;
4360 l7vs::tcp_session::down_thread_exit(LOCAL_PROC);
4363 void down_thread_exit_test(){
4365 BOOST_MESSAGE( "----- down_thread_exit test start -----" );
4367 // boost::asio::io_service io;
4368 // l7vs::virtualservice_tcp vs;
4369 // down_thread_exit_test_class test_obj(vs,io);
4370 l7vs::virtualservice_tcp vs;
4371 boost::asio::io_service io;
4372 l7vs::tcp_socket_option_info set_option;
4373 //! TCP_NODELAY (false:not set,true:set option)
4374 set_option.nodelay_opt = false;
4375 //! TCP_NODELAY option value (false:off,true:on)
4376 set_option.nodelay_val = false;
4377 //! TCP_CORK (false:not set,true:set option)
4378 set_option.cork_opt = false;
4379 //! TCP_CORK option value (false:off,true:on)
4380 set_option.cork_val = false;
4381 //! TCP_QUICKACK (false:not set,true:set option)
4382 set_option.quickack_opt = false;
4383 //! TCP_QUICKACK option value (false:off,true:on)
4384 set_option.quickack_val = false;
4386 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
4387 bool set_mode(false);
4388 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
4389 bool set_ssl_cache_flag(false);
4390 int set_ssl_handshake_time_out = 0;
4391 //std::string access_log_file_name = "test";
4392 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
4394 down_thread_exit_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
4396 // unit_test [1] down_thread_exit update exit_flag
4397 std::cout << "[1] down_thread_exit update exit_flag" << std::endl;
4400 bool& ref_exit_flag = test_obj.get_exit_flag();
4402 ref_exit_flag = false;
4404 test_obj.test_call();
4406 BOOST_CHECK(ref_exit_flag);
4409 // mutex_lock_test test_lock_obj(vs,io);
4410 mutex_lock_test test_lock_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
4411 test_lock_obj.set_down_thread_exit_test();
4414 test_lock_obj.test_thread_wait.lock();
4415 boost::thread::id proc_id = boost::this_thread::get_id();
4416 test_lock_obj.befor_thread_id = proc_id;
4417 test_lock_obj.after_thread_id = proc_id;
4418 test_lock_obj.mutex_lock();
4420 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
4422 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
4423 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
4425 boost::thread::id test_id = test_thread.get_id();
4427 BOOST_CHECK(test_id != proc_id);
4430 test_lock_obj.test_thread_wait.unlock();
4433 // unit_test [2] down_thread_exit thread block test (mutex lock)
4434 std::cout << "[2] down_thread_exit thread block test (mutex lock)" << std::endl;
4435 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
4436 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
4438 test_lock_obj.mutex_unlock();
4441 // unit_test [3] down_thread_exit thread run test (mutex unlock)
4442 std::cout << "[3] down_thread_exit thread run test (mutex unlock)" << std::endl;
4443 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
4444 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
4447 // // unit_test [4] down_thread_exit thread run after mutex unlock test
4448 // std::cout << "[4] down_thread_exit thread run after mutex unlock test" << std::endl;
4449 // BOOST_CHECK(test_lock_obj.mutex_trylock());
4450 // test_lock_obj.mutex_unlock();
4454 BOOST_MESSAGE( "----- down_thread_exit test end -----" );
4458 // up_thread_client_disconnect_event test
4459 // up_thread_client_disconnect_event test class
4460 class up_thread_client_disconnect_event_test_class : public module_event_map_test_base_class{
4462 // up_thread_client_disconnect_event_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : module_event_map_test_base_class(vs,session_io){
4464 up_thread_client_disconnect_event_test_class(
4465 l7vs::virtualservice_tcp& vs,
4466 boost::asio::io_service& session_io,
4467 l7vs::tcp_socket_option_info& set_socket_option,
4468 boost::asio::ip::tcp::endpoint listen_endpoint,
4470 boost::asio::ssl::context& set_ssl_context,
4471 bool set_ssl_cache_flag,
4472 int set_ssl_handshake_time_out,
4473 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
4480 set_ssl_handshake_time_out,
4481 set_access_logger){};
4483 ~up_thread_client_disconnect_event_test_class(){};
4486 l7vs::tcp_session::up_thread_client_disconnect_event(LOCAL_PROC);
4490 void up_thread_client_disconnect_event_test(){
4492 BOOST_MESSAGE( "----- up_thread_client_disconnect_event test start -----" );
4494 // boost::asio::io_service io;
4495 // l7vs::virtualservice_tcp vs;
4496 // up_thread_client_disconnect_event_test_class test_obj(vs,io);
4497 l7vs::virtualservice_tcp vs;
4498 boost::asio::io_service io;
4499 l7vs::tcp_socket_option_info set_option;
4500 //! TCP_NODELAY (false:not set,true:set option)
4501 set_option.nodelay_opt = false;
4502 //! TCP_NODELAY option value (false:off,true:on)
4503 set_option.nodelay_val = false;
4504 //! TCP_CORK (false:not set,true:set option)
4505 set_option.cork_opt = false;
4506 //! TCP_CORK option value (false:off,true:on)
4507 set_option.cork_val = false;
4508 //! TCP_QUICKACK (false:not set,true:set option)
4509 set_option.quickack_opt = false;
4510 //! TCP_QUICKACK option value (false:off,true:on)
4511 set_option.quickack_val = false;
4513 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
4514 bool set_mode(false);
4515 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
4516 bool set_ssl_cache_flag(false);
4517 int set_ssl_handshake_time_out = 0;
4518 //std::string access_log_file_name = "test";
4519 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
4521 up_thread_client_disconnect_event_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
4523 std::string test_protocol_name("test protocol");
4524 l7vs::test_protocol_module proto_test(test_protocol_name);
4526 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
4528 l7vs::protocol_module_base::EVENT_TAG chek_event[13];
4529 chek_event[0] = l7vs::protocol_module_base::ACCEPT;
4530 chek_event[1] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
4531 chek_event[2] = l7vs::protocol_module_base::CLIENT_RECV;
4532 chek_event[3] = l7vs::protocol_module_base::CLIENT_RESPONSE_SEND;
4533 chek_event[4] = l7vs::protocol_module_base::REALSERVER_SELECT;
4534 chek_event[5] = l7vs::protocol_module_base::REALSERVER_CONNECT;
4535 chek_event[6] = l7vs::protocol_module_base::REALSERVER_SEND;
4536 chek_event[7] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
4537 chek_event[8] = l7vs::protocol_module_base::SORRYSERVER_SELECT;
4538 chek_event[9] = l7vs::protocol_module_base::SORRYSERVER_CONNECT;
4539 chek_event[10] = l7vs::protocol_module_base::SORRYSERVER_SEND;
4540 chek_event[11] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
4541 chek_event[12] = l7vs::protocol_module_base::FINALIZE;
4543 // unit_test [1] up_thread_client_disconnect_event up_thread_next_call_function update check
4544 std::cout << "[1] up_thread_client_disconnect_event up_thread_next_call_function update check" << std::endl;
4545 for(int i = 0; i < 13;i++){
4546 proto_test.handle_client_disconnect_res_tag = chek_event[i];
4547 test_obj.test_call();
4548 BOOST_CHECK(test_obj.chk_up_thread_next_call_function(chek_event[i]));
4551 // unit_test [2] up_thread_client_disconnect_event module parameter check thread id
4552 std::cout << "[2] up_thread_client_disconnect_event module parameter check thread id" << std::endl;
4553 boost::thread::id def_id;
4554 boost::thread::id proc_id = boost::this_thread::get_id();
4555 test_obj.set_up_thread_id(proc_id);
4556 proto_test.handle_client_disconnect_thread_id = def_id;
4557 proto_test.handle_client_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
4558 BOOST_CHECK(proto_test.handle_client_disconnect_thread_id != proc_id);
4559 test_obj.test_call();
4560 BOOST_CHECK(proto_test.handle_client_disconnect_thread_id == proc_id);
4562 // unit_test [3] up_thread_client_disconnect_event not fond function error check
4563 std::cout << "[3] up_thread_client_disconnect_event not fond function error check" << std::endl;
4564 test_obj.up_thread_function_array_clear();
4565 proto_test.handle_client_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
4566 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
4567 l7vs::Logger::putLogError_id = 0;
4568 test_obj.test_call();
4569 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
4570 BOOST_CHECK_EQUAL(29,l7vs::Logger::putLogError_id);
4571 std::cout << l7vs::Logger::putLogError_message << std::endl;
4573 // unit_test [4] up_thread_client_disconnect_event returnd illegal EVENT_TAG error check
4574 std::cout << "[4] up_thread_client_disconnect_event returnd illegal EVENT_TAG error check" << std::endl;
4575 test_obj.up_thread_module_event_map_clear();
4576 proto_test.handle_client_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
4577 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
4578 l7vs::Logger::putLogError_id = 0;
4579 test_obj.test_call();
4580 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
4581 BOOST_CHECK_EQUAL(28,l7vs::Logger::putLogError_id);
4582 std::cout << l7vs::Logger::putLogError_message << std::endl;
4584 // mutex_lock_test test_lock_obj(vs,io);
4585 mutex_lock_test test_lock_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
4587 test_lock_obj.set_up_thread_client_disconnect_event_test();
4588 test_lock_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
4591 test_lock_obj.test_thread_wait.lock();
4592 test_lock_obj.befor_thread_id = proc_id;
4593 test_lock_obj.after_thread_id = proc_id;
4594 test_lock_obj.mutex_lock();
4596 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
4598 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
4599 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
4601 boost::thread::id test_id = test_thread.get_id();
4603 BOOST_CHECK(test_id != proc_id);
4606 test_lock_obj.test_thread_wait.unlock();
4609 // unit_test [5] up_thread_client_disconnect_event thread block test (mutex lock)
4610 std::cout << "[5] up_thread_client_disconnect_event thread block test (mutex lock)" << std::endl;
4611 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
4612 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
4614 test_lock_obj.mutex_unlock();
4617 // unit_test [6] up_thread_client_disconnect_event thread run test (mutex unlock)
4618 std::cout << "[6] up_thread_client_disconnect_event thread run test (mutex unlock)" << std::endl;
4619 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
4620 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
4622 BOOST_MESSAGE( "----- up_thread_client_disconnect_event test end -----" );
4625 // down_thread_client_disconnetc_event test
4626 // dwon_thread_client_disconnetc_event test class
4627 class down_thread_client_disconnect_event_test_class : public module_event_map_test_base_class{
4629 // down_thread_client_disconnect_event_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : module_event_map_test_base_class(vs,session_io){
4631 down_thread_client_disconnect_event_test_class(
4632 l7vs::virtualservice_tcp& vs,
4633 boost::asio::io_service& session_io,
4634 l7vs::tcp_socket_option_info& set_socket_option,
4635 boost::asio::ip::tcp::endpoint listen_endpoint,
4637 boost::asio::ssl::context& set_ssl_context,
4638 bool set_ssl_cache_flag,
4639 int set_ssl_handshake_time_out,
4640 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
4647 set_ssl_handshake_time_out,
4648 set_access_logger){};
4650 ~down_thread_client_disconnect_event_test_class(){};
4653 l7vs::tcp_session::down_thread_client_disconnect_event(LOCAL_PROC);
4657 void down_thread_client_disconnect_event_test(){
4659 BOOST_MESSAGE( "----- down_thread_client_disconnect_event test start -----" );
4661 // boost::asio::io_service io;
4662 // l7vs::virtualservice_tcp vs;
4663 // down_thread_client_disconnect_event_test_class test_obj(vs,io);
4664 l7vs::virtualservice_tcp vs;
4665 boost::asio::io_service io;
4666 l7vs::tcp_socket_option_info set_option;
4667 //! TCP_NODELAY (false:not set,true:set option)
4668 set_option.nodelay_opt = false;
4669 //! TCP_NODELAY option value (false:off,true:on)
4670 set_option.nodelay_val = false;
4671 //! TCP_CORK (false:not set,true:set option)
4672 set_option.cork_opt = false;
4673 //! TCP_CORK option value (false:off,true:on)
4674 set_option.cork_val = false;
4675 //! TCP_QUICKACK (false:not set,true:set option)
4676 set_option.quickack_opt = false;
4677 //! TCP_QUICKACK option value (false:off,true:on)
4678 set_option.quickack_val = false;
4680 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
4681 bool set_mode(false);
4682 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
4683 bool set_ssl_cache_flag(false);
4684 int set_ssl_handshake_time_out = 0;
4685 //std::string access_log_file_name = "test";
4686 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
4688 down_thread_client_disconnect_event_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
4690 std::string test_protocol_name("test protocol");
4691 l7vs::test_protocol_module proto_test(test_protocol_name);
4693 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
4695 l7vs::protocol_module_base::EVENT_TAG chek_event[7];
4696 chek_event[0] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
4697 chek_event[1] = l7vs::protocol_module_base::CLIENT_CONNECTION_CHECK;
4698 chek_event[2] = l7vs::protocol_module_base::REALSERVER_RECV;
4699 chek_event[3] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
4700 chek_event[4] = l7vs::protocol_module_base::SORRYSERVER_RECV;
4701 chek_event[5] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
4702 chek_event[6] = l7vs::protocol_module_base::FINALIZE;
4704 // unit_test [1] down_thread_client_disconnect_event up_thread_next_call_function update check
4705 std::cout << "[1] down_thread_client_disconnect_event up_thread_next_call_function update check" << std::endl;
4706 for(int i = 0; i < 7;i++){
4707 proto_test.handle_client_disconnect_res_tag = chek_event[i];
4708 test_obj.test_call();
4709 BOOST_CHECK(test_obj.chk_down_thread_next_call_function(chek_event[i]));
4712 // unit_test [2] down_thread_client_disconnect_event module parameter check thread id
4713 std::cout << "[2] down_thread_client_disconnect_event module parameter check thread id" << std::endl;
4714 boost::thread::id def_id;
4715 boost::thread::id proc_id = boost::this_thread::get_id();
4716 test_obj.set_down_thread_id(proc_id);
4717 proto_test.handle_client_disconnect_thread_id = def_id;
4718 proto_test.handle_client_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
4719 BOOST_CHECK(proto_test.handle_client_disconnect_thread_id != proc_id);
4720 test_obj.test_call();
4721 BOOST_CHECK(proto_test.handle_client_disconnect_thread_id == proc_id);
4723 // unit_test [3] down_thread_client_disconnect_event not fond function error check
4724 std::cout << "[3] down_thread_client_disconnect_event not fond function error check" << std::endl;
4725 test_obj.down_thread_function_array_clear();
4726 proto_test.handle_client_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
4727 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
4728 l7vs::Logger::putLogError_id = 0;
4729 test_obj.test_call();
4730 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
4731 BOOST_CHECK_EQUAL(87,l7vs::Logger::putLogError_id);
4732 std::cout << l7vs::Logger::putLogError_message << std::endl;
4734 // unit_test [4] down_thread_client_disconnect_event returnd illegal EVENT_TAG error check
4735 std::cout << "[4] down_thread_client_disconnect_event returnd illegal EVENT_TAG error check" << std::endl;
4736 test_obj.down_thread_module_event_map_clear();
4737 proto_test.handle_client_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
4738 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
4739 l7vs::Logger::putLogError_id = 0;
4740 test_obj.test_call();
4741 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
4742 BOOST_CHECK_EQUAL(86,l7vs::Logger::putLogError_id);
4743 std::cout << l7vs::Logger::putLogError_message << std::endl;
4745 // mutex_lock_test test_lock_obj(vs,io);
4746 mutex_lock_test test_lock_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
4748 test_lock_obj.set_down_thread_client_disconnect_event_test();
4749 test_lock_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
4751 test_lock_obj.test_thread_wait.lock();
4752 test_lock_obj.befor_thread_id = proc_id;
4753 test_lock_obj.after_thread_id = proc_id;
4754 test_lock_obj.mutex_lock();
4756 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
4758 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
4759 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
4761 boost::thread::id test_id = test_thread.get_id();
4763 BOOST_CHECK(test_id != proc_id);
4766 test_lock_obj.test_thread_wait.unlock();
4769 // unit_test [5] down_thread_client_disconnect_event thread block test (mutex lock)
4770 std::cout << "[5] down_thread_client_disconnect_event thread block test (mutex lock)" << std::endl;
4771 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
4772 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
4774 test_lock_obj.mutex_unlock();
4777 // unit_test [6] down_thread_client_disconnect_event thread run test (mutex unlock)
4778 std::cout << "[6] down_thread_client_disconnect_event thread run test (mutex unlock)" << std::endl;
4779 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
4780 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
4782 BOOST_MESSAGE( "----- down_thread_client_disconnect_event test end -----" );
4785 // up_thread_realserver_get_detination_event test
4786 // up_thread_realserver_get_detination_event test class
4787 class up_thread_realserver_get_detination_event_test_class : public l7vs::tcp_session{
4789 // up_thread_realserver_get_detination_event_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){
4791 up_thread_realserver_get_detination_event_test_class(
4792 l7vs::virtualservice_tcp& vs,
4793 boost::asio::io_service& session_io,
4794 l7vs::tcp_socket_option_info& set_socket_option,
4795 boost::asio::ip::tcp::endpoint listen_endpoint,
4797 boost::asio::ssl::context& set_ssl_context,
4798 bool set_ssl_cache_flag,
4799 int set_ssl_handshake_time_out,
4800 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
4807 set_ssl_handshake_time_out,
4808 set_access_logger){};
4810 ~up_thread_realserver_get_detination_event_test_class(){};
4813 tcp_session::up_thread_realserver_get_destination_event(LOCAL_PROC);
4816 l7vs::tcp_data& get_up_thread_data_dest_side(){
4817 return up_thread_data_dest_side;
4820 up_thread_next_call_function.second(LOCAL_PROC);
4823 void up_thread_realserver_connect(const TCP_PROCESS_TYPE_TAG process_type){
4824 up_thread_realserver_connect_call_check = true;
4827 bool up_thread_realserver_connect_call_check;
4829 void set_protocol_module(l7vs::protocol_module_base* set_proto){
4830 protocol_module = set_proto;
4833 void set_up_thread_id(boost::thread::id set_id){
4834 up_thread_id = set_id;
4837 void up_thread_function_array_clear(){
4838 for(int i = 0; i <= UP_FUNC_EXIT;i++){
4839 up_thread_function_array[i].second = NULL;
4842 void up_thread_module_event_map_clear(){
4843 up_thread_module_event_map.clear();
4846 void up_thread_realserver_get_detination_event_test(){
4847 BOOST_MESSAGE( "----- up_thread_realserver_get_detination_event test start -----" );
4849 // boost::asio::io_service io;
4850 // l7vs::virtualservice_tcp vs;
4851 // up_thread_realserver_get_detination_event_test_class test_obj(vs,io);
4852 l7vs::virtualservice_tcp vs;
4853 boost::asio::io_service io;
4854 l7vs::tcp_socket_option_info set_option;
4855 //! TCP_NODELAY (false:not set,true:set option)
4856 set_option.nodelay_opt = false;
4857 //! TCP_NODELAY option value (false:off,true:on)
4858 set_option.nodelay_val = false;
4859 //! TCP_CORK (false:not set,true:set option)
4860 set_option.cork_opt = false;
4861 //! TCP_CORK option value (false:off,true:on)
4862 set_option.cork_val = false;
4863 //! TCP_QUICKACK (false:not set,true:set option)
4864 set_option.quickack_opt = false;
4865 //! TCP_QUICKACK option value (false:off,true:on)
4866 set_option.quickack_val = false;
4868 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
4869 bool set_mode(false);
4870 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
4871 bool set_ssl_cache_flag(false);
4872 int set_ssl_handshake_time_out = 0;
4873 //std::string access_log_file_name = "test";
4874 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
4876 up_thread_realserver_get_detination_event_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
4879 std::string test_protocol_name("test protocol");
4880 l7vs::test_protocol_module proto_test(test_protocol_name);
4881 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
4882 l7vs::tcp_data& up_thread_data_dest_side = test_obj.get_up_thread_data_dest_side();
4883 boost::thread::id proc_id = boost::this_thread::get_id();
4884 test_obj.set_up_thread_id(proc_id);
4886 proto_test.handle_realserver_select_tcp_res_tag = l7vs::protocol_module_base::REALSERVER_CONNECT;
4887 proto_test.handle_realserver_select_out_rs_endpoint = boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string("100.101.102.103"), 7777);
4888 up_thread_data_dest_side.initialize();
4889 BOOST_CHECK(proto_test.handle_realserver_select_in_thread_id != proc_id);
4891 test_obj.test_call();
4893 // unit_test [1] up_thread_realserver_get_detination_event handle_realserver_select call check
4894 std::cout << "[1] up_thread_realserver_get_detination_event handle_realserver_select call check" << std::endl;
4895 BOOST_CHECK(proto_test.handle_realserver_select_in_thread_id == proc_id);
4896 boost::asio::ip::tcp::endpoint get_endpoint = up_thread_data_dest_side.get_endpoint();
4897 BOOST_CHECK(get_endpoint == proto_test.handle_realserver_select_out_rs_endpoint);
4899 // unit_test [2] up_thread_realserver_get_detination_event up_thread_next_call_function update check
4900 std::cout << "[2] up_thread_realserver_get_detination_event up_thread_next_call_function update check" << std::endl;
4901 test_obj.up_thread_realserver_connect_call_check = false;
4902 test_obj.next_call();
4903 BOOST_CHECK(test_obj.up_thread_realserver_connect_call_check);
4905 // unit_test [3] up_thread_realserver_get_detination_event not fond function error check
4906 std::cout << "[3] up_thread_realserver_get_detination_event not fond function error check" << std::endl;
4907 test_obj.up_thread_function_array_clear();
4908 proto_test.handle_realserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
4909 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
4910 l7vs::Logger::putLogError_id = 0;
4911 test_obj.test_call();
4912 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
4913 BOOST_CHECK_EQUAL(33,l7vs::Logger::putLogError_id);
4914 std::cout << l7vs::Logger::putLogError_message << std::endl;
4916 // unit_test [4] up_thread_realserver_get_detination_event returnd illegal EVENT_TAG error check
4917 std::cout << "[4] up_thread_realserver_get_detination_event returnd illegal EVENT_TAG error check" << std::endl;
4918 test_obj.up_thread_module_event_map_clear();
4919 proto_test.handle_realserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
4920 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
4921 l7vs::Logger::putLogError_id = 0;
4922 test_obj.test_call();
4923 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
4924 BOOST_CHECK_EQUAL(32,l7vs::Logger::putLogError_id);
4925 std::cout << l7vs::Logger::putLogError_message << std::endl;
4927 BOOST_MESSAGE( "----- up_thread_realserver_get_detination_event test end -----" );
4929 // up_thread_sorryserver_get_detination_event test
4930 // up_thread_sorryserver_get_detination_event test class
4931 class up_thread_sorryserver_get_detination_event_test_class : public l7vs::tcp_session{
4933 // up_thread_sorryserver_get_detination_event_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){
4935 up_thread_sorryserver_get_detination_event_test_class(
4936 l7vs::virtualservice_tcp& vs,
4937 boost::asio::io_service& session_io,
4938 l7vs::tcp_socket_option_info& set_socket_option,
4939 boost::asio::ip::tcp::endpoint listen_endpoint,
4941 boost::asio::ssl::context& set_ssl_context,
4942 bool set_ssl_cache_flag,
4943 int set_ssl_handshake_time_out,
4944 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
4951 set_ssl_handshake_time_out,
4952 set_access_logger){};
4954 ~up_thread_sorryserver_get_detination_event_test_class(){};
4957 tcp_session::up_thread_sorryserver_get_destination_event(LOCAL_PROC);
4960 l7vs::tcp_data& get_up_thread_data_dest_side(){
4961 return up_thread_data_dest_side;
4964 up_thread_next_call_function.second(LOCAL_PROC);
4967 void up_thread_sorryserver_connect(const TCP_PROCESS_TYPE_TAG process_type){
4968 up_thread_sorryserver_connect_call_check = true;
4971 bool up_thread_sorryserver_connect_call_check;
4973 void set_protocol_module(l7vs::protocol_module_base* set_proto){
4974 protocol_module = set_proto;
4977 void set_up_thread_id(boost::thread::id set_id){
4978 up_thread_id = set_id;
4981 void up_thread_function_array_clear(){
4982 for(int i = 0; i <= UP_FUNC_EXIT; i++){
4983 up_thread_function_array[i].second = NULL;
4986 void up_thread_module_event_map_clear(){
4987 up_thread_module_event_map.clear();
4990 void up_thread_sorryserver_get_detination_event_test(){
4991 BOOST_MESSAGE( "----- up_thread_sorryserver_get_detination_event test start -----" );
4993 // boost::asio::io_service io;
4994 // l7vs::virtualservice_tcp vs;
4995 // up_thread_sorryserver_get_detination_event_test_class test_obj(vs,io);
4996 l7vs::virtualservice_tcp vs;
4997 boost::asio::io_service io;
4998 l7vs::tcp_socket_option_info set_option;
4999 //! TCP_NODELAY (false:not set,true:set option)
5000 set_option.nodelay_opt = false;
5001 //! TCP_NODELAY option value (false:off,true:on)
5002 set_option.nodelay_val = false;
5003 //! TCP_CORK (false:not set,true:set option)
5004 set_option.cork_opt = false;
5005 //! TCP_CORK option value (false:off,true:on)
5006 set_option.cork_val = false;
5007 //! TCP_QUICKACK (false:not set,true:set option)
5008 set_option.quickack_opt = false;
5009 //! TCP_QUICKACK option value (false:off,true:on)
5010 set_option.quickack_val = false;
5012 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
5013 bool set_mode(false);
5014 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
5015 bool set_ssl_cache_flag(false);
5016 int set_ssl_handshake_time_out = 0;
5017 //std::string access_log_file_name = "test";
5018 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
5020 up_thread_sorryserver_get_detination_event_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
5022 std::string test_protocol_name("test protocol");
5023 l7vs::test_protocol_module proto_test(test_protocol_name);
5024 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
5025 l7vs::tcp_data& up_thread_data_dest_side = test_obj.get_up_thread_data_dest_side();
5026 boost::thread::id proc_id = boost::this_thread::get_id();
5027 test_obj.set_up_thread_id(proc_id);
5029 proto_test.handle_sorryserver_select_res_tag = l7vs::protocol_module_base::SORRYSERVER_CONNECT;
5030 proto_test.handle_sorryserver_select_out_sorry_endpoint = boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string("100.101.102.103"), 7777);
5031 vs.my_element.sorry_endpoint = boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string("200.201.202.203"), 8888);
5033 up_thread_data_dest_side.initialize();
5034 BOOST_CHECK(proto_test.handle_sorryserver_select_in_thread_id != proc_id);
5036 test_obj.test_call();
5038 // unit_test [1] up_thread_sorryserver_get_detination_event handle_realserver_select call check
5039 std::cout << "[1] up_thread_sorryserver_get_detination_event handle_realserver_select call check" << std::endl;
5040 BOOST_CHECK(proto_test.handle_sorryserver_select_in_thread_id == proc_id);
5041 boost::asio::ip::tcp::endpoint get_endpoint = up_thread_data_dest_side.get_endpoint();
5042 BOOST_CHECK(get_endpoint == proto_test.handle_sorryserver_select_out_sorry_endpoint);
5043 BOOST_CHECK(vs.my_element.sorry_endpoint == proto_test.handle_sorryserver_select_in_sorry_endpoint);
5045 // unit_test [2] up_thread_sorryserver_get_detination_event up_thread_next_call_function update check
5046 std::cout << "[2] up_thread_sorryserver_get_detination_event up_thread_next_call_function update check" << std::endl;
5047 test_obj.up_thread_sorryserver_connect_call_check = false;
5048 test_obj.next_call();
5049 BOOST_CHECK(test_obj.up_thread_sorryserver_connect_call_check);
5051 // unit_test [3] up_thread_sorryserver_get_detination_event not fond function error check
5052 std::cout << "[3] up_thread_sorryserver_get_detination_event not fond function error check" << std::endl;
5053 test_obj.up_thread_function_array_clear();
5054 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5055 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
5056 l7vs::Logger::putLogError_id = 0;
5057 test_obj.test_call();
5058 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
5059 BOOST_CHECK_EQUAL(52,l7vs::Logger::putLogError_id);
5060 std::cout << l7vs::Logger::putLogError_message << std::endl;
5062 // unit_test [4] up_thread_sorryserver_get_detination_event returnd illegal EVENT_TAG error check
5063 std::cout << "[4] up_thread_sorryserver_get_detination_event returnd illegal EVENT_TAG error check" << std::endl;
5064 test_obj.up_thread_module_event_map_clear();
5065 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5066 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
5067 l7vs::Logger::putLogError_id = 0;
5068 test_obj.test_call();
5069 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
5070 BOOST_CHECK_EQUAL(51,l7vs::Logger::putLogError_id);
5071 std::cout << l7vs::Logger::putLogError_message << std::endl;
5073 BOOST_MESSAGE( "----- up_thread_sorryserver_get_detination_event test end -----" );
5077 // up_thread_realserver_disconnect_event test
5078 // up_thread_realserver_disconnect_event test class
5079 class up_thread_realserver_disconnect_event_test_class : public module_event_map_test_base_class{
5081 // up_thread_realserver_disconnect_event_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : module_event_map_test_base_class(vs,session_io){
5083 up_thread_realserver_disconnect_event_test_class(
5084 l7vs::virtualservice_tcp& vs,
5085 boost::asio::io_service& session_io,
5086 l7vs::tcp_socket_option_info& set_socket_option,
5087 boost::asio::ip::tcp::endpoint listen_endpoint,
5089 boost::asio::ssl::context& set_ssl_context,
5090 bool set_ssl_cache_flag,
5091 int set_ssl_handshake_time_out,
5092 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
5099 set_ssl_handshake_time_out,
5100 set_access_logger){};
5103 ~up_thread_realserver_disconnect_event_test_class(){};
5106 l7vs::tcp_session::up_thread_realserver_disconnect_event(LOCAL_PROC);
5109 std::map<endpoint,tcp_socket_ptr>& get_realserver_socket_map(){
5110 return up_thread_send_realserver_socket_map;
5114 void up_thread_realserver_disconnect_event_test(){
5116 BOOST_MESSAGE( "----- up_thread_realserver_disconnect_event test start -----" );
5118 boost::asio::io_service io;
5119 l7vs::virtualservice_tcp vs;
5120 // up_thread_realserver_disconnect_event_test_class test_obj(vs,io);
5121 l7vs::tcp_socket_option_info set_option;
5122 //! TCP_NODELAY (false:not set,true:set option)
5123 set_option.nodelay_opt = false;
5124 //! TCP_NODELAY option value (false:off,true:on)
5125 set_option.nodelay_val = false;
5126 //! TCP_CORK (false:not set,true:set option)
5127 set_option.cork_opt = false;
5128 //! TCP_CORK option value (false:off,true:on)
5129 set_option.cork_val = false;
5130 //! TCP_QUICKACK (false:not set,true:set option)
5131 set_option.quickack_opt = false;
5132 //! TCP_QUICKACK option value (false:off,true:on)
5133 set_option.quickack_val = false;
5135 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
5136 bool set_mode(false);
5137 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
5138 bool set_ssl_cache_flag(false);
5139 int set_ssl_handshake_time_out = 0;
5140 //std::string access_log_file_name = "test";
5141 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
5143 up_thread_realserver_disconnect_event_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
5148 std::string test_protocol_name("test protocol");
5149 l7vs::test_protocol_module proto_test(test_protocol_name);
5151 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
5153 l7vs::protocol_module_base::EVENT_TAG chek_event[13];
5154 chek_event[0] = l7vs::protocol_module_base::ACCEPT;
5155 chek_event[1] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
5156 chek_event[2] = l7vs::protocol_module_base::CLIENT_RECV;
5157 chek_event[3] = l7vs::protocol_module_base::CLIENT_RESPONSE_SEND;
5158 chek_event[4] = l7vs::protocol_module_base::REALSERVER_SELECT;
5159 chek_event[5] = l7vs::protocol_module_base::REALSERVER_CONNECT;
5160 chek_event[6] = l7vs::protocol_module_base::REALSERVER_SEND;
5161 chek_event[7] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
5162 chek_event[8] = l7vs::protocol_module_base::SORRYSERVER_SELECT;
5163 chek_event[9] = l7vs::protocol_module_base::SORRYSERVER_CONNECT;
5164 chek_event[10] = l7vs::protocol_module_base::SORRYSERVER_SEND;
5165 chek_event[11] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
5166 chek_event[12] = l7vs::protocol_module_base::FINALIZE;
5168 // unit_test [1] up_thread_realserver_disconnect_event up_thread_next_call_function update check
5169 std::cout << "[1] up_thread_realserver_disconnect_event up_thread_next_call_function update check" << std::endl;
5170 for(int i = 0; i < 13;i++){
5171 proto_test.handle_realserver_disconnect_res_tag = chek_event[i];
5172 test_obj.test_call();
5173 BOOST_CHECK(test_obj.chk_up_thread_next_call_function(chek_event[i]));
5176 // module parameter check
5177 boost::thread::id def_id;
5178 boost::thread::id proc_id = boost::this_thread::get_id();
5179 boost::asio::ip::tcp::endpoint test_end(boost::asio::ip::address::from_string("100.102.103.104"), 7777);
5180 l7vs::tcp_data test_message;
5181 test_message.set_endpoint(test_end);
5182 test_obj.set_up_thread_id(proc_id);
5183 test_obj.set_up_thread_message_data(test_message);
5184 proto_test.handle_realserver_disconnect_thread_id = def_id;
5185 proto_test.handle_realserver_disconnect_rs_endpoint = boost::asio::ip::tcp::endpoint();
5186 proto_test.handle_realserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5187 BOOST_CHECK(proto_test.handle_realserver_disconnect_thread_id != proc_id);
5188 BOOST_CHECK(proto_test.handle_realserver_disconnect_rs_endpoint != test_end);
5189 test_obj.test_call();
5190 // unit_test [2] up_thread_realserver_disconnect_event module parameter check thread id
5191 std::cout << "[2] up_thread_realserver_disconnect_event module parameter check thread id" << std::endl;
5192 BOOST_CHECK(proto_test.handle_realserver_disconnect_thread_id == proc_id);
5194 // unit_test [3] up_thread_realserver_disconnect_event module parameter check endpoint
5195 std::cout << "[3] up_thread_realserver_disconnect_event module parameter check endpoint" << std::endl;
5196 BOOST_CHECK(proto_test.handle_realserver_disconnect_rs_endpoint == test_end);
5199 // unit_test [4] up_thread_realserver_disconnect_event realserver map erase check
5200 std::cout << "[4] up_thread_realserver_disconnect_event realserver map erase check" << std::endl;
5202 std::map<boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > >& realserver_map = test_obj.get_realserver_socket_map();
5203 boost::shared_ptr< l7vs::tcp_socket > test_tcp_sock0(new l7vs::tcp_socket(io));
5204 boost::shared_ptr< l7vs::tcp_socket > test_tcp_sock1(new l7vs::tcp_socket(io));
5205 boost::shared_ptr< l7vs::tcp_socket > test_tcp_sock2(new l7vs::tcp_socket(io));
5206 std::pair< boost::asio::ip::tcp::endpoint , boost::shared_ptr< l7vs::tcp_socket > > test_sock_list[3];
5207 test_sock_list[0].first = boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string("100.100.100.100"), 0);
5208 test_sock_list[0].second = test_tcp_sock0;
5209 test_sock_list[1].first = boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string("101.101.101.101"), 1);
5210 test_sock_list[1].second = test_tcp_sock1;
5211 test_sock_list[2].first = boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string("102.102.102.102"), 2);
5212 test_sock_list[2].second = test_tcp_sock2;
5213 for(int i = 0;i < 3;i++){
5214 realserver_map.insert(test_sock_list[i]);
5216 proto_test.handle_realserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5219 test_message.set_endpoint(test_sock_list[1].first);
5220 test_obj.set_up_thread_message_data(test_message);
5221 BOOST_CHECK(realserver_map.find(test_sock_list[0].first) != realserver_map.end());
5222 BOOST_CHECK(realserver_map.find(test_sock_list[1].first) != realserver_map.end());
5223 BOOST_CHECK(realserver_map.find(test_sock_list[2].first) != realserver_map.end());
5224 test_obj.test_call();
5225 BOOST_CHECK(realserver_map.find(test_sock_list[0].first) != realserver_map.end());
5226 BOOST_CHECK(realserver_map.find(test_sock_list[1].first) == realserver_map.end());
5227 BOOST_CHECK(realserver_map.find(test_sock_list[2].first) != realserver_map.end());
5229 test_message.set_endpoint(test_sock_list[0].first);
5230 test_obj.set_up_thread_message_data(test_message);
5231 BOOST_CHECK(realserver_map.find(test_sock_list[0].first) != realserver_map.end());
5232 BOOST_CHECK(realserver_map.find(test_sock_list[1].first) == realserver_map.end());
5233 BOOST_CHECK(realserver_map.find(test_sock_list[2].first) != realserver_map.end());
5234 test_obj.test_call();
5235 BOOST_CHECK(realserver_map.find(test_sock_list[0].first) == realserver_map.end());
5236 BOOST_CHECK(realserver_map.find(test_sock_list[1].first) == realserver_map.end());
5237 BOOST_CHECK(realserver_map.find(test_sock_list[2].first) != realserver_map.end());
5239 test_message.set_endpoint(test_sock_list[2].first);
5240 test_obj.set_up_thread_message_data(test_message);
5241 BOOST_CHECK(realserver_map.find(test_sock_list[0].first) == realserver_map.end());
5242 BOOST_CHECK(realserver_map.find(test_sock_list[1].first) == realserver_map.end());
5243 BOOST_CHECK(realserver_map.find(test_sock_list[2].first) != realserver_map.end());
5244 test_obj.test_call();
5245 BOOST_CHECK(realserver_map.find(test_sock_list[0].first) == realserver_map.end());
5246 BOOST_CHECK(realserver_map.find(test_sock_list[1].first) == realserver_map.end());
5247 BOOST_CHECK(realserver_map.find(test_sock_list[2].first) == realserver_map.end());
5248 BOOST_CHECK(realserver_map.empty());
5250 // unit_test [5] up_thread_realserver_disconnect_event not fond function error check
5251 std::cout << "[5] up_thread_realserver_disconnect_event not fond function error check" << std::endl;
5252 test_obj.up_thread_function_array_clear();
5253 proto_test.handle_realserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5254 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
5255 l7vs::Logger::putLogError_id = 0;
5256 test_obj.test_call();
5257 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
5258 BOOST_CHECK_EQUAL(46,l7vs::Logger::putLogError_id);
5259 std::cout << l7vs::Logger::putLogError_message << std::endl;
5261 // unit_test [6] up_thread_realserver_disconnect_event returnd illegal EVENT_TAG error check
5262 std::cout << "[6] up_thread_realserver_disconnect_event returnd illegal EVENT_TAG error check" << std::endl;
5263 test_obj.up_thread_module_event_map_clear();
5264 proto_test.handle_realserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5265 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
5266 l7vs::Logger::putLogError_id = 0;
5267 test_obj.test_call();
5268 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
5269 BOOST_CHECK_EQUAL(45,l7vs::Logger::putLogError_id);
5270 std::cout << l7vs::Logger::putLogError_message << std::endl;
5272 // mutex_lock_test test_lock_obj(vs,io);
5273 mutex_lock_test test_lock_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
5275 test_lock_obj.set_up_thread_realserver_disconnect_event_test();
5276 test_lock_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
5278 test_lock_obj.test_thread_wait.lock();
5279 test_lock_obj.befor_thread_id = proc_id;
5280 test_lock_obj.after_thread_id = proc_id;
5281 test_lock_obj.mutex_lock();
5283 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
5285 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
5286 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
5288 boost::thread::id test_id = test_thread.get_id();
5290 BOOST_CHECK(test_id != proc_id);
5293 test_lock_obj.test_thread_wait.unlock();
5296 // unit_test [7] up_thread_realserver_disconnect_event thread block test (mutex lock)
5297 std::cout << "[7] up_thread_realserver_disconnect_event thread block test (mutex lock)" << std::endl;
5298 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
5299 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
5301 test_lock_obj.mutex_unlock();
5304 // unit_test [8] up_thread_realserver_disconnect_event thread run test (mutex unlock)
5305 std::cout << "[8] up_thread_realserver_disconnect_event thread run test (mutex unlock)" << std::endl;
5306 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
5307 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
5309 BOOST_MESSAGE( "----- up_thread_realserver_disconnect_event test end -----" );
5314 // down_thread_realserver_disconnetc_event test
5315 // down_thread_realserver_disconnetc_event test class
5316 class down_thread_realserver_disconnect_event_test_class : public module_event_map_test_base_class{
5318 // down_thread_realserver_disconnect_event_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : module_event_map_test_base_class(vs,session_io){
5320 down_thread_realserver_disconnect_event_test_class(
5321 l7vs::virtualservice_tcp& vs,
5322 boost::asio::io_service& session_io,
5323 l7vs::tcp_socket_option_info& set_socket_option,
5324 boost::asio::ip::tcp::endpoint listen_endpoint,
5326 boost::asio::ssl::context& set_ssl_context,
5327 bool set_ssl_cache_flag,
5328 int set_ssl_handshake_time_out,
5329 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
5336 set_ssl_handshake_time_out,
5337 set_access_logger){};
5340 ~down_thread_realserver_disconnect_event_test_class(){};
5343 l7vs::tcp_session::down_thread_realserver_disconnect_event(LOCAL_PROC);
5346 std::list<socket_element>& get_realserver_socket_list(){
5347 return down_thread_receive_realserver_socket_list;
5351 void down_thread_realserver_disconnect_event_test(){
5353 BOOST_MESSAGE( "----- down_thread_realserver_disconnect_event test start -----" );
5355 boost::asio::io_service io;
5356 l7vs::virtualservice_tcp vs;
5357 l7vs::tcp_socket_option_info set_option;
5358 //! TCP_NODELAY (false:not set,true:set option)
5359 set_option.nodelay_opt = false;
5360 //! TCP_NODELAY option value (false:off,true:on)
5361 set_option.nodelay_val = false;
5362 //! TCP_CORK (false:not set,true:set option)
5363 set_option.cork_opt = false;
5364 //! TCP_CORK option value (false:off,true:on)
5365 set_option.cork_val = false;
5366 //! TCP_QUICKACK (false:not set,true:set option)
5367 set_option.quickack_opt = false;
5368 //! TCP_QUICKACK option value (false:off,true:on)
5369 set_option.quickack_val = false;
5371 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
5372 bool set_mode(false);
5373 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
5374 bool set_ssl_cache_flag(false);
5375 int set_ssl_handshake_time_out = 0;
5376 //std::string access_log_file_name = "test";
5377 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
5378 // down_thread_realserver_disconnect_event_test_class test_obj(vs,io);
5379 down_thread_realserver_disconnect_event_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
5385 std::string test_protocol_name("test protocol");
5386 l7vs::test_protocol_module proto_test(test_protocol_name);
5388 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
5390 l7vs::protocol_module_base::EVENT_TAG chek_event[7];
5391 chek_event[0] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
5392 chek_event[1] = l7vs::protocol_module_base::CLIENT_CONNECTION_CHECK;
5393 chek_event[2] = l7vs::protocol_module_base::REALSERVER_RECV;
5394 chek_event[3] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
5395 chek_event[4] = l7vs::protocol_module_base::SORRYSERVER_RECV;
5396 chek_event[5] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
5397 chek_event[6] = l7vs::protocol_module_base::FINALIZE;
5399 // unit_test [1] down_thread_realserver_disconnect_event down_thread_next_call_function update check
5400 std::cout << "[1] down_thread_realserver_disconnect_event down_thread_next_call_function update check" << std::endl;
5401 for(int i = 0; i < 7;i++){
5402 proto_test.handle_realserver_disconnect_res_tag = chek_event[i];
5403 test_obj.test_call();
5404 BOOST_CHECK(test_obj.chk_down_thread_next_call_function(chek_event[i]));
5407 // module parameter check
5408 boost::thread::id def_id;
5409 boost::thread::id proc_id = boost::this_thread::get_id();
5410 boost::asio::ip::tcp::endpoint test_end(boost::asio::ip::address::from_string("100.102.103.104"), 7777);
5411 l7vs::tcp_data test_message;
5412 test_message.set_endpoint(test_end);
5413 test_obj.set_down_thread_id(proc_id);
5414 test_obj.set_down_thread_message_data(test_message);
5415 proto_test.handle_realserver_disconnect_thread_id = def_id;
5416 proto_test.handle_realserver_disconnect_rs_endpoint = boost::asio::ip::tcp::endpoint();
5417 proto_test.handle_realserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5418 BOOST_CHECK(proto_test.handle_realserver_disconnect_thread_id != proc_id);
5419 BOOST_CHECK(proto_test.handle_realserver_disconnect_rs_endpoint != test_end);
5420 test_obj.test_call();
5421 // unit_test [2] down_thread_realserver_disconnect_event module parameter check thread id
5422 std::cout << "[2] down_thread_realserver_disconnect_event module parameter check thread id" << std::endl;
5423 BOOST_CHECK(proto_test.handle_realserver_disconnect_thread_id == proc_id);
5425 // unit_test [3] down_thread_realserver_disconnect_event module parameter check endpoint
5426 std::cout << "[3] down_thread_realserver_disconnect_event module parameter check endpoint" << std::endl;
5427 BOOST_CHECK(proto_test.handle_realserver_disconnect_rs_endpoint == test_end);
5430 // unit_test [4] down_thread_realserver_disconnect_event realserver map erase check
5431 std::cout << "[4] down_thread_realserver_disconnect_event realserver map erase check" << std::endl;
5433 std::list< std::pair< boost::asio::ip::tcp::endpoint , boost::shared_ptr< l7vs::tcp_socket > > >& realserver_list = test_obj.get_realserver_socket_list();
5434 boost::shared_ptr< l7vs::tcp_socket > test_tcp_sock0(new l7vs::tcp_socket(io));
5435 boost::shared_ptr< l7vs::tcp_socket > test_tcp_sock1(new l7vs::tcp_socket(io));
5436 boost::shared_ptr< l7vs::tcp_socket > test_tcp_sock2(new l7vs::tcp_socket(io));
5437 std::pair< boost::asio::ip::tcp::endpoint , boost::shared_ptr< l7vs::tcp_socket > > test_sock_list[3];
5438 test_sock_list[0].first = boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string("100.100.100.100"), 0);
5439 test_sock_list[0].second = test_tcp_sock0;
5440 test_sock_list[1].first = boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string("101.101.101.101"), 1);
5441 test_sock_list[1].second = test_tcp_sock1;
5442 test_sock_list[2].first = boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string("102.102.102.102"), 2);
5443 test_sock_list[2].second = test_tcp_sock2;
5444 for(int i = 0;i < 3;i++){
5445 realserver_list.push_back(test_sock_list[i]);
5447 proto_test.handle_realserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5448 std::list< std::pair< boost::asio::ip::tcp::endpoint , boost::shared_ptr< l7vs::tcp_socket > > >::iterator ret_ite;
5451 test_message.set_endpoint(test_sock_list[1].first);
5452 test_obj.set_down_thread_message_data(test_message);
5453 ret_ite = realserver_list.begin();
5454 BOOST_CHECK(ret_ite->first == test_sock_list[0].first);
5456 BOOST_CHECK(ret_ite->first == test_sock_list[1].first);
5458 BOOST_CHECK(ret_ite->first == test_sock_list[2].first);
5460 BOOST_CHECK(ret_ite == realserver_list.end());
5461 test_obj.test_call();
5462 ret_ite = realserver_list.begin();
5463 BOOST_CHECK(ret_ite->first == test_sock_list[0].first);
5465 BOOST_CHECK(ret_ite->first == test_sock_list[2].first);
5467 BOOST_CHECK(ret_ite == realserver_list.end());
5470 test_message.set_endpoint(test_sock_list[0].first);
5471 test_obj.set_down_thread_message_data(test_message);
5472 ret_ite = realserver_list.begin();
5473 BOOST_CHECK(ret_ite->first == test_sock_list[0].first);
5475 BOOST_CHECK(ret_ite->first == test_sock_list[2].first);
5477 BOOST_CHECK(ret_ite == realserver_list.end());
5478 test_obj.test_call();
5479 ret_ite = realserver_list.begin();
5480 BOOST_CHECK(ret_ite->first == test_sock_list[2].first);
5482 BOOST_CHECK(ret_ite == realserver_list.end());
5485 test_message.set_endpoint(test_sock_list[2].first);
5486 test_obj.set_down_thread_message_data(test_message);
5487 ret_ite = realserver_list.begin();
5488 BOOST_CHECK(ret_ite->first == test_sock_list[2].first);
5490 BOOST_CHECK(ret_ite == realserver_list.end());
5491 test_obj.test_call();
5492 ret_ite = realserver_list.begin();
5493 BOOST_CHECK(ret_ite == realserver_list.end());
5494 BOOST_CHECK(realserver_list.empty());
5496 // unit_test [5] down_thread_realserver_disconnect_event not fond function error check
5497 std::cout << "[5] down_thread_realserver_disconnect_event not fond function error check" << std::endl;
5498 test_obj.down_thread_function_array_clear();
5499 proto_test.handle_realserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5500 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
5501 l7vs::Logger::putLogError_id = 0;
5502 test_obj.test_call();
5503 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
5504 BOOST_CHECK_EQUAL(75,l7vs::Logger::putLogError_id);
5505 std::cout << l7vs::Logger::putLogError_message << std::endl;
5507 // unit_test [6] down_thread_realserver_disconnect_event returnd illegal EVENT_TAG error check
5508 std::cout << "[6] down_thread_realserver_disconnect_event returnd illegal EVENT_TAG error check" << std::endl;
5509 test_obj.down_thread_module_event_map_clear();
5510 proto_test.handle_realserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5511 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
5512 l7vs::Logger::putLogError_id = 0;
5513 test_obj.test_call();
5514 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
5515 BOOST_CHECK_EQUAL(74,l7vs::Logger::putLogError_id);
5516 std::cout << l7vs::Logger::putLogError_message << std::endl;
5518 // mutex_lock_test test_lock_obj(vs,io);
5519 mutex_lock_test test_lock_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
5520 test_lock_obj.set_down_thread_realserver_disconnect_event_test();
5521 test_lock_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
5523 test_lock_obj.test_thread_wait.lock();
5524 test_lock_obj.befor_thread_id = proc_id;
5525 test_lock_obj.after_thread_id = proc_id;
5526 test_lock_obj.mutex_lock();
5528 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
5530 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
5531 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
5533 boost::thread::id test_id = test_thread.get_id();
5535 BOOST_CHECK(test_id != proc_id);
5538 test_lock_obj.test_thread_wait.unlock();
5541 // unit_test [7] down_thread_realserver_disconnect_event thread block test (mutex lock)
5542 std::cout << "[7] down_thread_realserver_disconnect_event thread block test (mutex lock)" << std::endl;
5543 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
5544 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
5546 test_lock_obj.mutex_unlock();
5549 // unit_test [8] down_thread_realserver_disconnect_event thread run test (mutex unlock)
5550 std::cout << "[8] down_thread_realserver_disconnect_event thread run test (mutex unlock)" << std::endl;
5551 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
5552 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
5554 BOOST_MESSAGE( "----- down_thread_realserver_disconnect_event test end -----" );
5557 // up_thread_sorryserver_disconnect_event test
5558 // up_thread_sorryserver_disconnect_event test class
5559 class up_thread_sorryserver_disconnect_event_test_class : public module_event_map_test_base_class{
5561 // up_thread_sorryserver_disconnect_event_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : module_event_map_test_base_class(vs,session_io){
5563 up_thread_sorryserver_disconnect_event_test_class(
5564 l7vs::virtualservice_tcp& vs,
5565 boost::asio::io_service& session_io,
5566 l7vs::tcp_socket_option_info& set_socket_option,
5567 boost::asio::ip::tcp::endpoint listen_endpoint,
5569 boost::asio::ssl::context& set_ssl_context,
5570 bool set_ssl_cache_flag,
5571 int set_ssl_handshake_time_out,
5572 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
5579 set_ssl_handshake_time_out,
5580 set_access_logger){};
5583 ~up_thread_sorryserver_disconnect_event_test_class(){};
5586 l7vs::tcp_session::up_thread_sorryserver_disconnect_event(LOCAL_PROC);
5590 void up_thread_sorryserver_disconnect_event_test(){
5592 BOOST_MESSAGE( "----- up_thread_sorryserver_disconnect_event_test test start -----" );
5594 boost::asio::io_service io;
5595 l7vs::virtualservice_tcp vs;
5596 l7vs::tcp_socket_option_info set_option;
5597 //! TCP_NODELAY (false:not set,true:set option)
5598 set_option.nodelay_opt = false;
5599 //! TCP_NODELAY option value (false:off,true:on)
5600 set_option.nodelay_val = false;
5601 //! TCP_CORK (false:not set,true:set option)
5602 set_option.cork_opt = false;
5603 //! TCP_CORK option value (false:off,true:on)
5604 set_option.cork_val = false;
5605 //! TCP_QUICKACK (false:not set,true:set option)
5606 set_option.quickack_opt = false;
5607 //! TCP_QUICKACK option value (false:off,true:on)
5608 set_option.quickack_val = false;
5610 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
5611 bool set_mode(false);
5612 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
5613 bool set_ssl_cache_flag(false);
5614 int set_ssl_handshake_time_out = 0;
5615 //std::string access_log_file_name = "test";
5616 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
5618 // up_thread_sorryserver_disconnect_event_test_class test_obj(vs,io);
5619 up_thread_sorryserver_disconnect_event_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
5625 std::string test_protocol_name("test protocol");
5626 l7vs::test_protocol_module proto_test(test_protocol_name);
5628 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
5630 l7vs::protocol_module_base::EVENT_TAG chek_event[13];
5631 chek_event[0] = l7vs::protocol_module_base::ACCEPT;
5632 chek_event[1] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
5633 chek_event[2] = l7vs::protocol_module_base::CLIENT_RECV;
5634 chek_event[3] = l7vs::protocol_module_base::CLIENT_RESPONSE_SEND;
5635 chek_event[4] = l7vs::protocol_module_base::REALSERVER_SELECT;
5636 chek_event[5] = l7vs::protocol_module_base::REALSERVER_CONNECT;
5637 chek_event[6] = l7vs::protocol_module_base::REALSERVER_SEND;
5638 chek_event[7] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
5639 chek_event[8] = l7vs::protocol_module_base::SORRYSERVER_SELECT;
5640 chek_event[9] = l7vs::protocol_module_base::SORRYSERVER_CONNECT;
5641 chek_event[10] = l7vs::protocol_module_base::SORRYSERVER_SEND;
5642 chek_event[11] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
5643 chek_event[12] = l7vs::protocol_module_base::FINALIZE;
5645 // unit_test [1] up_thread_sorryserver_disconnect_event up_thread_next_call_function update check
5646 std::cout << "[1] up_thread_sorryserver_disconnect_event up_thread_next_call_function update check" << std::endl;
5647 for(int i = 0; i < 13;i++){
5648 proto_test.handle_sorryserver_disconnect_res_tag = chek_event[i];
5649 test_obj.test_call();
5650 BOOST_CHECK(test_obj.chk_up_thread_next_call_function(chek_event[i]));
5653 // module parameter check
5654 boost::thread::id def_id;
5655 boost::thread::id proc_id = boost::this_thread::get_id();
5656 boost::asio::ip::tcp::endpoint test_end(boost::asio::ip::address::from_string("100.102.103.104"), 7777);
5657 l7vs::tcp_data test_message;
5658 test_message.set_endpoint(test_end);
5659 test_obj.set_up_thread_id(proc_id);
5660 test_obj.set_up_thread_message_data(test_message);
5661 proto_test.handle_sorryserver_disconnect_thread_id = def_id;
5662 proto_test.handle_sorryserver_disconnect_rs_endpoint = boost::asio::ip::tcp::endpoint();
5663 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5664 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_thread_id != proc_id);
5665 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_rs_endpoint != test_end);
5666 test_obj.test_call();
5667 // unit_test [2] up_thread_sorryserver_disconnect_event module parameter check thread id
5668 std::cout << "[2] up_thread_sorryserver_disconnect_event module parameter check thread id" << std::endl;
5669 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_thread_id == proc_id);
5671 // unit_test [3] up_thread_sorryserver_disconnect_event module parameter check endpoint
5672 std::cout << "[3] up_thread_sorryserver_disconnect_event module parameter check endpoint" << std::endl;
5673 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_rs_endpoint == test_end);
5675 // unit_test [4] up_thread_sorryserver_disconnect_event not fond function error check
5676 std::cout << "[4] up_thread_sorryserver_disconnect_event not fond function error check" << std::endl;
5677 test_obj.up_thread_function_array_clear();
5678 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5679 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
5680 l7vs::Logger::putLogError_id = 0;
5681 test_obj.test_call();
5682 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
5683 BOOST_CHECK_EQUAL(65,l7vs::Logger::putLogError_id);
5684 std::cout << l7vs::Logger::putLogError_message << std::endl;
5686 // unit_test [5] up_thread_sorryserver_disconnect_event returnd illegal EVENT_TAG error check
5687 std::cout << "[5] up_thread_sorryserver_disconnect_event returnd illegal EVENT_TAG error check" << std::endl;
5688 test_obj.up_thread_module_event_map_clear();
5689 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5690 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
5691 l7vs::Logger::putLogError_id = 0;
5692 test_obj.test_call();
5693 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
5694 BOOST_CHECK_EQUAL(64,l7vs::Logger::putLogError_id);
5695 std::cout << l7vs::Logger::putLogError_message << std::endl;
5697 // mutex_lock_test test_lock_obj(vs,io);
5698 mutex_lock_test test_lock_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
5699 test_lock_obj.set_up_thread_sorryserver_disconnect_event_test();
5700 test_lock_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
5702 test_lock_obj.test_thread_wait.lock();
5703 test_lock_obj.befor_thread_id = proc_id;
5704 test_lock_obj.after_thread_id = proc_id;
5705 test_lock_obj.mutex_lock();
5707 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
5709 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
5710 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
5712 boost::thread::id test_id = test_thread.get_id();
5714 BOOST_CHECK(test_id != proc_id);
5717 test_lock_obj.test_thread_wait.unlock();
5720 // unit_test [6] up_thread_sorryserver_disconnect_event thread block test (mutex lock)
5721 std::cout << "[6] up_thread_sorryserver_disconnect_event thread block test (mutex lock)" << std::endl;
5722 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
5723 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
5725 test_lock_obj.mutex_unlock();
5728 // unit_test [7] up_thread_sorryserver_disconnect_event thread run test (mutex unlock)
5729 std::cout << "[7] up_thread_sorryserver_disconnect_event thread run test (mutex unlock)" << std::endl;
5730 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
5731 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
5733 BOOST_MESSAGE( "----- up_thread_sorryserver_disconnect_event_test test end -----" );
5736 // up_thread_sorryserver_mod_disconnect test
5737 // up_thread_sorryserver_mod_disconnect test class
5738 class up_thread_sorryserver_mod_disconnect_test_class : public module_event_map_test_base_class{
5740 // up_thread_sorryserver_mod_disconnect_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : module_event_map_test_base_class(vs,session_io){
5742 up_thread_sorryserver_mod_disconnect_test_class(
5743 l7vs::virtualservice_tcp& vs,
5744 boost::asio::io_service& session_io,
5745 l7vs::tcp_socket_option_info& set_socket_option,
5746 boost::asio::ip::tcp::endpoint listen_endpoint,
5748 boost::asio::ssl::context& set_ssl_context,
5749 bool set_ssl_cache_flag,
5750 int set_ssl_handshake_time_out,
5751 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
5758 set_ssl_handshake_time_out,
5759 set_access_logger){};
5761 ~up_thread_sorryserver_mod_disconnect_test_class(){};
5764 l7vs::tcp_session::up_thread_sorryserver_mod_disconnect(LOCAL_PROC);
5767 boost::shared_ptr< l7vs::tcp_socket > get_sorry_socket(){
5768 return sorryserver_socket.second;
5771 boost::asio::ip::tcp::endpoint& get_sorry_endpoint(){
5772 return sorryserver_socket.first;
5777 void up_thread_sorryserver_mod_disconnect_test(){
5779 BOOST_MESSAGE( "----- up_thread_sorryserver_mod_disconnect test start -----" );
5781 boost::asio::io_service io;
5782 l7vs::virtualservice_tcp vs;
5783 l7vs::tcp_socket_option_info set_option;
5784 //! TCP_NODELAY (false:not set,true:set option)
5785 set_option.nodelay_opt = false;
5786 //! TCP_NODELAY option value (false:off,true:on)
5787 set_option.nodelay_val = false;
5788 //! TCP_CORK (false:not set,true:set option)
5789 set_option.cork_opt = false;
5790 //! TCP_CORK option value (false:off,true:on)
5791 set_option.cork_val = false;
5792 //! TCP_QUICKACK (false:not set,true:set option)
5793 set_option.quickack_opt = false;
5794 //! TCP_QUICKACK option value (false:off,true:on)
5795 set_option.quickack_val = false;
5797 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
5798 bool set_mode(false);
5799 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
5800 bool set_ssl_cache_flag(false);
5801 int set_ssl_handshake_time_out = 0;
5802 //std::string access_log_file_name = "test";
5803 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
5805 // up_thread_sorryserver_mod_disconnect_test_class test_obj(vs,io);
5806 up_thread_sorryserver_mod_disconnect_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
5809 std::string test_protocol_name("test protocol");
5810 l7vs::test_protocol_module proto_test(test_protocol_name);
5812 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
5814 l7vs::protocol_module_base::EVENT_TAG chek_event[13];
5815 chek_event[0] = l7vs::protocol_module_base::ACCEPT;
5816 chek_event[1] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
5817 chek_event[2] = l7vs::protocol_module_base::CLIENT_RECV;
5818 chek_event[3] = l7vs::protocol_module_base::CLIENT_RESPONSE_SEND;
5819 chek_event[4] = l7vs::protocol_module_base::REALSERVER_SELECT;
5820 chek_event[5] = l7vs::protocol_module_base::REALSERVER_CONNECT;
5821 chek_event[6] = l7vs::protocol_module_base::REALSERVER_SEND;
5822 chek_event[7] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
5823 chek_event[8] = l7vs::protocol_module_base::SORRYSERVER_SELECT;
5824 chek_event[9] = l7vs::protocol_module_base::SORRYSERVER_CONNECT;
5825 chek_event[10] = l7vs::protocol_module_base::SORRYSERVER_SEND;
5826 chek_event[11] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
5827 chek_event[12] = l7vs::protocol_module_base::FINALIZE;
5829 // unit_test [1] up_thread_sorryserver_mod_disconnect up_thread_next_call_function update check
5830 std::cout << "[1] up_thread_sorryserver_mod_disconnect up_thread_next_call_function update check" << std::endl;
5831 for(int i = 0; i < 13;i++){
5832 proto_test.handle_sorryserver_disconnect_res_tag = chek_event[i];
5833 test_obj.test_call();
5834 BOOST_CHECK(test_obj.chk_up_thread_next_call_function(chek_event[i]));
5837 // module parameter check
5838 boost::thread::id def_id;
5839 boost::thread::id proc_id = boost::this_thread::get_id();
5840 boost::asio::ip::tcp::endpoint test_end(boost::asio::ip::address::from_string("100.102.103.104"), 7777);
5841 test_obj.get_sorry_endpoint() = test_end;
5842 test_obj.set_up_thread_id(proc_id);
5843 proto_test.handle_sorryserver_disconnect_thread_id = def_id;
5844 proto_test.handle_sorryserver_disconnect_rs_endpoint = boost::asio::ip::tcp::endpoint();
5845 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5846 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_thread_id != proc_id);
5847 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_rs_endpoint != test_end);
5848 test_obj.get_sorry_socket()->close_call_check = false;
5849 test_obj.get_sorry_socket()->close_res = true;
5851 test_obj.test_call();
5853 // unit_test [2] up_thread_sorryserver_mod_disconnect socket close check
5854 std::cout << "[2] up_thread_sorryserver_mod_disconnect socket close check" << std::endl;
5855 BOOST_CHECK(test_obj.get_sorry_socket()->close_call_check);
5857 // unit_test [3] up_thread_sorryserver_mod_disconnect endpoint not update check
5858 std::cout << "[3] up_thread_sorryserver_mod_disconnect endpoint not update check" << std::endl;
5859 BOOST_CHECK(test_obj.get_sorry_endpoint() == test_end);
5861 // unit_test [4] up_thread_sorryserver_mod_disconnect module parameter check thread id
5862 std::cout << "[4] up_thread_sorryserver_mod_disconnect module parameter check thread id" << std::endl;
5863 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_thread_id == proc_id);
5865 // unit_test [5] up_thread_sorryserver_mod_disconnect module parameter check endpoint
5866 std::cout << "[5] up_thread_sorryserver_mod_disconnect module parameter check endpoint" << std::endl;
5867 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_rs_endpoint == test_end);
5870 proto_test.handle_sorryserver_disconnect_thread_id = def_id;
5871 proto_test.handle_sorryserver_disconnect_rs_endpoint = boost::asio::ip::tcp::endpoint();
5872 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5873 test_obj.get_sorry_socket()->close_call_check = false;
5874 test_obj.get_sorry_socket()->close_res = false;
5876 test_obj.test_call();
5878 // unit_test [6] up_thread_sorryserver_mod_disconnect socket close check
5879 std::cout << "[6] up_thread_sorryserver_mod_disconnect socket close check" << std::endl;
5880 BOOST_CHECK(test_obj.get_sorry_socket()->close_call_check);
5882 // unit_test [7] up_thread_sorryserver_mod_disconnect endpoint not update check
5883 std::cout << "[7] up_thread_sorryserver_mod_disconnect endpoint not update check" << std::endl;
5884 BOOST_CHECK(test_obj.get_sorry_endpoint() == boost::asio::ip::tcp::endpoint());
5886 // unit_test [8] up_thread_sorryserver_mod_disconnect module parameter check thread id
5887 std::cout << "[8] up_thread_sorryserver_mod_disconnect module parameter check thread id" << std::endl;
5888 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_thread_id == proc_id);
5890 // unit_test [9] up_thread_sorryserver_mod_disconnect module parameter check endpoint
5891 std::cout << "[9] up_thread_sorryserver_mod_disconnect module parameter check endpoint" << std::endl;
5892 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_rs_endpoint == test_end);
5894 proto_test.handle_sorryserver_disconnect_thread_id = def_id;
5895 proto_test.handle_sorryserver_disconnect_rs_endpoint = boost::asio::ip::tcp::endpoint();
5896 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5897 test_obj.get_sorry_socket()->close_call_check = false;
5898 test_obj.get_sorry_socket()->close_res = false;
5900 test_obj.test_call();
5902 // unit_test [10] up_thread_sorryserver_mod_disconnect socket close check
5903 std::cout << "[10] up_thread_sorryserver_mod_disconnect socket close check" << std::endl;
5904 BOOST_CHECK(test_obj.get_sorry_socket()->close_call_check);
5906 // unit_test [11] up_thread_sorryserver_mod_disconnect endpoint not update check
5907 std::cout << "[11] up_thread_sorryserver_mod_disconnect endpoint not update check" << std::endl;
5908 BOOST_CHECK(test_obj.get_sorry_endpoint() == boost::asio::ip::tcp::endpoint());
5910 // unit_test [12] up_thread_sorryserver_mod_disconnect module parameter check thread id
5911 std::cout << "[12] up_thread_sorryserver_mod_disconnect module parameter check thread id" << std::endl;
5912 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_thread_id == proc_id);
5914 // unit_test [13] up_thread_sorryserver_mod_disconnect module parameter check endpoint
5915 std::cout << "[13] up_thread_sorryserver_mod_disconnect module parameter check endpoint" << std::endl;
5916 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_rs_endpoint == boost::asio::ip::tcp::endpoint());
5918 // unit_test [14] up_thread_sorryserver_mod_disconnect not fond function error check
5919 std::cout << "[14] up_thread_sorryserver_mod_disconnect not fond function error check" << std::endl;
5920 test_obj.up_thread_function_array_clear();
5921 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5922 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
5923 l7vs::Logger::putLogError_id = 0;
5924 test_obj.test_call();
5925 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
5926 BOOST_CHECK_EQUAL(63,l7vs::Logger::putLogError_id);
5927 std::cout << l7vs::Logger::putLogError_message << std::endl;
5929 // unit_test [15] up_thread_sorryserver_mod_disconnect returnd illegal EVENT_TAG error check
5930 std::cout << "[15] up_thread_sorryserver_mod_disconnect returnd illegal EVENT_TAG error check" << std::endl;
5931 test_obj.up_thread_module_event_map_clear();
5932 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5933 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
5934 l7vs::Logger::putLogError_id = 0;
5935 test_obj.test_call();
5936 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
5937 BOOST_CHECK_EQUAL(62,l7vs::Logger::putLogError_id);
5938 std::cout << l7vs::Logger::putLogError_message << std::endl;
5940 // mutex_lock_test test_lock_obj(vs,io);
5941 mutex_lock_test test_lock_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
5942 test_lock_obj.set_up_thread_sorryserver_disconnect_event_test();
5943 test_lock_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
5945 test_lock_obj.test_thread_wait.lock();
5946 test_lock_obj.befor_thread_id = proc_id;
5947 test_lock_obj.after_thread_id = proc_id;
5948 test_lock_obj.mutex_lock();
5950 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
5952 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
5953 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
5955 boost::thread::id test_id = test_thread.get_id();
5957 BOOST_CHECK(test_id != proc_id);
5960 test_lock_obj.test_thread_wait.unlock();
5963 // unit_test [16] up_thread_sorryserver_mod_disconnect thread block test (mutex lock)
5964 std::cout << "[16] up_thread_sorryserver_mod_disconnect thread block test (mutex lock)" << std::endl;
5965 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
5966 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
5968 test_lock_obj.mutex_unlock();
5971 // unit_test [17] up_thread_sorryserver_mod_disconnect thread run test (mutex unlock)
5972 std::cout << "[17] up_thread_sorryserver_mod_disconnect thread run test (mutex unlock)" << std::endl;
5973 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
5974 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
5976 BOOST_MESSAGE( "----- up_thread_sorryserver_mod_disconnect test end -----" );
5979 // down_thread_sorryserver_mod_disconnect test
5980 // down_thread_sorryserver_mod_disconnect test class
5981 class down_thread_sorryserver_mod_disconnect_test_class : public module_event_map_test_base_class{
5983 // down_thread_sorryserver_mod_disconnect_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : module_event_map_test_base_class(vs,session_io){
5985 down_thread_sorryserver_mod_disconnect_test_class(
5986 l7vs::virtualservice_tcp& vs,
5987 boost::asio::io_service& session_io,
5988 l7vs::tcp_socket_option_info& set_socket_option,
5989 boost::asio::ip::tcp::endpoint listen_endpoint,
5991 boost::asio::ssl::context& set_ssl_context,
5992 bool set_ssl_cache_flag,
5993 int set_ssl_handshake_time_out,
5994 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
6001 set_ssl_handshake_time_out,
6002 set_access_logger){};
6005 ~down_thread_sorryserver_mod_disconnect_test_class(){};
6008 l7vs::tcp_session::down_thread_sorryserver_mod_disconnect(LOCAL_PROC);
6011 boost::shared_ptr< l7vs::tcp_socket > get_sorry_socket(){
6012 return sorryserver_socket.second;
6015 boost::asio::ip::tcp::endpoint& get_sorry_endpoint(){
6016 return sorryserver_socket.first;
6021 void down_thread_sorryserver_mod_disconnect_test(){
6023 BOOST_MESSAGE( "----- down_thread_sorryserver_mod_disconnect test start -----" );
6025 boost::asio::io_service io;
6026 l7vs::virtualservice_tcp vs;
6027 l7vs::tcp_socket_option_info set_option;
6028 //! TCP_NODELAY (false:not set,true:set option)
6029 set_option.nodelay_opt = false;
6030 //! TCP_NODELAY option value (false:off,true:on)
6031 set_option.nodelay_val = false;
6032 //! TCP_CORK (false:not set,true:set option)
6033 set_option.cork_opt = false;
6034 //! TCP_CORK option value (false:off,true:on)
6035 set_option.cork_val = false;
6036 //! TCP_QUICKACK (false:not set,true:set option)
6037 set_option.quickack_opt = false;
6038 //! TCP_QUICKACK option value (false:off,true:on)
6039 set_option.quickack_val = false;
6041 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
6042 bool set_mode(false);
6043 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
6044 bool set_ssl_cache_flag(false);
6045 int set_ssl_handshake_time_out = 0;
6046 //std::string access_log_file_name = "test";
6047 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
6049 // down_thread_sorryserver_mod_disconnect_test_class test_obj(vs,io);
6050 down_thread_sorryserver_mod_disconnect_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
6053 std::string test_protocol_name("test protocol");
6054 l7vs::test_protocol_module proto_test(test_protocol_name);
6056 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
6058 l7vs::protocol_module_base::EVENT_TAG chek_event[7];
6059 chek_event[0] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
6060 chek_event[1] = l7vs::protocol_module_base::CLIENT_CONNECTION_CHECK;
6061 chek_event[2] = l7vs::protocol_module_base::REALSERVER_RECV;
6062 chek_event[3] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
6063 chek_event[4] = l7vs::protocol_module_base::SORRYSERVER_RECV;
6064 chek_event[5] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
6065 chek_event[6] = l7vs::protocol_module_base::FINALIZE;
6067 // unit_test [1] down_thread_sorryserver_mod_disconnect down_thread_next_call_function update check
6068 std::cout << "[1] down_thread_sorryserver_mod_disconnect down_thread_next_call_function update check" << std::endl;
6069 for(int i = 0; i < 7;i++){
6070 proto_test.handle_sorryserver_disconnect_res_tag = chek_event[i];
6071 test_obj.test_call();
6072 BOOST_CHECK(test_obj.chk_down_thread_next_call_function(chek_event[i]));
6075 // module parameter check
6076 boost::thread::id def_id;
6077 boost::thread::id proc_id = boost::this_thread::get_id();
6078 boost::asio::ip::tcp::endpoint test_end(boost::asio::ip::address::from_string("100.102.103.104"), 7777);
6079 test_obj.get_sorry_endpoint() = test_end;
6080 test_obj.set_down_thread_id(proc_id);
6081 proto_test.handle_sorryserver_disconnect_thread_id = def_id;
6082 proto_test.handle_sorryserver_disconnect_rs_endpoint = boost::asio::ip::tcp::endpoint();
6083 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
6084 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_thread_id != proc_id);
6085 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_rs_endpoint != test_end);
6086 test_obj.get_sorry_socket()->close_call_check = false;
6087 test_obj.get_sorry_socket()->close_res = true;
6089 test_obj.test_call();
6091 // unit_test [2] down_thread_sorryserver_mod_disconnect socket close check
6092 std::cout << "[2] down_thread_sorryserver_mod_disconnect socket close check" << std::endl;
6093 BOOST_CHECK(test_obj.get_sorry_socket()->close_call_check);
6095 // unit_test [3] down_thread_sorryserver_mod_disconnect endpoint not update check
6096 std::cout << "[3] down_thread_sorryserver_mod_disconnect endpoint not update check" << std::endl;
6097 BOOST_CHECK(test_obj.get_sorry_endpoint() == test_end);
6099 // unit_test [4] down_thread_sorryserver_mod_disconnect module parameter check thread id
6100 std::cout << "[4] down_thread_sorryserver_mod_disconnect module parameter check thread id" << std::endl;
6101 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_thread_id == proc_id);
6103 // unit_test [5] down_thread_sorryserver_mod_disconnect module parameter check endpoint
6104 std::cout << "[5] down_thread_sorryserver_mod_disconnect module parameter check endpoint" << std::endl;
6105 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_rs_endpoint == test_end);
6107 proto_test.handle_sorryserver_disconnect_thread_id = def_id;
6108 proto_test.handle_sorryserver_disconnect_rs_endpoint = boost::asio::ip::tcp::endpoint();
6109 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
6110 test_obj.get_sorry_socket()->close_call_check = false;
6111 test_obj.get_sorry_socket()->close_res = false;
6113 test_obj.test_call();
6115 // unit_test [6] down_thread_sorryserver_mod_disconnect socket close check
6116 std::cout << "[6] down_thread_sorryserver_mod_disconnect socket close check" << std::endl;
6117 BOOST_CHECK(test_obj.get_sorry_socket()->close_call_check);
6119 // unit_test [7] down_thread_sorryserver_mod_disconnect endpoint not update check
6120 std::cout << "[7] down_thread_sorryserver_mod_disconnect endpoint not update check" << std::endl;
6121 BOOST_CHECK(test_obj.get_sorry_endpoint() == boost::asio::ip::tcp::endpoint());
6123 // unit_test [8] down_thread_sorryserver_mod_disconnect module parameter check thread id
6124 std::cout << "[8] down_thread_sorryserver_mod_disconnect module parameter check thread id" << std::endl;
6125 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_thread_id == proc_id);
6127 // unit_test [9] down_thread_sorryserver_mod_disconnect module parameter check endpoint
6128 std::cout << "[9] down_thread_sorryserver_mod_disconnect module parameter check endpoint" << std::endl;
6129 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_rs_endpoint == test_end);
6131 proto_test.handle_sorryserver_disconnect_thread_id = def_id;
6132 proto_test.handle_sorryserver_disconnect_rs_endpoint = boost::asio::ip::tcp::endpoint();
6133 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
6134 test_obj.get_sorry_socket()->close_call_check = false;
6135 test_obj.get_sorry_socket()->close_res = false;
6137 test_obj.test_call();
6139 // unit_test [10] down_thread_sorryserver_mod_disconnect socket close check
6140 std::cout << "[10] down_thread_sorryserver_mod_disconnect socket close check" << std::endl;
6141 BOOST_CHECK(test_obj.get_sorry_socket()->close_call_check);
6143 // unit_test [11] down_thread_sorryserver_mod_disconnect endpoint not update check
6144 std::cout << "[11] down_thread_sorryserver_mod_disconnect endpoint not update check" << std::endl;
6145 BOOST_CHECK(test_obj.get_sorry_endpoint() == boost::asio::ip::tcp::endpoint());
6147 // unit_test [12] down_thread_sorryserver_mod_disconnect module parameter check thread id
6148 std::cout << "[12] down_thread_sorryserver_mod_disconnect module parameter check thread id" << std::endl;
6149 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_thread_id == proc_id);
6151 // unit_test [13] down_thread_sorryserver_mod_disconnect module parameter check endpoint
6152 std::cout << "[13] down_thread_sorryserver_mod_disconnect module parameter check endpoint" << std::endl;
6153 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_rs_endpoint == boost::asio::ip::tcp::endpoint());
6155 // unit_test [14] down_thread_sorryserver_mod_disconnect not fond function error check
6156 std::cout << "[14] down_thread_sorryserver_mod_disconnect not fond function error check" << std::endl;
6157 test_obj.down_thread_function_array_clear();
6158 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
6159 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
6160 l7vs::Logger::putLogError_id = 0;
6161 test_obj.test_call();
6162 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
6163 BOOST_CHECK_EQUAL(93,l7vs::Logger::putLogError_id);
6164 std::cout << l7vs::Logger::putLogError_message << std::endl;
6166 // unit_test [15] down_thread_sorryserver_mod_disconnect returnd illegal EVENT_TAG error check
6167 std::cout << "[15] down_thread_sorryserver_mod_disconnect returnd illegal EVENT_TAG error check" << std::endl;
6168 test_obj.down_thread_module_event_map_clear();
6169 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
6170 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
6171 l7vs::Logger::putLogError_id = 0;
6172 test_obj.test_call();
6173 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
6174 BOOST_CHECK_EQUAL(92,l7vs::Logger::putLogError_id);
6175 std::cout << l7vs::Logger::putLogError_message << std::endl;
6177 // mutex_lock_test test_lock_obj(vs,io);
6178 mutex_lock_test test_lock_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
6179 test_lock_obj.set_down_thread_sorryserver_disconnect_event_test();
6180 test_lock_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
6182 test_lock_obj.test_thread_wait.lock();
6183 test_lock_obj.befor_thread_id = proc_id;
6184 test_lock_obj.after_thread_id = proc_id;
6185 test_lock_obj.mutex_lock();
6187 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
6189 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
6190 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
6192 boost::thread::id test_id = test_thread.get_id();
6194 BOOST_CHECK(test_id != proc_id);
6197 test_lock_obj.test_thread_wait.unlock();
6200 // unit_test [16] down_thread_sorryserver_mod_disconnect thread block test (mutex lock)
6201 std::cout << "[16] down_thread_sorryserver_mod_disconnect thread block test (mutex lock)" << std::endl;
6202 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
6203 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
6205 test_lock_obj.mutex_unlock();
6208 // unit_test [17] down_thread_sorryserver_mod_disconnect thread run test (mutex unlock)
6209 std::cout << "[17] down_thread_sorryserver_mod_disconnect thread run test (mutex unlock)" << std::endl;
6210 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
6211 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
6213 BOOST_MESSAGE( "----- down_thread_sorryserver_mod_disconnect test end -----" );
6218 // down_thread_sorryserver_disconnetc_event test
6219 // down_thread_sorryserver_disconnetc_event test class
6220 class down_thread_sorryserver_disconnect_event_test_class : public module_event_map_test_base_class{
6222 // down_thread_sorryserver_disconnect_event_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : module_event_map_test_base_class(vs,session_io){
6224 down_thread_sorryserver_disconnect_event_test_class(
6225 l7vs::virtualservice_tcp& vs,
6226 boost::asio::io_service& session_io,
6227 l7vs::tcp_socket_option_info& set_socket_option,
6228 boost::asio::ip::tcp::endpoint listen_endpoint,
6230 boost::asio::ssl::context& set_ssl_context,
6231 bool set_ssl_cache_flag,
6232 int set_ssl_handshake_time_out,
6233 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
6240 set_ssl_handshake_time_out,
6241 set_access_logger){};
6244 ~down_thread_sorryserver_disconnect_event_test_class(){};
6247 l7vs::tcp_session::down_thread_sorryserver_disconnect_event(LOCAL_PROC);
6251 void down_thread_sorryserver_disconnect_event_test(){
6253 BOOST_MESSAGE( "----- down_thread_sorryserver_disconnect_event test start -----" );
6255 boost::asio::io_service io;
6256 l7vs::virtualservice_tcp vs;
6257 l7vs::tcp_socket_option_info set_option;
6258 //! TCP_NODELAY (false:not set,true:set option)
6259 set_option.nodelay_opt = false;
6260 //! TCP_NODELAY option value (false:off,true:on)
6261 set_option.nodelay_val = false;
6262 //! TCP_CORK (false:not set,true:set option)
6263 set_option.cork_opt = false;
6264 //! TCP_CORK option value (false:off,true:on)
6265 set_option.cork_val = false;
6266 //! TCP_QUICKACK (false:not set,true:set option)
6267 set_option.quickack_opt = false;
6268 //! TCP_QUICKACK option value (false:off,true:on)
6269 set_option.quickack_val = false;
6271 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
6272 bool set_mode(false);
6273 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
6274 bool set_ssl_cache_flag(false);
6275 int set_ssl_handshake_time_out = 0;
6276 //std::string access_log_file_name = "test";
6277 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
6279 // down_thread_sorryserver_disconnect_event_test_class test_obj(vs,io);
6280 down_thread_sorryserver_disconnect_event_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
6282 std::string test_protocol_name("test protocol");
6283 l7vs::test_protocol_module proto_test(test_protocol_name);
6285 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
6287 l7vs::protocol_module_base::EVENT_TAG chek_event[7];
6288 chek_event[0] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
6289 chek_event[1] = l7vs::protocol_module_base::CLIENT_CONNECTION_CHECK;
6290 chek_event[2] = l7vs::protocol_module_base::REALSERVER_RECV;
6291 chek_event[3] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
6292 chek_event[4] = l7vs::protocol_module_base::SORRYSERVER_RECV;
6293 chek_event[5] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
6294 chek_event[6] = l7vs::protocol_module_base::FINALIZE;
6296 // unit_test [1] down_thread_sorryserver_disconnect_event down_thread_next_call_function update check
6297 std::cout << "[1] down_thread_sorryserver_disconnect_event down_thread_next_call_function update check" << std::endl;
6298 for(int i = 0; i < 7;i++){
6299 proto_test.handle_sorryserver_disconnect_res_tag = chek_event[i];
6300 test_obj.test_call();
6301 BOOST_CHECK(test_obj.chk_down_thread_next_call_function(chek_event[i]));
6304 // module parameter check
6305 boost::thread::id def_id;
6306 boost::thread::id proc_id = boost::this_thread::get_id();
6307 boost::asio::ip::tcp::endpoint test_end(boost::asio::ip::address::from_string("100.102.103.104"), 7777);
6308 l7vs::tcp_data test_message;
6309 test_message.set_endpoint(test_end);
6310 test_obj.set_down_thread_id(proc_id);
6311 test_obj.set_down_thread_message_data(test_message);
6312 proto_test.handle_sorryserver_disconnect_thread_id = def_id;
6313 proto_test.handle_sorryserver_disconnect_rs_endpoint = boost::asio::ip::tcp::endpoint();
6314 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
6315 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_thread_id != proc_id);
6316 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_rs_endpoint != test_end);
6317 test_obj.test_call();
6318 // unit_test [2] down_thread_sorryserver_disconnect_event module parameter check thread id
6319 std::cout << "[2] down_thread_sorryserver_disconnect_event module parameter check thread id" << std::endl;
6320 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_thread_id == proc_id);
6322 // unit_test [3] down_thread_sorryserver_disconnect_event module parameter check endpoint
6323 std::cout << "[3] down_thread_sorryserver_disconnect_event module parameter check endpoint" << std::endl;
6324 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_rs_endpoint == test_end);
6326 // unit_test [4] down_thread_sorryserver_disconnect_event not fond function error check
6327 std::cout << "[4] down_thread_sorryserver_disconnect_event not fond function error check" << std::endl;
6328 test_obj.down_thread_function_array_clear();
6329 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
6330 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
6331 l7vs::Logger::putLogError_id = 0;
6332 test_obj.test_call();
6333 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
6334 BOOST_CHECK_EQUAL(95,l7vs::Logger::putLogError_id);
6335 std::cout << l7vs::Logger::putLogError_message << std::endl;
6337 // unit_test [5] down_thread_sorryserver_disconnect_event returnd illegal EVENT_TAG error check
6338 std::cout << "[5] down_thread_sorryserver_disconnect_event returnd illegal EVENT_TAG error check" << std::endl;
6339 test_obj.down_thread_module_event_map_clear();
6340 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
6341 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
6342 l7vs::Logger::putLogError_id = 0;
6343 test_obj.test_call();
6344 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
6345 BOOST_CHECK_EQUAL(94,l7vs::Logger::putLogError_id);
6346 std::cout << l7vs::Logger::putLogError_message << std::endl;
6348 // mutex_lock_test test_lock_obj(vs,io);
6349 mutex_lock_test test_lock_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
6350 test_lock_obj.set_down_thread_sorryserver_disconnect_event_test();
6351 test_lock_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
6353 test_lock_obj.test_thread_wait.lock();
6354 test_lock_obj.befor_thread_id = proc_id;
6355 test_lock_obj.after_thread_id = proc_id;
6356 test_lock_obj.mutex_lock();
6358 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
6360 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
6361 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
6363 boost::thread::id test_id = test_thread.get_id();
6365 BOOST_CHECK(test_id != proc_id);
6368 test_lock_obj.test_thread_wait.unlock();
6371 // unit_test [6] down_thread_sorryserver_disconnect_event thread block test (mutex lock)
6372 std::cout << "[6] down_thread_sorryserver_disconnect_event thread block test (mutex lock)" << std::endl;
6373 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
6374 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
6376 test_lock_obj.mutex_unlock();
6379 // unit_test [7] down_thread_sorryserver_disconnect_event thread run test (mutex unlock)
6380 std::cout << "[7] down_thread_sorryserver_disconnect_event thread run test (mutex unlock)" << std::endl;
6381 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
6382 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
6384 BOOST_MESSAGE( "----- down_thread_sorryserver_disconnect_event test end -----" );
6387 // up_thread_sorry_enable_event test
6388 // up_thread_sorry_enable_event test class
6389 class up_thread_sorry_enable_event_test_class : public module_event_map_test_base_class{
6391 // up_thread_sorry_enable_event_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : module_event_map_test_base_class(vs,session_io){
6393 up_thread_sorry_enable_event_test_class(
6394 l7vs::virtualservice_tcp& vs,
6395 boost::asio::io_service& session_io,
6396 l7vs::tcp_socket_option_info& set_socket_option,
6397 boost::asio::ip::tcp::endpoint listen_endpoint,
6399 boost::asio::ssl::context& set_ssl_context,
6400 bool set_ssl_cache_flag,
6401 int set_ssl_handshake_time_out,
6402 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
6409 set_ssl_handshake_time_out,
6410 set_access_logger){};
6413 ~up_thread_sorry_enable_event_test_class(){};
6416 l7vs::tcp_session::up_thread_sorry_enable_event(LOCAL_PROC);
6420 void up_thread_sorry_enable_event_test(){
6422 BOOST_MESSAGE( "----- up_thread_sorry_enable_event test start -----" );
6424 boost::asio::io_service io;
6425 l7vs::virtualservice_tcp vs;
6426 l7vs::tcp_socket_option_info set_option;
6427 //! TCP_NODELAY (false:not set,true:set option)
6428 set_option.nodelay_opt = false;
6429 //! TCP_NODELAY option value (false:off,true:on)
6430 set_option.nodelay_val = false;
6431 //! TCP_CORK (false:not set,true:set option)
6432 set_option.cork_opt = false;
6433 //! TCP_CORK option value (false:off,true:on)
6434 set_option.cork_val = false;
6435 //! TCP_QUICKACK (false:not set,true:set option)
6436 set_option.quickack_opt = false;
6437 //! TCP_QUICKACK option value (false:off,true:on)
6438 set_option.quickack_val = false;
6440 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
6441 bool set_mode(false);
6442 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
6443 bool set_ssl_cache_flag(false);
6444 int set_ssl_handshake_time_out = 0;
6445 //std::string access_log_file_name = "test";
6446 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
6448 // up_thread_sorry_enable_event_test_class test_obj(vs,io);
6449 up_thread_sorry_enable_event_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
6452 std::string test_protocol_name("test protocol");
6453 l7vs::test_protocol_module proto_test(test_protocol_name);
6455 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
6457 l7vs::protocol_module_base::EVENT_TAG chek_event[13];
6458 chek_event[0] = l7vs::protocol_module_base::ACCEPT;
6459 chek_event[1] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
6460 chek_event[2] = l7vs::protocol_module_base::CLIENT_RECV;
6461 chek_event[3] = l7vs::protocol_module_base::CLIENT_RESPONSE_SEND;
6462 chek_event[4] = l7vs::protocol_module_base::REALSERVER_SELECT;
6463 chek_event[5] = l7vs::protocol_module_base::REALSERVER_CONNECT;
6464 chek_event[6] = l7vs::protocol_module_base::REALSERVER_SEND;
6465 chek_event[7] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
6466 chek_event[8] = l7vs::protocol_module_base::SORRYSERVER_SELECT;
6467 chek_event[9] = l7vs::protocol_module_base::SORRYSERVER_CONNECT;
6468 chek_event[10] = l7vs::protocol_module_base::SORRYSERVER_SEND;
6469 chek_event[11] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
6470 chek_event[12] = l7vs::protocol_module_base::FINALIZE;
6472 // unit_test [1] up_thread_sorry_enable_event up_thread_next_call_function update check
6473 std::cout << "[1] up_thread_sorry_enable_event up_thread_next_call_function update check" << std::endl;
6474 for(int i = 0; i < 13;i++){
6475 proto_test.handle_sorry_enable_res_tag = chek_event[i];
6476 test_obj.test_call();
6477 BOOST_CHECK(test_obj.chk_up_thread_next_call_function(chek_event[i]));
6480 // unit_test [2] up_thread_sorry_enable_event module parameter check thread id
6481 std::cout << "[2] up_thread_sorry_enable_event module parameter check thread id" << std::endl;
6482 boost::thread::id def_id;
6483 boost::thread::id proc_id = boost::this_thread::get_id();
6484 test_obj.set_up_thread_id(proc_id);
6485 proto_test.handle_sorry_enable_thread_id = def_id;
6486 proto_test.handle_sorry_enable_res_tag = l7vs::protocol_module_base::FINALIZE;
6487 BOOST_CHECK(proto_test.handle_sorry_enable_thread_id != proc_id);
6488 test_obj.test_call();
6489 BOOST_CHECK(proto_test.handle_sorry_enable_thread_id == proc_id);
6491 // unit_test [3] up_thread_sorry_enable_event not fond function error check
6492 std::cout << "[3] up_thread_sorry_enable_event not fond function error check" << std::endl;
6493 test_obj.up_thread_function_array_clear();
6494 proto_test.handle_sorry_enable_res_tag = l7vs::protocol_module_base::FINALIZE;
6495 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
6496 l7vs::Logger::putLogError_id = 0;
6497 test_obj.test_call();
6498 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
6499 BOOST_CHECK_EQUAL(67,l7vs::Logger::putLogError_id);
6500 std::cout << l7vs::Logger::putLogError_message << std::endl;
6502 // unit_test [4] up_thread_sorry_enable_event returnd illegal EVENT_TAG error check
6503 std::cout << "[4] up_thread_sorry_enable_event returnd illegal EVENT_TAG error check" << std::endl;
6504 test_obj.up_thread_module_event_map_clear();
6505 proto_test.handle_sorry_enable_res_tag = l7vs::protocol_module_base::FINALIZE;
6506 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
6507 l7vs::Logger::putLogError_id = 0;
6508 test_obj.test_call();
6509 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
6510 BOOST_CHECK_EQUAL(66,l7vs::Logger::putLogError_id);
6511 std::cout << l7vs::Logger::putLogError_message << std::endl;
6513 // mutex_lock_test test_lock_obj(vs,io);
6514 mutex_lock_test test_lock_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
6515 test_lock_obj.set_up_thread_sorry_enable_event_test();
6516 test_lock_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
6518 test_lock_obj.test_thread_wait.lock();
6519 test_lock_obj.befor_thread_id = proc_id;
6520 test_lock_obj.after_thread_id = proc_id;
6521 test_lock_obj.mutex_lock();
6523 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
6525 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
6526 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
6528 boost::thread::id test_id = test_thread.get_id();
6530 BOOST_CHECK(test_id != proc_id);
6533 test_lock_obj.test_thread_wait.unlock();
6536 // unit_test [5] up_thread_sorry_enable_event thread block test (mutex lock)
6537 std::cout << "[5] up_thread_sorry_enable_event thread block test (mutex lock)" << std::endl;
6538 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
6539 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
6541 test_lock_obj.mutex_unlock();
6544 // unit_test [6] up_thread_sorry_enable_event thread run test (mutex unlock)
6545 std::cout << "[6] up_thread_sorry_enable_event thread run test (mutex unlock)" << std::endl;
6546 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
6547 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
6549 BOOST_MESSAGE( "----- up_thread_sorry_enable_event test end -----" );
6552 // up_thread_sorry_disable_event test
6553 // up_thread_sorry_disable_event test class
6554 class up_thread_sorry_disable_event_test_class : public module_event_map_test_base_class{
6556 // up_thread_sorry_disable_event_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : module_event_map_test_base_class(vs,session_io){
6558 up_thread_sorry_disable_event_test_class(
6559 l7vs::virtualservice_tcp& vs,
6560 boost::asio::io_service& session_io,
6561 l7vs::tcp_socket_option_info& set_socket_option,
6562 boost::asio::ip::tcp::endpoint listen_endpoint,
6564 boost::asio::ssl::context& set_ssl_context,
6565 bool set_ssl_cache_flag,
6566 int set_ssl_handshake_time_out,
6567 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
6574 set_ssl_handshake_time_out,
6575 set_access_logger){};
6580 ~up_thread_sorry_disable_event_test_class(){};
6583 l7vs::tcp_session::up_thread_sorry_disable_event(LOCAL_PROC);
6587 void up_thread_sorry_disable_event_test(){
6589 BOOST_MESSAGE( "----- up_thread_sorry_disable_event test start -----" );
6591 boost::asio::io_service io;
6592 l7vs::virtualservice_tcp vs;
6593 l7vs::tcp_socket_option_info set_option;
6594 //! TCP_NODELAY (false:not set,true:set option)
6595 set_option.nodelay_opt = false;
6596 //! TCP_NODELAY option value (false:off,true:on)
6597 set_option.nodelay_val = false;
6598 //! TCP_CORK (false:not set,true:set option)
6599 set_option.cork_opt = false;
6600 //! TCP_CORK option value (false:off,true:on)
6601 set_option.cork_val = false;
6602 //! TCP_QUICKACK (false:not set,true:set option)
6603 set_option.quickack_opt = false;
6604 //! TCP_QUICKACK option value (false:off,true:on)
6605 set_option.quickack_val = false;
6607 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
6608 bool set_mode(false);
6609 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
6610 bool set_ssl_cache_flag(false);
6611 int set_ssl_handshake_time_out = 0;
6612 //std::string access_log_file_name = "test";
6613 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
6615 // up_thread_sorry_disable_event_test_class test_obj(vs,io);
6616 up_thread_sorry_disable_event_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
6620 std::string test_protocol_name("test protocol");
6621 l7vs::test_protocol_module proto_test(test_protocol_name);
6623 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
6625 l7vs::protocol_module_base::EVENT_TAG chek_event[13];
6626 chek_event[0] = l7vs::protocol_module_base::ACCEPT;
6627 chek_event[1] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
6628 chek_event[2] = l7vs::protocol_module_base::CLIENT_RECV;
6629 chek_event[3] = l7vs::protocol_module_base::CLIENT_RESPONSE_SEND;
6630 chek_event[4] = l7vs::protocol_module_base::REALSERVER_SELECT;
6631 chek_event[5] = l7vs::protocol_module_base::REALSERVER_CONNECT;
6632 chek_event[6] = l7vs::protocol_module_base::REALSERVER_SEND;
6633 chek_event[7] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
6634 chek_event[8] = l7vs::protocol_module_base::SORRYSERVER_SELECT;
6635 chek_event[9] = l7vs::protocol_module_base::SORRYSERVER_CONNECT;
6636 chek_event[10] = l7vs::protocol_module_base::SORRYSERVER_SEND;
6637 chek_event[11] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
6638 chek_event[12] = l7vs::protocol_module_base::FINALIZE;
6640 // unit_test [1] up_thread_sorry_disable_event up_thread_next_call_function update check
6641 std::cout << "[1] up_thread_sorry_disable_event up_thread_next_call_function update check" << std::endl;
6642 for(int i = 0; i < 13;i++){
6643 proto_test.handle_sorry_disable_res_tag = chek_event[i];
6644 test_obj.test_call();
6645 BOOST_CHECK(test_obj.chk_up_thread_next_call_function(chek_event[i]));
6648 // unit_test [2] up_thread_sorry_disable_event module parameter check thread id
6649 std::cout << "[2] up_thread_sorry_disable_event module parameter check thread id" << std::endl;
6650 boost::thread::id def_id;
6651 boost::thread::id proc_id = boost::this_thread::get_id();
6652 test_obj.set_up_thread_id(proc_id);
6653 proto_test.handle_sorry_disable_thread_id = def_id;
6654 proto_test.handle_sorry_disable_res_tag = l7vs::protocol_module_base::FINALIZE;
6655 BOOST_CHECK(proto_test.handle_sorry_disable_thread_id != proc_id);
6656 test_obj.test_call();
6657 BOOST_CHECK(proto_test.handle_sorry_disable_thread_id == proc_id);
6659 // unit_test [3] up_thread_sorry_disable_event not fond function error check
6660 std::cout << "[3] up_thread_sorry_disable_event not fond function error check" << std::endl;
6661 test_obj.up_thread_function_array_clear();
6662 proto_test.handle_sorry_disable_res_tag = l7vs::protocol_module_base::FINALIZE;
6663 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
6664 l7vs::Logger::putLogError_id = 0;
6665 test_obj.test_call();
6666 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
6667 BOOST_CHECK_EQUAL(69,l7vs::Logger::putLogError_id);
6668 std::cout << l7vs::Logger::putLogError_message << std::endl;
6670 // unit_test [4] up_thread_sorry_disable_event returnd illegal EVENT_TAG error check
6671 std::cout << "[4] up_thread_sorry_disable_event returnd illegal EVENT_TAG error check" << std::endl;
6672 test_obj.up_thread_module_event_map_clear();
6673 proto_test.handle_sorry_disable_res_tag = l7vs::protocol_module_base::FINALIZE;
6674 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
6675 l7vs::Logger::putLogError_id = 0;
6676 test_obj.test_call();
6677 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
6678 BOOST_CHECK_EQUAL(68,l7vs::Logger::putLogError_id);
6679 std::cout << l7vs::Logger::putLogError_message << std::endl;
6681 // mutex_lock_test test_lock_obj(vs,io);
6682 mutex_lock_test test_lock_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
6683 test_lock_obj.set_up_thread_sorry_disable_event_test();
6684 test_lock_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
6686 test_lock_obj.test_thread_wait.lock();
6687 test_lock_obj.befor_thread_id = proc_id;
6688 test_lock_obj.after_thread_id = proc_id;
6689 test_lock_obj.mutex_lock();
6691 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
6693 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
6694 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
6696 boost::thread::id test_id = test_thread.get_id();
6698 BOOST_CHECK(test_id != proc_id);
6701 test_lock_obj.test_thread_wait.unlock();
6704 // unit_test [5] up_thread_sorry_disable_event thread block test (mutex lock)
6705 std::cout << "[5] up_thread_sorry_disable_event thread block test (mutex lock)" << std::endl;
6706 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
6707 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
6709 test_lock_obj.mutex_unlock();
6712 // unit_test [6] up_thread_sorry_disable_event thread run test (mutex unlock)
6713 std::cout << "[6] up_thread_sorry_disable_event thread run test (mutex unlock)" << std::endl;
6714 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
6715 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
6717 BOOST_MESSAGE( "----- up_thread_sorry_disable_event test end -----" );
6721 // down_thread_sorry_enable_event test
6722 // dwon_thread_sorry_enable_event test class
6723 class down_thread_sorry_enable_event_test_class : public module_event_map_test_base_class{
6725 // down_thread_sorry_enable_event_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : module_event_map_test_base_class(vs,session_io){
6727 down_thread_sorry_enable_event_test_class(
6728 l7vs::virtualservice_tcp& vs,
6729 boost::asio::io_service& session_io,
6730 l7vs::tcp_socket_option_info& set_socket_option,
6731 boost::asio::ip::tcp::endpoint listen_endpoint,
6733 boost::asio::ssl::context& set_ssl_context,
6734 bool set_ssl_cache_flag,
6735 int set_ssl_handshake_time_out,
6736 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
6743 set_ssl_handshake_time_out,
6744 set_access_logger){};
6748 ~down_thread_sorry_enable_event_test_class(){};
6751 l7vs::tcp_session::down_thread_sorry_enable_event(LOCAL_PROC);
6755 void down_thread_sorry_enable_event_test(){
6757 BOOST_MESSAGE( "----- down_thread_sorry_enable_event test start -----" );
6759 boost::asio::io_service io;
6760 l7vs::virtualservice_tcp vs;
6761 l7vs::tcp_socket_option_info set_option;
6762 //! TCP_NODELAY (false:not set,true:set option)
6763 set_option.nodelay_opt = false;
6764 //! TCP_NODELAY option value (false:off,true:on)
6765 set_option.nodelay_val = false;
6766 //! TCP_CORK (false:not set,true:set option)
6767 set_option.cork_opt = false;
6768 //! TCP_CORK option value (false:off,true:on)
6769 set_option.cork_val = false;
6770 //! TCP_QUICKACK (false:not set,true:set option)
6771 set_option.quickack_opt = false;
6772 //! TCP_QUICKACK option value (false:off,true:on)
6773 set_option.quickack_val = false;
6775 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
6776 bool set_mode(false);
6777 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
6778 bool set_ssl_cache_flag(false);
6779 int set_ssl_handshake_time_out = 0;
6780 //std::string access_log_file_name = "test";
6781 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
6783 // down_thread_sorry_enable_event_test_class test_obj(vs,io);
6784 down_thread_sorry_enable_event_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
6786 std::string test_protocol_name("test protocol");
6787 l7vs::test_protocol_module proto_test(test_protocol_name);
6789 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
6791 l7vs::protocol_module_base::EVENT_TAG chek_event[7];
6792 chek_event[0] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
6793 chek_event[1] = l7vs::protocol_module_base::CLIENT_CONNECTION_CHECK;
6794 chek_event[2] = l7vs::protocol_module_base::REALSERVER_RECV;
6795 chek_event[3] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
6796 chek_event[4] = l7vs::protocol_module_base::SORRYSERVER_RECV;
6797 chek_event[5] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
6798 chek_event[6] = l7vs::protocol_module_base::FINALIZE;
6800 // unit_test [1] down_thread_sorry_enable_event up_thread_next_call_function update check
6801 std::cout << "[1] down_thread_sorry_enable_event up_thread_next_call_function update check" << std::endl;
6802 for(int i = 0; i < 7;i++){
6803 proto_test.handle_sorry_enable_res_tag = chek_event[i];
6804 test_obj.test_call();
6805 BOOST_CHECK(test_obj.chk_down_thread_next_call_function(chek_event[i]));
6808 // unit_test [2] down_thread_sorry_enable_event module parameter check thread id
6809 std::cout << "[2] down_thread_sorry_enable_event module parameter check thread id" << std::endl;
6810 boost::thread::id def_id;
6811 boost::thread::id proc_id = boost::this_thread::get_id();
6812 test_obj.set_down_thread_id(proc_id);
6813 proto_test.handle_sorry_enable_thread_id = def_id;
6814 proto_test.handle_sorry_enable_res_tag = l7vs::protocol_module_base::FINALIZE;
6815 BOOST_CHECK(proto_test.handle_sorry_enable_thread_id != proc_id);
6816 test_obj.test_call();
6817 BOOST_CHECK(proto_test.handle_sorry_enable_thread_id == proc_id);
6819 // unit_test [3] down_thread_sorry_enable_event not fond function error check
6820 std::cout << "[3] down_thread_sorry_enable_event not fond function error check" << std::endl;
6821 test_obj.down_thread_function_array_clear();
6822 proto_test.handle_sorry_enable_res_tag = l7vs::protocol_module_base::FINALIZE;
6823 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
6824 l7vs::Logger::putLogError_id = 0;
6825 test_obj.test_call();
6826 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
6827 BOOST_CHECK_EQUAL(97,l7vs::Logger::putLogError_id);
6828 std::cout << l7vs::Logger::putLogError_message << std::endl;
6830 // unit_test [4] down_thread_sorry_enable_event returnd illegal EVENT_TAG error check
6831 std::cout << "[4] down_thread_sorry_enable_event returnd illegal EVENT_TAG error check" << std::endl;
6832 test_obj.down_thread_module_event_map_clear();
6833 proto_test.handle_sorry_enable_res_tag = l7vs::protocol_module_base::FINALIZE;
6834 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
6835 l7vs::Logger::putLogError_id = 0;
6836 test_obj.test_call();
6837 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
6838 BOOST_CHECK_EQUAL(96,l7vs::Logger::putLogError_id);
6839 std::cout << l7vs::Logger::putLogError_message << std::endl;
6841 // mutex_lock_test test_lock_obj(vs,io);
6842 mutex_lock_test test_lock_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
6843 test_lock_obj.set_down_thread_sorry_enable_event_test();
6844 test_lock_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
6847 test_lock_obj.test_thread_wait.lock();
6848 test_lock_obj.befor_thread_id = proc_id;
6849 test_lock_obj.after_thread_id = proc_id;
6850 test_lock_obj.mutex_lock();
6852 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
6854 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
6855 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
6857 boost::thread::id test_id = test_thread.get_id();
6859 BOOST_CHECK(test_id != proc_id);
6862 test_lock_obj.test_thread_wait.unlock();
6865 // unit_test [5] down_thread_sorry_enable_event thread block test (mutex lock)
6866 std::cout << "[5] down_thread_sorry_enable_event thread block test (mutex lock)" << std::endl;
6867 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
6868 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
6870 test_lock_obj.mutex_unlock();
6873 // unit_test [6] down_thread_sorry_enable_event thread run test (mutex unlock)
6874 std::cout << "[6] down_thread_sorry_enable_event thread run test (mutex unlock)" << std::endl;
6875 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
6876 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
6878 BOOST_MESSAGE( "----- down_thread_sorry_enable_event test end -----" );
6880 // down_thread_sorry_disable_event test
6881 // dwon_thread_sorry_disable_event test class
6882 class down_thread_sorry_disable_event_test_class : public module_event_map_test_base_class{
6884 // down_thread_sorry_disable_event_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : module_event_map_test_base_class(vs,session_io){
6886 down_thread_sorry_disable_event_test_class(
6887 l7vs::virtualservice_tcp& vs,
6888 boost::asio::io_service& session_io,
6889 l7vs::tcp_socket_option_info& set_socket_option,
6890 boost::asio::ip::tcp::endpoint listen_endpoint,
6892 boost::asio::ssl::context& set_ssl_context,
6893 bool set_ssl_cache_flag,
6894 int set_ssl_handshake_time_out,
6895 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
6902 set_ssl_handshake_time_out,
6903 set_access_logger){};
6906 ~down_thread_sorry_disable_event_test_class(){};
6909 l7vs::tcp_session::down_thread_sorry_disable_event(LOCAL_PROC);
6913 void down_thread_sorry_disable_event_test(){
6915 BOOST_MESSAGE( "----- down_thread_sorry_disable_event test start -----" );
6917 boost::asio::io_service io;
6918 l7vs::virtualservice_tcp vs;
6919 l7vs::tcp_socket_option_info set_option;
6920 //! TCP_NODELAY (false:not set,true:set option)
6921 set_option.nodelay_opt = false;
6922 //! TCP_NODELAY option value (false:off,true:on)
6923 set_option.nodelay_val = false;
6924 //! TCP_CORK (false:not set,true:set option)
6925 set_option.cork_opt = false;
6926 //! TCP_CORK option value (false:off,true:on)
6927 set_option.cork_val = false;
6928 //! TCP_QUICKACK (false:not set,true:set option)
6929 set_option.quickack_opt = false;
6930 //! TCP_QUICKACK option value (false:off,true:on)
6931 set_option.quickack_val = false;
6933 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
6934 bool set_mode(false);
6935 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
6936 bool set_ssl_cache_flag(false);
6937 int set_ssl_handshake_time_out = 0;
6938 //std::string access_log_file_name = "test";
6939 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
6941 // down_thread_sorry_disable_event_test_class test_obj(vs,io);
6942 down_thread_sorry_disable_event_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
6945 std::string test_protocol_name("test protocol");
6946 l7vs::test_protocol_module proto_test(test_protocol_name);
6948 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
6950 l7vs::protocol_module_base::EVENT_TAG chek_event[7];
6951 chek_event[0] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
6952 chek_event[1] = l7vs::protocol_module_base::CLIENT_CONNECTION_CHECK;
6953 chek_event[2] = l7vs::protocol_module_base::REALSERVER_RECV;
6954 chek_event[3] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
6955 chek_event[4] = l7vs::protocol_module_base::SORRYSERVER_RECV;
6956 chek_event[5] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
6957 chek_event[6] = l7vs::protocol_module_base::FINALIZE;
6959 // unit_test [1] down_thread_sorry_disable_event up_thread_next_call_function update check
6960 std::cout << "[1] down_thread_sorry_disable_event up_thread_next_call_function update check" << std::endl;
6961 for(int i = 0; i < 7;i++){
6962 proto_test.handle_sorry_disable_res_tag = chek_event[i];
6963 test_obj.test_call();
6964 BOOST_CHECK(test_obj.chk_down_thread_next_call_function(chek_event[i]));
6967 // unit_test [2] down_thread_sorry_disable_event module parameter check thread id
6968 std::cout << "[2] down_thread_sorry_disable_event module parameter check thread id" << std::endl;
6969 boost::thread::id def_id;
6970 boost::thread::id proc_id = boost::this_thread::get_id();
6971 test_obj.set_down_thread_id(proc_id);
6972 proto_test.handle_sorry_disable_thread_id = def_id;
6973 proto_test.handle_sorry_disable_res_tag = l7vs::protocol_module_base::FINALIZE;
6974 BOOST_CHECK(proto_test.handle_sorry_disable_thread_id != proc_id);
6975 test_obj.test_call();
6976 BOOST_CHECK(proto_test.handle_sorry_disable_thread_id == proc_id);
6978 // unit_test [3] down_thread_sorry_disable_event not fond function error check
6979 std::cout << "[3] down_thread_sorry_disable_event not fond function error check" << std::endl;
6980 test_obj.down_thread_function_array_clear();
6981 proto_test.handle_sorry_disable_res_tag = l7vs::protocol_module_base::FINALIZE;
6982 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
6983 l7vs::Logger::putLogError_id = 0;
6984 test_obj.test_call();
6985 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
6986 BOOST_CHECK_EQUAL(99,l7vs::Logger::putLogError_id);
6987 std::cout << l7vs::Logger::putLogError_message << std::endl;
6989 // unit_test [4] down_thread_sorry_disable_event returnd illegal EVENT_TAG error check
6990 std::cout << "[4] down_thread_sorry_disable_event returnd illegal EVENT_TAG error check" << std::endl;
6991 test_obj.down_thread_module_event_map_clear();
6992 proto_test.handle_sorry_disable_res_tag = l7vs::protocol_module_base::FINALIZE;
6993 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
6994 l7vs::Logger::putLogError_id = 0;
6995 test_obj.test_call();
6996 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
6997 BOOST_CHECK_EQUAL(98,l7vs::Logger::putLogError_id);
6998 std::cout << l7vs::Logger::putLogError_message << std::endl;
7000 // mutex_lock_test test_lock_obj(vs,io);
7001 mutex_lock_test test_lock_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
7002 test_lock_obj.set_down_thread_sorry_disable_event_test();
7003 test_lock_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
7005 test_lock_obj.test_thread_wait.lock();
7006 test_lock_obj.befor_thread_id = proc_id;
7007 test_lock_obj.after_thread_id = proc_id;
7008 test_lock_obj.mutex_lock();
7010 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
7012 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
7013 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
7015 boost::thread::id test_id = test_thread.get_id();
7017 BOOST_CHECK(test_id != proc_id);
7020 test_lock_obj.test_thread_wait.unlock();
7023 // unit_test [5] down_thread_sorry_disable_event thread block test (mutex lock)
7024 std::cout << "[5] down_thread_sorry_disable_event thread block test (mutex lock)" << std::endl;
7025 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
7026 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
7028 test_lock_obj.mutex_unlock();
7031 // unit_test [6] down_thread_sorry_disable_event thread run test (mutex unlock)
7032 std::cout << "[6] down_thread_sorry_disable_event thread run test (mutex unlock)" << std::endl;
7033 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
7034 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
7036 BOOST_MESSAGE( "----- down_thread_sorry_disable_event test end -----" );
7039 // up_thread_client_accept_event test
7040 // up_thread_client_accept_event test class
7041 class up_thread_client_accept_event_test_class : public module_event_map_test_base_class{
7043 // up_thread_client_accept_event_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : module_event_map_test_base_class(vs,session_io){
7045 up_thread_client_accept_event_test_class(
7046 l7vs::virtualservice_tcp& vs,
7047 boost::asio::io_service& session_io,
7048 l7vs::tcp_socket_option_info& set_socket_option,
7049 boost::asio::ip::tcp::endpoint listen_endpoint,
7051 boost::asio::ssl::context& set_ssl_context,
7052 bool set_ssl_cache_flag,
7053 int set_ssl_handshake_time_out,
7054 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
7061 set_ssl_handshake_time_out,
7062 set_access_logger){};
7065 ~up_thread_client_accept_event_test_class(){};
7068 l7vs::tcp_session::up_thread_client_accept_event(LOCAL_PROC);
7072 void up_thread_client_accept_event_test(){
7074 BOOST_MESSAGE( "----- up_thread_client_accept_event test start -----" );
7076 boost::asio::io_service io;
7077 l7vs::virtualservice_tcp vs;
7078 l7vs::tcp_socket_option_info set_option;
7079 //! TCP_NODELAY (false:not set,true:set option)
7080 set_option.nodelay_opt = false;
7081 //! TCP_NODELAY option value (false:off,true:on)
7082 set_option.nodelay_val = false;
7083 //! TCP_CORK (false:not set,true:set option)
7084 set_option.cork_opt = false;
7085 //! TCP_CORK option value (false:off,true:on)
7086 set_option.cork_val = false;
7087 //! TCP_QUICKACK (false:not set,true:set option)
7088 set_option.quickack_opt = false;
7089 //! TCP_QUICKACK option value (false:off,true:on)
7090 set_option.quickack_val = false;
7092 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
7093 bool set_mode(false);
7094 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
7095 bool set_ssl_cache_flag(false);
7096 int set_ssl_handshake_time_out = 0;
7097 //std::string access_log_file_name = "test";
7098 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
7100 // up_thread_client_accept_event_test_class test_obj(vs,io);
7101 up_thread_client_accept_event_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
7103 std::string test_protocol_name("test protocol");
7104 l7vs::test_protocol_module proto_test(test_protocol_name);
7106 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
7108 l7vs::protocol_module_base::EVENT_TAG chek_event[13];
7109 chek_event[0] = l7vs::protocol_module_base::ACCEPT;
7110 chek_event[1] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
7111 chek_event[2] = l7vs::protocol_module_base::CLIENT_RECV;
7112 chek_event[3] = l7vs::protocol_module_base::CLIENT_RESPONSE_SEND;
7113 chek_event[4] = l7vs::protocol_module_base::REALSERVER_SELECT;
7114 chek_event[5] = l7vs::protocol_module_base::REALSERVER_CONNECT;
7115 chek_event[6] = l7vs::protocol_module_base::REALSERVER_SEND;
7116 chek_event[7] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
7117 chek_event[8] = l7vs::protocol_module_base::SORRYSERVER_SELECT;
7118 chek_event[9] = l7vs::protocol_module_base::SORRYSERVER_CONNECT;
7119 chek_event[10] = l7vs::protocol_module_base::SORRYSERVER_SEND;
7120 chek_event[11] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
7121 chek_event[12] = l7vs::protocol_module_base::FINALIZE;
7123 // unit_test [1] up_thread_client_accept_event up_thread_next_call_function update check
7124 std::cout << "[1] up_thread_client_accept_event up_thread_next_call_function update check" << std::endl;
7125 for(int i = 0; i < 13;i++){
7126 proto_test.handle_accept_res_tag = chek_event[i];
7127 test_obj.test_call();
7128 BOOST_CHECK(test_obj.chk_up_thread_next_call_function(chek_event[i]));
7131 // unit_test [2] up_thread_client_accept_event module parameter check thread id
7132 std::cout << "[2] up_thread_client_accept_event module parameter check thread id" << std::endl;
7133 boost::thread::id def_id;
7134 boost::thread::id proc_id = boost::this_thread::get_id();
7135 test_obj.set_up_thread_id(proc_id);
7136 proto_test.handle_accept_in_thread_id = def_id;
7137 proto_test.handle_accept_res_tag = l7vs::protocol_module_base::FINALIZE;
7138 BOOST_CHECK(proto_test.handle_accept_in_thread_id != proc_id);
7139 test_obj.test_call();
7140 BOOST_CHECK(proto_test.handle_accept_in_thread_id == proc_id);
7142 // unit_test [3] up_thread_client_accept_event not fond function error check
7143 std::cout << "[3] up_thread_client_accept_event not fond function error check" << std::endl;
7144 test_obj.up_thread_function_array_clear();
7145 proto_test.handle_accept_res_tag = l7vs::protocol_module_base::FINALIZE;
7146 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
7147 l7vs::Logger::putLogError_id = 0;
7148 test_obj.test_call();
7149 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
7150 BOOST_CHECK_EQUAL(19,l7vs::Logger::putLogError_id);
7151 std::cout << l7vs::Logger::putLogError_message << std::endl;
7153 // unit_test [4] up_thread_client_accept_event returnd illegal EVENT_TAG error check
7154 std::cout << "[4] up_thread_client_accept_event returnd illegal EVENT_TAG error check" << std::endl;
7155 test_obj.up_thread_module_event_map_clear();
7156 proto_test.handle_accept_res_tag = l7vs::protocol_module_base::FINALIZE;
7157 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
7158 l7vs::Logger::putLogError_id = 0;
7159 test_obj.test_call();
7160 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
7161 BOOST_CHECK_EQUAL(18,l7vs::Logger::putLogError_id);
7162 std::cout << l7vs::Logger::putLogError_message << std::endl;
7164 BOOST_MESSAGE( "----- up_thread_client_accept_event test end -----" );
7169 // up_thread_client_respond test
7170 // up_thread_client_respond test class
7171 class up_thread_client_respond_test_class : public l7vs::tcp_session{
7173 // up_thread_client_respond_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){
7175 up_thread_client_respond_test_class(
7176 l7vs::virtualservice_tcp& vs,
7177 boost::asio::io_service& session_io,
7178 l7vs::tcp_socket_option_info& set_socket_option,
7179 boost::asio::ip::tcp::endpoint listen_endpoint,
7181 boost::asio::ssl::context& set_ssl_context,
7182 bool set_ssl_cache_flag,
7183 int set_ssl_handshake_time_out,
7184 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
7191 set_ssl_handshake_time_out,
7192 set_access_logger){};
7195 ~up_thread_client_respond_test_class(){};
7198 l7vs::tcp_session::up_thread_client_respond(LOCAL_PROC);
7201 l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_up_thread_message_que(){
7202 return up_thread_message_que;
7205 l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_down_thread_message_que(){
7206 return down_thread_message_que;
7209 void up_thread_function_array_clear(){
7210 for(int i = 0;i <= UP_FUNC_EXIT;i++){
7211 up_thread_function_array[i].second = NULL;
7214 void up_thread_message_down_thread_function_map_clear(){
7215 up_thread_message_down_thread_function_map.clear();
7218 void up_thread_client_respond_event(const TCP_PROCESS_TYPE_TAG process_type){
7219 up_thread_client_respond_event_call_chek = true;
7221 bool up_thread_client_respond_event_call_chek;
7223 void down_thread_client_respond_event(const TCP_PROCESS_TYPE_TAG process_type){
7224 down_thread_client_respond_event_call_chek = true;
7226 bool down_thread_client_respond_event_call_chek;
7228 void up_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
7229 up_thread_exit_call_chek = true;
7231 bool up_thread_exit_call_chek;
7233 void up_thread_client_respond_test(){
7234 BOOST_MESSAGE( "----- up_thread_client_respond test start -----" );
7235 // boost::asio::io_service io;
7236 // l7vs::virtualservice_tcp vs;
7237 // up_thread_client_respond_test_class test_obj(vs,io);
7239 l7vs::virtualservice_tcp vs;
7240 boost::asio::io_service io;
7241 l7vs::tcp_socket_option_info set_option;
7242 //! TCP_NODELAY (false:not set,true:set option)
7243 set_option.nodelay_opt = false;
7244 //! TCP_NODELAY option value (false:off,true:on)
7245 set_option.nodelay_val = false;
7246 //! TCP_CORK (false:not set,true:set option)
7247 set_option.cork_opt = false;
7248 //! TCP_CORK option value (false:off,true:on)
7249 set_option.cork_val = false;
7250 //! TCP_QUICKACK (false:not set,true:set option)
7251 set_option.quickack_opt = false;
7252 //! TCP_QUICKACK option value (false:off,true:on)
7253 set_option.quickack_val = false;
7255 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
7256 bool set_mode(false);
7257 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
7258 bool set_ssl_cache_flag(false);
7259 int set_ssl_handshake_time_out = 0;
7260 //std::string access_log_file_name = "test";
7261 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
7263 up_thread_client_respond_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
7267 l7vs::lockfree_queue<l7vs::tcp_thread_message>& up_thread_message_que = test_obj.get_up_thread_message_que();
7268 l7vs::lockfree_queue<l7vs::tcp_thread_message>& down_thread_message_que = test_obj.get_down_thread_message_que();
7270 BOOST_CHECK(up_thread_message_que.empty());
7271 BOOST_CHECK(down_thread_message_que.empty());
7273 test_obj.test_call();
7275 // unit_test [1] up_thread_client_respond up thread message set check
7276 std::cout << "[1] up_thread_client_respond up thread message set check" << std::endl;
7277 BOOST_CHECK(!up_thread_message_que.empty());
7278 l7vs::tcp_thread_message* up_msg = up_thread_message_que.pop();
7279 BOOST_CHECK(up_thread_message_que.empty());
7280 test_obj.up_thread_client_respond_event_call_chek = false;
7281 up_msg->message(l7vs::tcp_session::MESSAGE_PROC);
7282 BOOST_CHECK(test_obj.up_thread_client_respond_event_call_chek);
7285 // unit_test [2] up_thread_client_respond down thread message set check
7286 std::cout << "[2] up_thread_client_respond down thread message set check" << std::endl;
7287 BOOST_CHECK(!down_thread_message_que.empty());
7288 l7vs::tcp_thread_message* down_msg = down_thread_message_que.pop();
7289 BOOST_CHECK(down_thread_message_que.empty());
7290 test_obj.down_thread_client_respond_event_call_chek = false;
7291 down_msg->message(l7vs::tcp_session::MESSAGE_PROC);
7292 BOOST_CHECK(test_obj.down_thread_client_respond_event_call_chek);
7295 // unit_test [3] up_thread_client_respond not fond down_thread_client_respond_event function error check
7296 std::cout << "[3] up_thread_client_respond not fond down_thread_client_respond_event function error check" << std::endl;
7297 test_obj.up_thread_message_down_thread_function_map_clear();
7298 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
7299 l7vs::Logger::putLogError_id = 0;
7300 test_obj.up_thread_exit_call_chek = false;
7301 test_obj.test_call();
7302 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
7303 BOOST_CHECK_EQUAL(23,l7vs::Logger::putLogError_id);
7304 std::cout << l7vs::Logger::putLogError_message << std::endl;
7305 BOOST_CHECK(test_obj.up_thread_exit_call_chek);
7307 // unit_test [4] up_thread_client_respond not fond up_thread_client_respond_event function error check
7308 std::cout << "[4] up_thread_client_respond not fond up_thread_client_respond_event function error check" << std::endl;
7309 test_obj.up_thread_function_array_clear();
7310 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
7311 l7vs::Logger::putLogError_id = 0;
7312 test_obj.up_thread_exit_call_chek = false;
7313 test_obj.test_call();
7314 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
7315 BOOST_CHECK_EQUAL(22,l7vs::Logger::putLogError_id);
7316 std::cout << l7vs::Logger::putLogError_message << std::endl;
7317 BOOST_CHECK(test_obj.up_thread_exit_call_chek);
7319 BOOST_MESSAGE( "----- up_thread_client_respond test end -----" );
7323 // up_thread_client_respond_event test
7324 // up_thread_client_respond_event test class
7325 class up_thread_client_respond_event_test_class : public module_event_map_test_base_class{
7327 // up_thread_client_respond_event_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : module_event_map_test_base_class(vs,session_io){
7329 up_thread_client_respond_event_test_class(
7330 l7vs::virtualservice_tcp& vs,
7331 boost::asio::io_service& session_io,
7332 l7vs::tcp_socket_option_info& set_socket_option,
7333 boost::asio::ip::tcp::endpoint listen_endpoint,
7335 boost::asio::ssl::context& set_ssl_context,
7336 bool set_ssl_cache_flag,
7337 int set_ssl_handshake_time_out,
7338 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
7345 set_ssl_handshake_time_out,
7346 set_access_logger){};
7349 ~up_thread_client_respond_event_test_class(){};
7352 l7vs::tcp_session::up_thread_client_respond_event(LOCAL_PROC);
7356 void up_thread_client_respond_event_test(){
7358 BOOST_MESSAGE( "----- up_thread_client_respond_event test start -----" );
7360 // boost::asio::io_service io;
7361 // l7vs::virtualservice_tcp vs;
7362 // up_thread_client_respond_event_test_class test_obj(vs,io);
7363 l7vs::virtualservice_tcp vs;
7364 boost::asio::io_service io;
7365 l7vs::tcp_socket_option_info set_option;
7366 //! TCP_NODELAY (false:not set,true:set option)
7367 set_option.nodelay_opt = false;
7368 //! TCP_NODELAY option value (false:off,true:on)
7369 set_option.nodelay_val = false;
7370 //! TCP_CORK (false:not set,true:set option)
7371 set_option.cork_opt = false;
7372 //! TCP_CORK option value (false:off,true:on)
7373 set_option.cork_val = false;
7374 //! TCP_QUICKACK (false:not set,true:set option)
7375 set_option.quickack_opt = false;
7376 //! TCP_QUICKACK option value (false:off,true:on)
7377 set_option.quickack_val = false;
7379 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
7380 bool set_mode(false);
7381 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
7382 bool set_ssl_cache_flag(false);
7383 int set_ssl_handshake_time_out = 0;
7384 //std::string access_log_file_name = "test";
7385 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
7387 up_thread_client_respond_event_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
7390 std::string test_protocol_name("test protocol");
7391 l7vs::test_protocol_module proto_test(test_protocol_name);
7393 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
7395 l7vs::protocol_module_base::EVENT_TAG chek_event[13];
7396 chek_event[0] = l7vs::protocol_module_base::ACCEPT;
7397 chek_event[1] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
7398 chek_event[2] = l7vs::protocol_module_base::CLIENT_RECV;
7399 chek_event[3] = l7vs::protocol_module_base::CLIENT_RESPONSE_SEND;
7400 chek_event[4] = l7vs::protocol_module_base::REALSERVER_SELECT;
7401 chek_event[5] = l7vs::protocol_module_base::REALSERVER_CONNECT;
7402 chek_event[6] = l7vs::protocol_module_base::REALSERVER_SEND;
7403 chek_event[7] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
7404 chek_event[8] = l7vs::protocol_module_base::SORRYSERVER_SELECT;
7405 chek_event[9] = l7vs::protocol_module_base::SORRYSERVER_CONNECT;
7406 chek_event[10] = l7vs::protocol_module_base::SORRYSERVER_SEND;
7407 chek_event[11] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
7408 chek_event[12] = l7vs::protocol_module_base::FINALIZE;
7410 // unit_test [1] up_thread_client_respond_event up_thread_next_call_function update check
7411 std::cout << "[1] up_thread_client_respond_event up_thread_next_call_function update check" << std::endl;
7412 for(int i = 0; i < 13;i++){
7413 proto_test.handle_response_send_inform_res_tag = chek_event[i];
7414 test_obj.test_call();
7415 BOOST_CHECK(test_obj.chk_up_thread_next_call_function(chek_event[i]));
7418 // unit_test [2] up_thread_client_respond_event module parameter check thread id
7419 std::cout << "[2] up_thread_client_respond_event module parameter check thread id" << std::endl;
7420 boost::thread::id def_id;
7421 boost::thread::id proc_id = boost::this_thread::get_id();
7422 test_obj.set_up_thread_id(proc_id);
7423 proto_test.handle_response_send_inform_thread_id = def_id;
7424 proto_test.handle_response_send_inform_res_tag = l7vs::protocol_module_base::FINALIZE;
7425 BOOST_CHECK(proto_test.handle_response_send_inform_thread_id != proc_id);
7426 test_obj.test_call();
7427 BOOST_CHECK(proto_test.handle_response_send_inform_thread_id == proc_id);
7429 // unit_test [3] up_thread_client_respond_event not fond function error check
7430 std::cout << "[3] up_thread_client_respond_event not fond function error check" << std::endl;
7431 test_obj.up_thread_function_array_clear();
7432 proto_test.handle_response_send_inform_res_tag = l7vs::protocol_module_base::FINALIZE;
7433 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
7434 l7vs::Logger::putLogError_id = 0;
7435 test_obj.test_call();
7436 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
7437 BOOST_CHECK_EQUAL(25,l7vs::Logger::putLogError_id);
7438 std::cout << l7vs::Logger::putLogError_message << std::endl;
7440 // unit_test [4] up_thread_client_respond_event returnd illegal EVENT_TAG error check
7441 std::cout << "[4] up_thread_client_respond_event returnd illegal EVENT_TAG error check" << std::endl;
7442 test_obj.up_thread_module_event_map_clear();
7443 proto_test.handle_response_send_inform_res_tag = l7vs::protocol_module_base::FINALIZE;
7444 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
7445 l7vs::Logger::putLogError_id = 0;
7446 test_obj.test_call();
7447 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
7448 BOOST_CHECK_EQUAL(24,l7vs::Logger::putLogError_id);
7449 std::cout << l7vs::Logger::putLogError_message << std::endl;
7451 // mutex_lock_test test_lock_obj(vs,io);
7452 mutex_lock_test test_lock_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
7453 test_lock_obj.set_up_thread_client_respond_event_test();
7454 test_lock_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
7456 test_lock_obj.test_thread_wait.lock();
7457 test_lock_obj.befor_thread_id = proc_id;
7458 test_lock_obj.after_thread_id = proc_id;
7459 test_lock_obj.mutex_lock();
7461 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
7463 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
7464 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
7466 boost::thread::id test_id = test_thread.get_id();
7468 BOOST_CHECK(test_id != proc_id);
7471 test_lock_obj.test_thread_wait.unlock();
7474 // unit_test [5] up_thread_client_respond_event thread block test (mutex lock)
7475 std::cout << "[5] up_thread_client_respond_event thread block test (mutex lock)" << std::endl;
7476 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
7477 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
7479 test_lock_obj.mutex_unlock();
7482 // unit_test [6] up_thread_client_respond_event thread run test (mutex unlock)
7483 std::cout << "[6] up_thread_client_respond_event thread run test (mutex unlock)" << std::endl;
7484 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
7485 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
7487 BOOST_MESSAGE( "----- up_thread_client_respond_event test end -----" );
7492 // down_thread_client_respond_event test
7493 // dwon_thread_client_respond_event test class
7494 class down_thread_client_respond_event_test_class : public module_event_map_test_base_class{
7496 // down_thread_client_respond_event_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : module_event_map_test_base_class(vs,session_io){
7498 down_thread_client_respond_event_test_class(
7499 l7vs::virtualservice_tcp& vs,
7500 boost::asio::io_service& session_io,
7501 l7vs::tcp_socket_option_info& set_socket_option,
7502 boost::asio::ip::tcp::endpoint listen_endpoint,
7504 boost::asio::ssl::context& set_ssl_context,
7505 bool set_ssl_cache_flag,
7506 int set_ssl_handshake_time_out,
7507 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
7514 set_ssl_handshake_time_out,
7515 set_access_logger){};
7518 ~down_thread_client_respond_event_test_class(){};
7521 l7vs::tcp_session::down_thread_client_respond_event(LOCAL_PROC);
7525 void down_thread_client_respond_event_test(){
7527 BOOST_MESSAGE( "----- down_thread_client_respond_event test start -----" );
7529 // boost::asio::io_service io;
7530 // l7vs::virtualservice_tcp vs;
7531 // down_thread_client_respond_event_test_class test_obj(vs,io);
7532 l7vs::virtualservice_tcp vs;
7533 boost::asio::io_service io;
7534 l7vs::tcp_socket_option_info set_option;
7535 //! TCP_NODELAY (false:not set,true:set option)
7536 set_option.nodelay_opt = false;
7537 //! TCP_NODELAY option value (false:off,true:on)
7538 set_option.nodelay_val = false;
7539 //! TCP_CORK (false:not set,true:set option)
7540 set_option.cork_opt = false;
7541 //! TCP_CORK option value (false:off,true:on)
7542 set_option.cork_val = false;
7543 //! TCP_QUICKACK (false:not set,true:set option)
7544 set_option.quickack_opt = false;
7545 //! TCP_QUICKACK option value (false:off,true:on)
7546 set_option.quickack_val = false;
7548 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
7549 bool set_mode(false);
7550 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
7551 bool set_ssl_cache_flag(false);
7552 int set_ssl_handshake_time_out = 0;
7553 //std::string access_log_file_name = "test";
7554 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
7556 down_thread_client_respond_event_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
7559 std::string test_protocol_name("test protocol");
7560 l7vs::test_protocol_module proto_test(test_protocol_name);
7562 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
7564 l7vs::protocol_module_base::EVENT_TAG chek_event[7];
7565 chek_event[0] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
7566 chek_event[1] = l7vs::protocol_module_base::CLIENT_CONNECTION_CHECK;
7567 chek_event[2] = l7vs::protocol_module_base::REALSERVER_RECV;
7568 chek_event[3] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
7569 chek_event[4] = l7vs::protocol_module_base::SORRYSERVER_RECV;
7570 chek_event[5] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
7571 chek_event[6] = l7vs::protocol_module_base::FINALIZE;
7573 // unit_test [1] down_thread_client_respond_event down_thread_next_call_function update check
7574 std::cout << "[1] down_thread_client_respond_event down_thread_next_call_function update check" << std::endl;
7575 for(int i = 0; i < 7;i++){
7576 proto_test.handle_response_send_inform_res_tag = chek_event[i];
7577 test_obj.test_call();
7578 BOOST_CHECK(test_obj.chk_down_thread_next_call_function(chek_event[i]));
7581 // unit_test [2] down_thread_client_respond_event module parameter check thread id
7582 std::cout << "[2] down_thread_client_respond_event module parameter check thread id" << std::endl;
7583 boost::thread::id def_id;
7584 boost::thread::id proc_id = boost::this_thread::get_id();
7585 test_obj.set_down_thread_id(proc_id);
7586 proto_test.handle_response_send_inform_thread_id = def_id;
7587 proto_test.handle_response_send_inform_res_tag = l7vs::protocol_module_base::FINALIZE;
7588 BOOST_CHECK(proto_test.handle_response_send_inform_thread_id != proc_id);
7589 test_obj.test_call();
7590 BOOST_CHECK(proto_test.handle_response_send_inform_thread_id == proc_id);
7592 // unit_test [3] down_thread_client_respond_event not fond function error check
7593 std::cout << "[3] down_thread_client_respond_event not fond function error check" << std::endl;
7594 test_obj.down_thread_function_array_clear();
7595 proto_test.handle_response_send_inform_res_tag = l7vs::protocol_module_base::FINALIZE;
7596 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
7597 l7vs::Logger::putLogError_id = 0;
7598 test_obj.test_call();
7599 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
7600 BOOST_CHECK_EQUAL(81,l7vs::Logger::putLogError_id);
7601 std::cout << l7vs::Logger::putLogError_message << std::endl;
7603 // unit_test [4] down_thread_client_respond_event returnd illegal EVENT_TAG error check
7604 std::cout << "[4] down_thread_client_respond_event returnd illegal EVENT_TAG error check" << std::endl;
7605 test_obj.down_thread_module_event_map_clear();
7606 proto_test.handle_response_send_inform_res_tag = l7vs::protocol_module_base::FINALIZE;
7607 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
7608 l7vs::Logger::putLogError_id = 0;
7609 test_obj.test_call();
7610 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
7611 BOOST_CHECK_EQUAL(80,l7vs::Logger::putLogError_id);
7612 std::cout << l7vs::Logger::putLogError_message << std::endl;
7614 // mutex_lock_test test_lock_obj(vs,io);
7615 mutex_lock_test test_lock_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
7616 test_lock_obj.set_down_thread_client_respond_event_test();
7617 test_lock_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
7619 test_lock_obj.test_thread_wait.lock();
7620 test_lock_obj.befor_thread_id = proc_id;
7621 test_lock_obj.after_thread_id = proc_id;
7622 test_lock_obj.mutex_lock();
7624 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
7626 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
7627 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
7629 boost::thread::id test_id = test_thread.get_id();
7631 BOOST_CHECK(test_id != proc_id);
7634 test_lock_obj.test_thread_wait.unlock();
7637 // unit_test [5] down_thread_client_respond_event thread block test (mutex lock)
7638 std::cout << "[5] down_thread_client_respond_event thread block test (mutex lock)" << std::endl;
7639 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
7640 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
7642 test_lock_obj.mutex_unlock();
7645 // unit_test [6] down_thread_client_respond_event thread run test (mutex unlock)
7646 std::cout << "[6] down_thread_client_respond_event thread run test (mutex unlock)" << std::endl;
7647 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
7648 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
7650 BOOST_MESSAGE( "----- down_thread_client_respond_event test end -----" );
7654 // up_thread_all_socket_close test
7655 // up_thread_all_socket_close test class
7656 class up_thread_all_socket_close_test_class : public l7vs::tcp_session{
7658 // up_thread_all_socket_close_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){
7660 up_thread_all_socket_close_test_class(
7661 l7vs::virtualservice_tcp& vs,
7662 boost::asio::io_service& session_io,
7663 l7vs::tcp_socket_option_info& set_socket_option,
7664 boost::asio::ip::tcp::endpoint listen_endpoint,
7666 boost::asio::ssl::context& set_ssl_context,
7667 bool set_ssl_cache_flag,
7668 int set_ssl_handshake_time_out,
7669 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
7676 set_ssl_handshake_time_out,
7677 set_access_logger){};
7679 ~up_thread_all_socket_close_test_class(){};
7682 tcp_session::up_thread_all_socket_close();
7685 l7vs::tcp_socket& get_client_socket(){
7686 return client_socket;
7688 l7vs::tcp_ssl_socket& get_client_ssl_socket(){
7689 return client_ssl_socket;
7692 boost::shared_ptr< l7vs::tcp_socket > get_sorry_socket(){
7693 return sorryserver_socket.second;
7696 std::map<endpoint,tcp_socket_ptr>& get_up_thread_send_realserver_socket_map(){
7697 return up_thread_send_realserver_socket_map;
7700 l7vs::tcp_realserver_connect_socket_list& get_down_thread_connect_socket_list(){
7701 return down_thread_connect_socket_list;
7704 void up_thread_all_socket_close_test(){
7705 BOOST_MESSAGE( "----- up_thread_all_socket_close test start -----" );
7706 // boost::asio::io_service io;
7707 // l7vs::virtualservice_tcp vs;
7708 // up_thread_all_socket_close_test_class test_obj(vs,io);
7709 l7vs::virtualservice_tcp vs;
7710 boost::asio::io_service io;
7711 l7vs::tcp_socket_option_info set_option;
7712 //! TCP_NODELAY (false:not set,true:set option)
7713 set_option.nodelay_opt = false;
7714 //! TCP_NODELAY option value (false:off,true:on)
7715 set_option.nodelay_val = false;
7716 //! TCP_CORK (false:not set,true:set option)
7717 set_option.cork_opt = false;
7718 //! TCP_CORK option value (false:off,true:on)
7719 set_option.cork_val = false;
7720 //! TCP_QUICKACK (false:not set,true:set option)
7721 set_option.quickack_opt = false;
7722 //! TCP_QUICKACK option value (false:off,true:on)
7723 set_option.quickack_val = false;
7725 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
7726 bool set_mode(false);
7727 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
7728 bool set_ssl_cache_flag(false);
7729 int set_ssl_handshake_time_out = 0;
7730 //std::string access_log_file_name = "test";
7731 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
7733 up_thread_all_socket_close_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
7736 l7vs::tcp_socket& client_socket = test_obj.get_client_socket();
7737 client_socket.close_call_check = false;
7738 l7vs::tcp_socket& sorry_socket = *(test_obj.get_sorry_socket());
7739 sorry_socket.close_call_check = false;
7740 std::map< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > >& up_thread_send_realserver_socket_map = test_obj.get_up_thread_send_realserver_socket_map();
7741 std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > pair_socket;
7742 std::list< std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > > rs_socket_list;
7743 std::list< std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > >::iterator rs_list_it;
7744 pair_socket.first.address(boost::asio::ip::address::from_string(DUMMI_SERVER_IP));
7745 vs.connection_inactive_list.clear();
7746 std::list<boost::asio::ip::tcp::endpoint>::iterator inact_list_it;
7747 l7vs::tcp_realserver_connect_socket_list& connect_socket_list = test_obj.get_down_thread_connect_socket_list();
7749 for(int i = 0; i < 1024;i++){
7750 pair_socket.first.port(i);
7751 boost::shared_ptr< l7vs::tcp_socket > new_socket(new l7vs::tcp_socket(io));
7752 pair_socket.second = new_socket;
7753 new_socket->close_call_check = false;
7754 new_socket->close_res = true;
7755 rs_socket_list.push_back(pair_socket);
7756 up_thread_send_realserver_socket_map.insert(pair_socket);
7757 connect_socket_list.push_back(pair_socket);
7759 BOOST_CHECK(!up_thread_send_realserver_socket_map.empty());
7760 BOOST_CHECK(!connect_socket_list.empty());
7761 BOOST_CHECK(!rs_socket_list.empty());
7763 test_obj.test_call();
7765 // unit_test [1] up_thread_all_socket_close realserver socket close call check
7766 std::cout << "[1] up_thread_all_socket_close realserver socket close call check" << std::endl;
7767 rs_list_it = rs_socket_list.begin();
7768 for(int i = 0; i < 1024;i++){
7769 BOOST_CHECK(rs_list_it->second->close_call_check);
7773 // unit_test [2] up_thread_all_socket_close parent virtual service connection incactive call check
7774 std::cout << "[2] up_thread_all_socket_close parent virtual service connection incactive call check" << std::endl;
7775 rs_list_it = rs_socket_list.begin();
7776 for(int i = 0; i < 1024;i++){
7777 inact_list_it = vs.connection_inactive_list.begin();
7778 while(inact_list_it != vs.connection_inactive_list.end()){
7779 if(*inact_list_it == rs_list_it->first)
7783 BOOST_CHECK(inact_list_it != vs.connection_inactive_list.end());
7784 vs.connection_inactive_list.erase(inact_list_it);
7787 BOOST_CHECK(vs.connection_inactive_list.empty());
7789 // unit_test [3] up_thread_all_socket_close realserver send socket map clear check
7790 std::cout << "[3] up_thread_all_socket_close realserver send socket map clear check" << std::endl;
7791 BOOST_CHECK(up_thread_send_realserver_socket_map.empty());
7793 // unit_test [4] up_thread_all_socket_close down thread connect socket list clear check
7794 std::cout << "[4] up_thread_all_socket_close down thread connect socket list clear check" << std::endl;
7795 BOOST_CHECK(connect_socket_list.empty());
7797 // unit_test [5] up_thread_all_socket_close client socket close call check
7798 std::cout << "[5] up_thread_all_socket_close client socket close call check" << std::endl;
7799 BOOST_CHECK(client_socket.close_call_check);
7801 // unit_test [6] up_thread_all_socket_close sorry socket close call check
7802 std::cout << "[6] up_thread_all_socket_close sorry socket close call check" << std::endl;
7803 BOOST_CHECK(sorry_socket.close_call_check);
7806 rs_list_it = rs_socket_list.begin();
7807 for(int i = 0; i < 1024;i++){
7808 rs_list_it->second->close_res = false;
7809 up_thread_send_realserver_socket_map.insert(*rs_list_it);
7813 test_obj.test_call();
7815 // unit_test [7] up_thread_all_socket_close closed socket parent virtual service connection incactive not call check
7816 std::cout << "[7] up_thread_all_socket_close closed socket parent virtual service connection incactive not call check" << std::endl;
7817 BOOST_CHECK(vs.connection_inactive_list.empty());
7820 up_thread_all_socket_close_test_class ssl_test_obj(vs,io,set_option,listen_endpoint,true,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
7821 l7vs::tcp_ssl_socket& client_ssl_socket = ssl_test_obj.get_client_ssl_socket();
7822 client_ssl_socket.close_call_check = false;
7824 ssl_test_obj.test_call();
7826 // unit_test [8] up_thread_all_socket_close client ssl socket close call check
7827 std::cout << "[8] up_thread_all_socket_close client ssl socket close call check" << std::endl;
7828 BOOST_CHECK(client_ssl_socket.close_call_check);
7830 BOOST_MESSAGE( "----- up_thread_all_socket_close test end -----" );
7833 // down_thread_all_socket_close test
7834 // down_thread_all_socket_close test class
7835 class down_thread_all_socket_close_test_class : public l7vs::tcp_session{
7837 // down_thread_all_socket_close_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){
7839 down_thread_all_socket_close_test_class(
7840 l7vs::virtualservice_tcp& vs,
7841 boost::asio::io_service& session_io,
7842 l7vs::tcp_socket_option_info& set_socket_option,
7843 boost::asio::ip::tcp::endpoint listen_endpoint,
7845 boost::asio::ssl::context& set_ssl_context,
7846 bool set_ssl_cache_flag,
7847 int set_ssl_handshake_time_out,
7848 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
7855 set_ssl_handshake_time_out,
7856 set_access_logger){};
7858 ~down_thread_all_socket_close_test_class(){};
7860 tcp_session::down_thread_all_socket_close();
7862 l7vs::tcp_socket& get_client_socket(){
7863 return client_socket;
7865 l7vs::tcp_ssl_socket& get_client_ssl_socket(){
7866 return client_ssl_socket;
7868 boost::shared_ptr< l7vs::tcp_socket > get_sorry_socket(){
7869 return sorryserver_socket.second;
7871 std::list<socket_element>& get_down_thread_receive_realserver_socket_list(){
7872 return down_thread_receive_realserver_socket_list;
7875 void down_thread_all_socket_close_test(){
7876 BOOST_MESSAGE( "----- down_thread_all_socket_close test start -----" );
7877 // boost::asio::io_service io;
7878 // l7vs::virtualservice_tcp vs;
7879 // down_thread_all_socket_close_test_class test_obj(vs,io);
7880 l7vs::virtualservice_tcp vs;
7881 boost::asio::io_service io;
7882 l7vs::tcp_socket_option_info set_option;
7883 //! TCP_NODELAY (false:not set,true:set option)
7884 set_option.nodelay_opt = false;
7885 //! TCP_NODELAY option value (false:off,true:on)
7886 set_option.nodelay_val = false;
7887 //! TCP_CORK (false:not set,true:set option)
7888 set_option.cork_opt = false;
7889 //! TCP_CORK option value (false:off,true:on)
7890 set_option.cork_val = false;
7891 //! TCP_QUICKACK (false:not set,true:set option)
7892 set_option.quickack_opt = false;
7893 //! TCP_QUICKACK option value (false:off,true:on)
7894 set_option.quickack_val = false;
7896 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
7897 bool set_mode(false);
7898 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
7899 bool set_ssl_cache_flag(false);
7900 int set_ssl_handshake_time_out = 0;
7901 //std::string access_log_file_name = "test";
7902 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
7904 down_thread_all_socket_close_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
7908 l7vs::tcp_socket& client_socket = test_obj.get_client_socket();
7909 client_socket.close_call_check = false;
7910 l7vs::tcp_socket& sorry_socket = *(test_obj.get_sorry_socket());
7911 sorry_socket.close_call_check = false;
7912 std::list< std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > >& down_thread_receive_realserver_socket_list = test_obj.get_down_thread_receive_realserver_socket_list();
7913 std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > pair_socket;
7914 std::list< std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > > rs_socket_list;
7915 std::list< std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > >::iterator rs_list_it;
7916 pair_socket.first.address(boost::asio::ip::address::from_string(DUMMI_SERVER_IP));
7917 vs.connection_inactive_list.clear();
7918 std::list<boost::asio::ip::tcp::endpoint>::iterator inact_list_it;
7920 for(int i = 0; i < 1024;i++){
7921 pair_socket.first.port(i);
7922 boost::shared_ptr< l7vs::tcp_socket > new_socket(new l7vs::tcp_socket(io));
7923 pair_socket.second = new_socket;
7924 new_socket->close_call_check = false;
7925 new_socket->close_res = true;
7926 rs_socket_list.push_back(pair_socket);
7927 down_thread_receive_realserver_socket_list.push_back(pair_socket);
7929 BOOST_CHECK(!down_thread_receive_realserver_socket_list.empty());
7930 BOOST_CHECK(!rs_socket_list.empty());
7932 test_obj.test_call();
7934 // unit_test [1] down_thread_all_socket_close realserver socket close call check
7935 std::cout << "[1] down_thread_all_socket_close realserver socket close call check" << std::endl;
7936 rs_list_it = rs_socket_list.begin();
7937 for(int i = 0; i < 1024;i++){
7938 BOOST_CHECK(rs_list_it->second->close_call_check);
7942 // unit_test [2] down_thread_all_socket_close parent virtual service connection incactive call check
7943 std::cout << "[2] down_thread_all_socket_close parent virtual service connection incactive call check" << std::endl;
7944 rs_list_it = rs_socket_list.begin();
7945 for(int i = 0; i < 1024;i++){
7946 inact_list_it = vs.connection_inactive_list.begin();
7947 while(inact_list_it != vs.connection_inactive_list.end()){
7948 if(*inact_list_it == rs_list_it->first)
7952 BOOST_CHECK(inact_list_it != vs.connection_inactive_list.end());
7953 vs.connection_inactive_list.erase(inact_list_it);
7956 BOOST_CHECK(vs.connection_inactive_list.empty());
7958 // unit_test [3] down_thread_all_socket_close realserver receive socket list clear check
7959 std::cout << "[3] down_thread_all_socket_close realserver receive socket list clear check" << std::endl;
7960 BOOST_CHECK(down_thread_receive_realserver_socket_list.empty());
7962 // unit_test [4] up_thread_all_socket_close client socket close call check
7963 std::cout << "[4] up_thread_all_socket_close client socket close call check" << std::endl;
7964 BOOST_CHECK(client_socket.close_call_check);
7966 // unit_test [5] up_thread_all_socket_close sorry socket close call check
7967 std::cout << "[5] up_thread_all_socket_close sorry socket close call check" << std::endl;
7968 BOOST_CHECK(sorry_socket.close_call_check);
7970 rs_list_it = rs_socket_list.begin();
7971 for(int i = 0; i < 1024;i++){
7972 rs_list_it->second->close_res = false;
7973 down_thread_receive_realserver_socket_list.push_back(*rs_list_it);
7977 test_obj.test_call();
7979 // unit_test [6] down_thread_all_socket_close closed socket parent virtual service connection incactive not call check
7980 std::cout << "[6] down_thread_all_socket_close closed socket parent virtual service connection incactive not call check" << std::endl;
7981 BOOST_CHECK(vs.connection_inactive_list.empty());
7984 down_thread_all_socket_close_test_class ssl_test_obj(vs,io,set_option,listen_endpoint,true,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
7985 l7vs::tcp_ssl_socket& client_ssl_socket = ssl_test_obj.get_client_ssl_socket();
7986 client_ssl_socket.close_call_check = false;
7988 ssl_test_obj.test_call();
7990 // unit_test [7] up_thread_all_socket_close client ssl socket close call check
7991 std::cout << "[7] up_thread_all_socket_close client ssl socket close call check" << std::endl;
7992 BOOST_CHECK(client_ssl_socket.close_call_check);
7994 BOOST_MESSAGE( "----- down_thread_all_socket_close test end -----" );
7997 // up_thread_client_disconnect test
7998 // up_thread_client_disconnect test class
7999 class up_thread_client_disconnect : public l7vs::tcp_session{
8001 // up_thread_client_disconnect(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){
8003 up_thread_client_disconnect(
8004 l7vs::virtualservice_tcp& vs,
8005 boost::asio::io_service& session_io,
8006 l7vs::tcp_socket_option_info& set_socket_option,
8007 boost::asio::ip::tcp::endpoint listen_endpoint,
8009 boost::asio::ssl::context& set_ssl_context,
8010 bool set_ssl_cache_flag,
8011 int set_ssl_handshake_time_out,
8012 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
8019 set_ssl_handshake_time_out,
8020 set_access_logger){};
8022 ~up_thread_client_disconnect(){};
8025 l7vs::tcp_session::up_thread_client_disconnect(LOCAL_PROC);
8028 l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_up_thread_message_que(){
8029 return up_thread_message_que;
8032 l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_down_thread_message_que(){
8033 return down_thread_message_que;
8036 void up_thread_function_array_clear(){
8037 for(int i = 0;i <= UP_FUNC_EXIT;i++){
8038 up_thread_function_array[i].second = NULL;
8041 void up_thread_message_down_thread_function_map_clear(){
8042 up_thread_message_down_thread_function_map.clear();
8045 void up_thread_client_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){
8046 up_thread_client_disconnect_event_call_chek = true;
8048 bool up_thread_client_disconnect_event_call_chek;
8050 void down_thread_client_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){
8051 down_thread_client_disconnect_event_call_chek = true;
8053 bool down_thread_client_disconnect_event_call_chek;
8055 void up_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
8056 up_thread_exit_call_chek = true;
8058 bool up_thread_exit_call_chek;
8060 l7vs::tcp_socket& get_client_socket(){
8061 return client_socket;
8063 l7vs::tcp_ssl_socket& get_client_ssl_socket(){
8064 return client_ssl_socket;
8068 void up_thread_client_disconnect_test(){
8069 BOOST_MESSAGE( "----- up_thread_client_disconnect test start -----" );
8070 // boost::asio::io_service io;
8071 // l7vs::virtualservice_tcp vs;
8072 // up_thread_client_disconnect test_obj(vs,io);
8073 l7vs::virtualservice_tcp vs;
8074 boost::asio::io_service io;
8075 l7vs::tcp_socket_option_info set_option;
8076 //! TCP_NODELAY (false:not set,true:set option)
8077 set_option.nodelay_opt = false;
8078 //! TCP_NODELAY option value (false:off,true:on)
8079 set_option.nodelay_val = false;
8080 //! TCP_CORK (false:not set,true:set option)
8081 set_option.cork_opt = false;
8082 //! TCP_CORK option value (false:off,true:on)
8083 set_option.cork_val = false;
8084 //! TCP_QUICKACK (false:not set,true:set option)
8085 set_option.quickack_opt = false;
8086 //! TCP_QUICKACK option value (false:off,true:on)
8087 set_option.quickack_val = false;
8089 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
8090 bool set_mode(false);
8091 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
8092 bool set_ssl_cache_flag(false);
8093 int set_ssl_handshake_time_out = 0;
8094 //std::string access_log_file_name = "test";
8095 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
8097 up_thread_client_disconnect test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
8100 l7vs::lockfree_queue<l7vs::tcp_thread_message>& up_thread_message_que = test_obj.get_up_thread_message_que();
8101 l7vs::lockfree_queue<l7vs::tcp_thread_message>& down_thread_message_que = test_obj.get_down_thread_message_que();
8103 BOOST_CHECK(up_thread_message_que.empty());
8104 BOOST_CHECK(down_thread_message_que.empty());
8105 l7vs::tcp_socket& client_socket = test_obj.get_client_socket();
8106 client_socket.close_res = true;
8107 client_socket.close_call_check = false;
8109 test_obj.test_call();
8111 // unit_test [1] up_thread_client_disconnect client socket close call check
8112 std::cout << "[1] up_thread_client_disconnect client socket close call check" << std::endl;
8113 BOOST_CHECK(client_socket.close_call_check);
8115 // unit_test [2] up_thread_client_disconnect up thread message set check
8116 std::cout << "[2] up_thread_client_disconnect up thread message set check" << std::endl;
8117 BOOST_CHECK(!up_thread_message_que.empty());
8118 l7vs::tcp_thread_message* up_msg = up_thread_message_que.pop();
8119 BOOST_CHECK(up_thread_message_que.empty());
8120 test_obj.up_thread_client_disconnect_event_call_chek = false;
8121 up_msg->message(l7vs::tcp_session::MESSAGE_PROC);
8122 BOOST_CHECK(test_obj.up_thread_client_disconnect_event_call_chek);
8125 // unit_test [3] up_thread_client_disconnect down thread message set check
8126 std::cout << "[3] up_thread_client_disconnect down thread message set check" << std::endl;
8127 BOOST_CHECK(!down_thread_message_que.empty());
8128 l7vs::tcp_thread_message* down_msg = down_thread_message_que.pop();
8129 BOOST_CHECK(down_thread_message_que.empty());
8130 test_obj.down_thread_client_disconnect_event_call_chek = false;
8131 down_msg->message(l7vs::tcp_session::MESSAGE_PROC);
8132 BOOST_CHECK(test_obj.down_thread_client_disconnect_event_call_chek);
8135 // unit_test [4] up_thread_client_disconnect closed client socket not set message check
8136 std::cout << "[4] up_thread_client_disconnect closed client socket not set message check" << std::endl;
8137 client_socket.close_res = false;
8138 test_obj.test_call();
8139 BOOST_CHECK(up_thread_message_que.empty());
8140 BOOST_CHECK(down_thread_message_que.empty());
8142 client_socket.close_res = true;
8144 // unit_test [5] up_thread_client_disconnect not fond down_thread_client_disconnect_event function error check
8145 std::cout << "[5] up_thread_client_disconnect not fond down_thread_client_disconnect_event function error check" << std::endl;
8146 test_obj.up_thread_message_down_thread_function_map_clear();
8147 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
8148 l7vs::Logger::putLogError_id = 0;
8149 test_obj.up_thread_exit_call_chek = false;
8150 test_obj.test_call();
8151 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
8152 BOOST_CHECK_EQUAL(27,l7vs::Logger::putLogError_id);
8153 std::cout << l7vs::Logger::putLogError_message << std::endl;
8154 BOOST_CHECK(test_obj.up_thread_exit_call_chek);
8156 // unit_test [6] up_thread_client_disconnect not fond up_thread_client_disconnect_event function error check
8157 std::cout << "[6] up_thread_client_disconnect not fond up_thread_client_disconnect_event function error check" << std::endl;
8158 test_obj.up_thread_function_array_clear();
8159 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
8160 l7vs::Logger::putLogError_id = 0;
8161 test_obj.up_thread_exit_call_chek = false;
8162 test_obj.test_call();
8163 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
8164 BOOST_CHECK_EQUAL(26,l7vs::Logger::putLogError_id);
8165 std::cout << l7vs::Logger::putLogError_message << std::endl;
8166 BOOST_CHECK(test_obj.up_thread_exit_call_chek);
8168 // ----SSL Mode Test
8169 up_thread_client_disconnect ssl_test_obj(vs,io,set_option,listen_endpoint,true,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
8171 l7vs::tcp_ssl_socket& client_ssl_socket = ssl_test_obj.get_client_ssl_socket();
8172 client_ssl_socket.close_res = true;
8173 client_ssl_socket.close_call_check = false;
8175 ssl_test_obj.test_call();
8177 // unit_test [7] up_thread_client_disconnect client ssl socket close call check
8178 std::cout << "[7] up_thread_client_disconnect client ssl socket close call check" << std::endl;
8179 BOOST_CHECK(client_ssl_socket.close_call_check);
8182 BOOST_MESSAGE( "----- up_thread_client_disconnect test end -----" );
8187 // down_thread_client_disconnect test
8188 // down_thread_client_disconnect test class
8189 class down_thread_client_disconnect_test_class : public l7vs::tcp_session{
8191 // down_thread_client_disconnect_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){
8193 down_thread_client_disconnect_test_class(
8194 l7vs::virtualservice_tcp& vs,
8195 boost::asio::io_service& session_io,
8196 l7vs::tcp_socket_option_info& set_socket_option,
8197 boost::asio::ip::tcp::endpoint listen_endpoint,
8199 boost::asio::ssl::context& set_ssl_context,
8200 bool set_ssl_cache_flag,
8201 int set_ssl_handshake_time_out,
8202 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
8209 set_ssl_handshake_time_out,
8210 set_access_logger){};
8212 ~down_thread_client_disconnect_test_class(){};
8215 l7vs::tcp_session::down_thread_client_disconnect(LOCAL_PROC);
8218 l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_up_thread_message_que(){
8219 return up_thread_message_que;
8222 l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_down_thread_message_que(){
8223 return down_thread_message_que;
8226 void down_thread_function_array_clear(){
8227 for(int i = 0; i <= DOWN_FUNC_EXIT; i++){
8228 down_thread_function_array[i].second = NULL;
8231 void down_thread_message_up_thread_function_map_clear(){
8232 down_thread_message_up_thread_function_map.clear();
8235 void up_thread_client_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){
8236 up_thread_client_disconnect_event_call_chek = true;
8238 bool up_thread_client_disconnect_event_call_chek;
8240 void down_thread_client_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){
8241 down_thread_client_disconnect_event_call_chek = true;
8243 bool down_thread_client_disconnect_event_call_chek;
8245 void down_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
8246 down_thread_exit_call_chek = true;
8248 bool down_thread_exit_call_chek;
8250 l7vs::tcp_socket& get_client_socket(){
8251 return client_socket;
8253 l7vs::tcp_ssl_socket& get_client_ssl_socket(){
8254 return client_ssl_socket;
8257 void down_thread_client_disconnect_test(){
8258 BOOST_MESSAGE( "----- down_thread_client_disconnect test start -----" );
8259 // boost::asio::io_service io;
8260 // l7vs::virtualservice_tcp vs;
8261 // down_thread_client_disconnect_test_class test_obj(vs,io);
8262 l7vs::virtualservice_tcp vs;
8263 boost::asio::io_service io;
8264 l7vs::tcp_socket_option_info set_option;
8265 //! TCP_NODELAY (false:not set,true:set option)
8266 set_option.nodelay_opt = false;
8267 //! TCP_NODELAY option value (false:off,true:on)
8268 set_option.nodelay_val = false;
8269 //! TCP_CORK (false:not set,true:set option)
8270 set_option.cork_opt = false;
8271 //! TCP_CORK option value (false:off,true:on)
8272 set_option.cork_val = false;
8273 //! TCP_QUICKACK (false:not set,true:set option)
8274 set_option.quickack_opt = false;
8275 //! TCP_QUICKACK option value (false:off,true:on)
8276 set_option.quickack_val = false;
8278 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
8279 bool set_mode(false);
8280 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
8281 bool set_ssl_cache_flag(false);
8282 int set_ssl_handshake_time_out = 0;
8283 //std::string access_log_file_name = "test";
8284 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
8286 down_thread_client_disconnect_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
8288 l7vs::lockfree_queue<l7vs::tcp_thread_message>& up_thread_message_que = test_obj.get_up_thread_message_que();
8289 l7vs::lockfree_queue<l7vs::tcp_thread_message>& down_thread_message_que = test_obj.get_down_thread_message_que();
8291 BOOST_CHECK(up_thread_message_que.empty());
8292 BOOST_CHECK(down_thread_message_que.empty());
8293 l7vs::tcp_socket& client_socket = test_obj.get_client_socket();
8294 client_socket.close_res = true;
8295 client_socket.close_call_check = false;
8297 test_obj.test_call();
8299 // unit_test [1] down_thread_client_disconnect client socket close call check
8300 std::cout << "[1] down_thread_client_disconnect client socket close call check" << std::endl;
8301 BOOST_CHECK(client_socket.close_call_check);
8303 // unit_test [2] down_thread_client_disconnect up thread message set check
8304 std::cout << "[2] down_thread_client_disconnect up thread message set check" << std::endl;
8305 BOOST_CHECK(!up_thread_message_que.empty());
8306 l7vs::tcp_thread_message* up_msg = up_thread_message_que.pop();
8307 BOOST_CHECK(up_thread_message_que.empty());
8308 test_obj.up_thread_client_disconnect_event_call_chek = false;
8309 up_msg->message(l7vs::tcp_session::MESSAGE_PROC);
8310 BOOST_CHECK(test_obj.up_thread_client_disconnect_event_call_chek);
8313 // unit_test [3] down_thread_client_disconnect down thread message set check
8314 std::cout << "[3] down_thread_client_disconnect down thread message set check" << std::endl;
8315 BOOST_CHECK(!down_thread_message_que.empty());
8316 l7vs::tcp_thread_message* down_msg = down_thread_message_que.pop();
8317 BOOST_CHECK(down_thread_message_que.empty());
8318 test_obj.down_thread_client_disconnect_event_call_chek = false;
8319 down_msg->message(l7vs::tcp_session::MESSAGE_PROC);
8320 BOOST_CHECK(test_obj.down_thread_client_disconnect_event_call_chek);
8323 // unit_test [4] down_thread_client_disconnect closed client socket not set message check
8324 std::cout << "[4] down_thread_client_disconnect closed client socket not set message check" << std::endl;
8325 client_socket.close_res = false;
8326 test_obj.test_call();
8327 BOOST_CHECK(up_thread_message_que.empty());
8328 BOOST_CHECK(down_thread_message_que.empty());
8330 client_socket.close_res = true;
8332 // unit_test [5] down_thread_client_disconnect not fond up_thread_client_disconnect_event function error check
8333 std::cout << "[5] down_thread_client_disconnect not fond up_thread_client_disconnect_event function error check" << std::endl;
8334 test_obj.down_thread_message_up_thread_function_map_clear();
8335 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
8336 l7vs::Logger::putLogError_id = 0;
8337 test_obj.down_thread_exit_call_chek = false;
8338 test_obj.test_call();
8339 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
8340 BOOST_CHECK_EQUAL(85,l7vs::Logger::putLogError_id);
8341 std::cout << l7vs::Logger::putLogError_message << std::endl;
8342 BOOST_CHECK(test_obj.down_thread_exit_call_chek);
8344 // unit_test [6] down_thread_client_disconnect not fond down_thread_client_disconnect_event function error check
8345 std::cout << "[6] down_thread_client_disconnect not fond down_thread_client_disconnect_event function error check" << std::endl;
8346 test_obj.down_thread_function_array_clear();
8347 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
8348 l7vs::Logger::putLogError_id = 0;
8349 test_obj.down_thread_exit_call_chek = false;
8350 test_obj.test_call();
8351 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
8352 BOOST_CHECK_EQUAL(84,l7vs::Logger::putLogError_id);
8353 std::cout << l7vs::Logger::putLogError_message << std::endl;
8354 BOOST_CHECK(test_obj.down_thread_exit_call_chek);
8357 // ----SSL Mode Test
8358 down_thread_client_disconnect_test_class ssl_test_obj(vs,io,set_option,listen_endpoint,true,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
8360 l7vs::tcp_ssl_socket& client_ssl_socket = ssl_test_obj.get_client_ssl_socket();
8361 client_ssl_socket.close_res = true;
8362 client_ssl_socket.close_call_check = false;
8364 ssl_test_obj.test_call();
8366 // unit_test [7] down_thread_client_disconnect client ssl socket close call check
8367 std::cout << "[7] down_thread_client_disconnect client ssl socket close call check" << std::endl;
8368 BOOST_CHECK(client_ssl_socket.close_call_check);
8371 BOOST_MESSAGE( "----- down_thread_client_disconnect test end -----" );
8375 // up_thread_sorryserver_disconnect test
8376 // up_thread_sorryserver_disconnect test class
8377 class up_thread_sorryserver_disconnect_test_class : public l7vs::tcp_session{
8379 // up_thread_sorryserver_disconnect_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){
8381 up_thread_sorryserver_disconnect_test_class(
8382 l7vs::virtualservice_tcp& vs,
8383 boost::asio::io_service& session_io,
8384 l7vs::tcp_socket_option_info& set_socket_option,
8385 boost::asio::ip::tcp::endpoint listen_endpoint,
8387 boost::asio::ssl::context& set_ssl_context,
8388 bool set_ssl_cache_flag,
8389 int set_ssl_handshake_time_out,
8390 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
8397 set_ssl_handshake_time_out,
8398 set_access_logger){};
8400 ~up_thread_sorryserver_disconnect_test_class(){};
8403 l7vs::tcp_session::up_thread_sorryserver_disconnect(LOCAL_PROC);
8406 l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_up_thread_message_que(){
8407 return up_thread_message_que;
8410 l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_down_thread_message_que(){
8411 return down_thread_message_que;
8414 void up_thread_function_array_clear(){
8415 for(int i = 0;i <= UP_FUNC_EXIT;i++){
8416 up_thread_function_array[i].second = NULL;
8419 void up_thread_message_down_thread_function_map_clear(){
8420 up_thread_message_down_thread_function_map.clear();
8423 void up_thread_sorryserver_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){
8424 up_thread_sorryserver_disconnect_event_call_chek = true;
8426 bool up_thread_sorryserver_disconnect_event_call_chek;
8428 void down_thread_sorryserver_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){
8429 down_thread_sorryserver_disconnect_event_call_chek = true;
8431 bool down_thread_sorryserver_disconnect_event_call_chek;
8433 void up_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
8434 up_thread_exit_call_chek = true;
8436 bool up_thread_exit_call_chek;
8438 boost::shared_ptr< l7vs::tcp_socket > get_sorry_socket(){
8439 return sorryserver_socket.second;
8441 void set_sorry_endpoint(endpoint set_end){
8442 sorryserver_socket.first = set_end;
8445 void up_thread_sorryserver_disconnect_test(){
8446 BOOST_MESSAGE( "----- up_thread_sorryserver_disconnect test start -----" );
8447 // boost::asio::io_service io;
8448 // l7vs::virtualservice_tcp vs;
8449 // up_thread_sorryserver_disconnect_test_class test_obj(vs,io);
8450 l7vs::virtualservice_tcp vs;
8451 boost::asio::io_service io;
8452 l7vs::tcp_socket_option_info set_option;
8453 //! TCP_NODELAY (false:not set,true:set option)
8454 set_option.nodelay_opt = false;
8455 //! TCP_NODELAY option value (false:off,true:on)
8456 set_option.nodelay_val = false;
8457 //! TCP_CORK (false:not set,true:set option)
8458 set_option.cork_opt = false;
8459 //! TCP_CORK option value (false:off,true:on)
8460 set_option.cork_val = false;
8461 //! TCP_QUICKACK (false:not set,true:set option)
8462 set_option.quickack_opt = false;
8463 //! TCP_QUICKACK option value (false:off,true:on)
8464 set_option.quickack_val = false;
8466 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
8467 bool set_mode(false);
8468 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
8469 bool set_ssl_cache_flag(false);
8470 int set_ssl_handshake_time_out = 0;
8471 //std::string access_log_file_name = "test";
8472 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
8474 up_thread_sorryserver_disconnect_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
8478 l7vs::lockfree_queue<l7vs::tcp_thread_message>& up_thread_message_que = test_obj.get_up_thread_message_que();
8479 l7vs::lockfree_queue<l7vs::tcp_thread_message>& down_thread_message_que = test_obj.get_down_thread_message_que();
8481 BOOST_CHECK(up_thread_message_que.empty());
8482 BOOST_CHECK(down_thread_message_que.empty());
8483 l7vs::tcp_socket& sorry_socket = *(test_obj.get_sorry_socket());
8484 sorry_socket.close_res = true;
8485 sorry_socket.close_call_check = false;
8486 boost::asio::ip::tcp::endpoint sorry_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
8487 test_obj.set_sorry_endpoint(sorry_end);
8489 test_obj.test_call();
8491 // unit_test [1] up_thread_sorryserver_disconnect client socket close call check
8492 std::cout << "[1] up_thread_sorryserver_disconnect client socket close call check" << std::endl;
8493 BOOST_CHECK(sorry_socket.close_call_check);
8495 // unit_test [2] up_thread_sorryserver_disconnect up thread message set check
8496 std::cout << "[2] up_thread_sorryserver_disconnect up thread message set check" << std::endl;
8497 BOOST_CHECK(!up_thread_message_que.empty());
8498 l7vs::tcp_thread_message* up_msg = up_thread_message_que.pop();
8499 BOOST_CHECK(up_thread_message_que.empty());
8500 BOOST_CHECK(up_msg->endpoint_info == sorry_end);
8501 test_obj.up_thread_sorryserver_disconnect_event_call_chek = false;
8502 up_msg->message(l7vs::tcp_session::MESSAGE_PROC);
8503 BOOST_CHECK(test_obj.up_thread_sorryserver_disconnect_event_call_chek);
8506 // unit_test [3] up_thread_sorryserver_disconnect down thread message set check
8507 std::cout << "[3] up_thread_sorryserver_disconnect down thread message set check" << std::endl;
8508 BOOST_CHECK(!down_thread_message_que.empty());
8509 l7vs::tcp_thread_message* down_msg = down_thread_message_que.pop();
8510 BOOST_CHECK(down_thread_message_que.empty());
8511 BOOST_CHECK(down_msg->endpoint_info == sorry_end);
8512 test_obj.down_thread_sorryserver_disconnect_event_call_chek = false;
8513 down_msg->message(l7vs::tcp_session::MESSAGE_PROC);
8514 BOOST_CHECK(test_obj.down_thread_sorryserver_disconnect_event_call_chek);
8517 // unit_test [4] up_thread_sorryserver_disconnect closed client socket not set message check
8518 std::cout << "[4] up_thread_sorryserver_disconnect closed client socket not set message check" << std::endl;
8519 sorry_socket.close_res = false;
8520 test_obj.test_call();
8521 BOOST_CHECK(up_thread_message_que.empty());
8522 BOOST_CHECK(down_thread_message_que.empty());
8524 sorry_socket.close_res = true;
8526 // unit_test [5] up_thread_sorryserver_disconnect not fond down_thread_sorryserver_disconnect_event function error check
8527 std::cout << "[5] up_thread_sorryserver_disconnect not fond down_thread_sorryserver_disconnect_event function error check" << std::endl;
8528 test_obj.up_thread_message_down_thread_function_map_clear();
8529 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
8530 l7vs::Logger::putLogError_id = 0;
8531 test_obj.up_thread_exit_call_chek = false;
8532 test_obj.test_call();
8533 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
8534 BOOST_CHECK_EQUAL(61,l7vs::Logger::putLogError_id);
8535 std::cout << l7vs::Logger::putLogError_message << std::endl;
8536 BOOST_CHECK(test_obj.up_thread_exit_call_chek);
8538 // unit_test [6] up_thread_sorryserver_disconnect not fond up_thread_sorryserver_disconnect_event function error check
8539 std::cout << "[6] up_thread_sorryserver_disconnect not fond up_thread_sorryserver_disconnect_event function error check" << std::endl;
8540 test_obj.up_thread_function_array_clear();
8541 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
8542 l7vs::Logger::putLogError_id = 0;
8543 test_obj.up_thread_exit_call_chek = false;
8544 test_obj.test_call();
8545 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
8546 BOOST_CHECK_EQUAL(60,l7vs::Logger::putLogError_id);
8547 std::cout << l7vs::Logger::putLogError_message << std::endl;
8548 BOOST_CHECK(test_obj.up_thread_exit_call_chek);
8550 BOOST_MESSAGE( "----- up_thread_sorryserver_disconnect test end -----" );
8554 // down_thread_sorryserver_disconnect test
8555 // down_thread_sorryserver_disconnect test class
8556 class down_thread_sorryserver_disconnect_test_class : public l7vs::tcp_session{
8558 // down_thread_sorryserver_disconnect_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){
8560 down_thread_sorryserver_disconnect_test_class(
8561 l7vs::virtualservice_tcp& vs,
8562 boost::asio::io_service& session_io,
8563 l7vs::tcp_socket_option_info& set_socket_option,
8564 boost::asio::ip::tcp::endpoint listen_endpoint,
8566 boost::asio::ssl::context& set_ssl_context,
8567 bool set_ssl_cache_flag,
8568 int set_ssl_handshake_time_out,
8569 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
8576 set_ssl_handshake_time_out,
8577 set_access_logger){};
8579 ~down_thread_sorryserver_disconnect_test_class(){};
8582 l7vs::tcp_session::down_thread_sorryserver_disconnect(LOCAL_PROC);
8585 l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_up_thread_message_que(){
8586 return up_thread_message_que;
8589 l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_down_thread_message_que(){
8590 return down_thread_message_que;
8593 void down_thread_function_array_clear(){
8594 for(int i = 0; i <= DOWN_FUNC_EXIT;i++){
8595 down_thread_function_array[i].second = NULL;
8598 void down_thread_message_up_thread_function_map_clear(){
8599 down_thread_message_up_thread_function_map.clear();
8602 void up_thread_sorryserver_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){
8603 up_thread_sorryserver_disconnect_event_call_chek = true;
8605 bool up_thread_sorryserver_disconnect_event_call_chek;
8607 void down_thread_sorryserver_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){
8608 down_thread_sorryserver_disconnect_event_call_chek = true;
8610 bool down_thread_sorryserver_disconnect_event_call_chek;
8612 void down_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
8613 down_thread_exit_call_chek = true;
8615 bool down_thread_exit_call_chek;
8617 boost::shared_ptr< l7vs::tcp_socket > get_sorry_socket(){
8618 return sorryserver_socket.second;
8620 void set_sorry_endpoint(endpoint set_end){
8621 sorryserver_socket.first = set_end;
8624 void down_thread_sorryserver_disconnect_test(){
8625 BOOST_MESSAGE( "----- down_thread_sorryserver_disconnect test start -----" );
8626 // boost::asio::io_service io;
8627 // l7vs::virtualservice_tcp vs;
8628 // down_thread_sorryserver_disconnect_test_class test_obj(vs,io);
8629 l7vs::virtualservice_tcp vs;
8630 boost::asio::io_service io;
8631 l7vs::tcp_socket_option_info set_option;
8632 //! TCP_NODELAY (false:not set,true:set option)
8633 set_option.nodelay_opt = false;
8634 //! TCP_NODELAY option value (false:off,true:on)
8635 set_option.nodelay_val = false;
8636 //! TCP_CORK (false:not set,true:set option)
8637 set_option.cork_opt = false;
8638 //! TCP_CORK option value (false:off,true:on)
8639 set_option.cork_val = false;
8640 //! TCP_QUICKACK (false:not set,true:set option)
8641 set_option.quickack_opt = false;
8642 //! TCP_QUICKACK option value (false:off,true:on)
8643 set_option.quickack_val = false;
8645 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
8646 bool set_mode(false);
8647 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
8648 bool set_ssl_cache_flag(false);
8649 int set_ssl_handshake_time_out = 0;
8650 //std::string access_log_file_name = "test";
8651 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
8653 down_thread_sorryserver_disconnect_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
8655 l7vs::lockfree_queue<l7vs::tcp_thread_message>& up_thread_message_que = test_obj.get_up_thread_message_que();
8656 l7vs::lockfree_queue<l7vs::tcp_thread_message>& down_thread_message_que = test_obj.get_down_thread_message_que();
8658 BOOST_CHECK(up_thread_message_que.empty());
8659 BOOST_CHECK(down_thread_message_que.empty());
8660 l7vs::tcp_socket& sorry_socket = *(test_obj.get_sorry_socket());
8661 sorry_socket.close_res = true;
8662 sorry_socket.close_call_check = false;
8663 boost::asio::ip::tcp::endpoint sorry_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
8664 test_obj.set_sorry_endpoint(sorry_end);
8666 test_obj.test_call();
8668 // unit_test [1] down_thread_sorryserver_disconnect client socket close call check
8669 std::cout << "[1] down_thread_sorryserver_disconnect client socket close call check" << std::endl;
8670 BOOST_CHECK(sorry_socket.close_call_check);
8672 // unit_test [2] down_thread_sorryserver_disconnect up thread message set check
8673 std::cout << "[2] down_thread_sorryserver_disconnect up thread message set check" << std::endl;
8674 BOOST_CHECK(!up_thread_message_que.empty());
8675 l7vs::tcp_thread_message* up_msg = up_thread_message_que.pop();
8676 BOOST_CHECK(up_thread_message_que.empty());
8677 BOOST_CHECK(up_msg->endpoint_info == sorry_end);
8678 test_obj.up_thread_sorryserver_disconnect_event_call_chek = false;
8679 up_msg->message(l7vs::tcp_session::MESSAGE_PROC);
8680 BOOST_CHECK(test_obj.up_thread_sorryserver_disconnect_event_call_chek);
8683 // unit_test [3] down_thread_sorryserver_disconnect down thread message set check
8684 std::cout << "[3] down_thread_sorryserver_disconnect down thread message set check" << std::endl;
8685 BOOST_CHECK(!down_thread_message_que.empty());
8686 l7vs::tcp_thread_message* down_msg = down_thread_message_que.pop();
8687 BOOST_CHECK(down_thread_message_que.empty());
8688 BOOST_CHECK(down_msg->endpoint_info == sorry_end);
8689 test_obj.down_thread_sorryserver_disconnect_event_call_chek = false;
8690 down_msg->message(l7vs::tcp_session::MESSAGE_PROC);
8691 BOOST_CHECK(test_obj.down_thread_sorryserver_disconnect_event_call_chek);
8694 // unit_test [4] down_thread_sorryserver_disconnect closed client socket not set message check
8695 std::cout << "[4] down_thread_sorryserver_disconnect closed client socket not set message check" << std::endl;
8696 sorry_socket.close_res = false;
8697 test_obj.test_call();
8698 BOOST_CHECK(up_thread_message_que.empty());
8699 BOOST_CHECK(down_thread_message_que.empty());
8701 sorry_socket.close_res = true;
8703 // unit_test [5] down_thread_sorryserver_disconnect not fond up_thread_sorryserver_disconnect_event function error check
8704 std::cout << "[5] down_thread_sorryserver_disconnect not fond up_thread_sorryserver_disconnect_event function error check" << std::endl;
8705 test_obj.down_thread_message_up_thread_function_map_clear();
8706 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
8707 l7vs::Logger::putLogError_id = 0;
8708 test_obj.down_thread_exit_call_chek = false;
8709 test_obj.test_call();
8710 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
8711 BOOST_CHECK_EQUAL(91,l7vs::Logger::putLogError_id);
8712 std::cout << l7vs::Logger::putLogError_message << std::endl;
8713 BOOST_CHECK(test_obj.down_thread_exit_call_chek);
8715 // unit_test [6] down_thread_sorryserver_disconnect not fond down_thread_sorryserver_disconnect_event function error check
8716 std::cout << "[6] down_thread_sorryserver_disconnect not fond down_thread_sorryserver_disconnect_event function error check" << std::endl;
8717 test_obj.down_thread_function_array_clear();
8718 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
8719 l7vs::Logger::putLogError_id = 0;
8720 test_obj.down_thread_exit_call_chek = false;
8721 test_obj.test_call();
8722 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
8723 BOOST_CHECK_EQUAL(90,l7vs::Logger::putLogError_id);
8724 std::cout << l7vs::Logger::putLogError_message << std::endl;
8725 BOOST_CHECK(test_obj.down_thread_exit_call_chek);
8727 BOOST_MESSAGE( "----- down_thread_sorryserver_disconnect test end -----" );
8730 // up_thread_realserver_connect_event test
8731 // up_thread_realserver_connect_event test class
8732 class up_thread_realserver_connect_event_test_class : public module_event_map_test_base_class{
8734 // up_thread_realserver_connect_event_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : module_event_map_test_base_class(vs,session_io){
8736 up_thread_realserver_connect_event_test_class(
8737 l7vs::virtualservice_tcp& vs,
8738 boost::asio::io_service& session_io,
8739 l7vs::tcp_socket_option_info& set_socket_option,
8740 boost::asio::ip::tcp::endpoint listen_endpoint,
8742 boost::asio::ssl::context& set_ssl_context,
8743 bool set_ssl_cache_flag,
8744 int set_ssl_handshake_time_out,
8745 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
8752 set_ssl_handshake_time_out,
8753 set_access_logger){};
8755 ~up_thread_realserver_connect_event_test_class(){};
8758 l7vs::tcp_session::up_thread_realserver_connect_event(LOCAL_PROC);
8762 void up_thread_realserver_connect_event_test(){
8763 BOOST_MESSAGE( "----- up_thread_realserver_connect_event test start -----" );
8764 // boost::asio::io_service io;
8765 // l7vs::virtualservice_tcp vs;
8766 // up_thread_realserver_connect_event_test_class test_obj(vs,io);
8767 l7vs::virtualservice_tcp vs;
8768 boost::asio::io_service io;
8769 l7vs::tcp_socket_option_info set_option;
8770 //! TCP_NODELAY (false:not set,true:set option)
8771 set_option.nodelay_opt = false;
8772 //! TCP_NODELAY option value (false:off,true:on)
8773 set_option.nodelay_val = false;
8774 //! TCP_CORK (false:not set,true:set option)
8775 set_option.cork_opt = false;
8776 //! TCP_CORK option value (false:off,true:on)
8777 set_option.cork_val = false;
8778 //! TCP_QUICKACK (false:not set,true:set option)
8779 set_option.quickack_opt = false;
8780 //! TCP_QUICKACK option value (false:off,true:on)
8781 set_option.quickack_val = false;
8783 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
8784 bool set_mode(false);
8785 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
8786 bool set_ssl_cache_flag(false);
8787 int set_ssl_handshake_time_out = 0;
8788 //std::string access_log_file_name = "test";
8789 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
8791 up_thread_realserver_connect_event_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
8794 std::string test_protocol_name("test protocol");
8795 l7vs::test_protocol_module proto_test(test_protocol_name);
8797 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
8799 l7vs::protocol_module_base::EVENT_TAG chek_event[13];
8800 chek_event[0] = l7vs::protocol_module_base::ACCEPT;
8801 chek_event[1] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
8802 chek_event[2] = l7vs::protocol_module_base::CLIENT_RECV;
8803 chek_event[3] = l7vs::protocol_module_base::CLIENT_RESPONSE_SEND;
8804 chek_event[4] = l7vs::protocol_module_base::REALSERVER_SELECT;
8805 chek_event[5] = l7vs::protocol_module_base::REALSERVER_CONNECT;
8806 chek_event[6] = l7vs::protocol_module_base::REALSERVER_SEND;
8807 chek_event[7] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
8808 chek_event[8] = l7vs::protocol_module_base::SORRYSERVER_SELECT;
8809 chek_event[9] = l7vs::protocol_module_base::SORRYSERVER_CONNECT;
8810 chek_event[10] = l7vs::protocol_module_base::SORRYSERVER_SEND;
8811 chek_event[11] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
8812 chek_event[12] = l7vs::protocol_module_base::FINALIZE;
8814 // unit_test [1] up_thread_realserver_connect_event up_thread_next_call_function update check
8815 std::cout << "[1] up_thread_realserver_connect_event up_thread_next_call_function update check" << std::endl;
8816 for(int i = 0; i < 13;i++){
8817 proto_test.handle_realserver_connect_res_tag = chek_event[i];
8818 test_obj.test_call();
8819 BOOST_CHECK(test_obj.chk_up_thread_next_call_function(chek_event[i]));
8822 // unit_test [2] up_thread_realserver_connect_event module parameter check
8823 std::cout << "[2] up_thread_realserver_connect_event module parameter check" << std::endl;
8824 boost::thread::id def_id;
8825 boost::thread::id proc_id = boost::this_thread::get_id();
8826 test_obj.set_up_thread_id(proc_id);
8827 proto_test.handle_realserver_connect_thread_id = def_id;
8828 proto_test.handle_realserver_connect_res_tag = l7vs::protocol_module_base::FINALIZE;
8829 BOOST_CHECK(proto_test.handle_realserver_connect_thread_id != proc_id);
8830 char set_char = CHAR_MIN;
8831 for(int i = 0;i < MAX_BUFFER_SIZE;i++){
8832 proto_test.handle_realserver_connect_sendbuffer[i] = set_char;
8833 if(set_char == CHAR_MAX){
8834 set_char = CHAR_MIN;
8839 proto_test.handle_realserver_connect_datalen = MAX_BUFFER_SIZE;
8840 l7vs::tcp_data& test_data = test_obj.get_up_thread_data_dest_side();
8841 test_data.initialize();
8842 boost::asio::ip::tcp::endpoint server_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
8843 test_data.set_endpoint(server_end);
8845 test_obj.test_call();
8847 BOOST_CHECK(proto_test.handle_realserver_connect_thread_id == proc_id);
8848 BOOST_CHECK(proto_test.handle_realserver_connect_sendbuffer == test_data.get_data());
8849 BOOST_CHECK(proto_test.handle_realserver_connect_datalen == test_data.get_size());
8850 BOOST_CHECK(server_end == test_data.get_endpoint());
8852 // unit_test [3] up_thread_realserver_connect_event not fond function error check
8853 std::cout << "[3] up_thread_realserver_connect_event not fond function error check" << std::endl;
8854 test_obj.up_thread_function_array_clear();
8855 proto_test.handle_realserver_connect_res_tag = l7vs::protocol_module_base::FINALIZE;
8856 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
8857 l7vs::Logger::putLogError_id = 0;
8858 test_obj.test_call();
8859 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
8860 BOOST_CHECK_EQUAL(40,l7vs::Logger::putLogError_id);
8861 std::cout << l7vs::Logger::putLogError_message << std::endl;
8863 // unit_test [4] up_thread_realserver_connect_event returnd illegal EVENT_TAG error check
8864 std::cout << "[4] up_thread_realserver_connect_event returnd illegal EVENT_TAG error check" << std::endl;
8865 test_obj.up_thread_module_event_map_clear();
8866 proto_test.handle_realserver_connect_res_tag = l7vs::protocol_module_base::FINALIZE;
8867 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
8868 l7vs::Logger::putLogError_id = 0;
8869 test_obj.test_call();
8870 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
8871 BOOST_CHECK_EQUAL(39,l7vs::Logger::putLogError_id);
8872 std::cout << l7vs::Logger::putLogError_message << std::endl;
8874 BOOST_MESSAGE( "----- up_thread_realserver_connect_event test end -----" );
8877 // up_thread_sorryserver_connect_event test
8878 // up_thread_sorryserver_connect_event test class
8879 class up_thread_sorryserver_connect_event_test_class : public module_event_map_test_base_class{
8881 // up_thread_sorryserver_connect_event_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : module_event_map_test_base_class(vs,session_io){
8883 up_thread_sorryserver_connect_event_test_class(
8884 l7vs::virtualservice_tcp& vs,
8885 boost::asio::io_service& session_io,
8886 l7vs::tcp_socket_option_info& set_socket_option,
8887 boost::asio::ip::tcp::endpoint listen_endpoint,
8889 boost::asio::ssl::context& set_ssl_context,
8890 bool set_ssl_cache_flag,
8891 int set_ssl_handshake_time_out,
8892 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
8899 set_ssl_handshake_time_out,
8900 set_access_logger){};
8902 ~up_thread_sorryserver_connect_event_test_class(){};
8905 l7vs::tcp_session::up_thread_sorryserver_connect_event(LOCAL_PROC);
8909 void up_thread_sorryserver_connect_event_test(){
8910 BOOST_MESSAGE( "----- up_thread_sorryserver_connect_event test start -----" );
8911 // boost::asio::io_service io;
8912 // l7vs::virtualservice_tcp vs;
8913 // up_thread_sorryserver_connect_event_test_class test_obj(vs,io);
8914 l7vs::virtualservice_tcp vs;
8915 boost::asio::io_service io;
8916 l7vs::tcp_socket_option_info set_option;
8917 //! TCP_NODELAY (false:not set,true:set option)
8918 set_option.nodelay_opt = false;
8919 //! TCP_NODELAY option value (false:off,true:on)
8920 set_option.nodelay_val = false;
8921 //! TCP_CORK (false:not set,true:set option)
8922 set_option.cork_opt = false;
8923 //! TCP_CORK option value (false:off,true:on)
8924 set_option.cork_val = false;
8925 //! TCP_QUICKACK (false:not set,true:set option)
8926 set_option.quickack_opt = false;
8927 //! TCP_QUICKACK option value (false:off,true:on)
8928 set_option.quickack_val = false;
8930 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
8931 bool set_mode(false);
8932 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
8933 bool set_ssl_cache_flag(false);
8934 int set_ssl_handshake_time_out = 0;
8935 //std::string access_log_file_name = "test";
8936 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
8938 up_thread_sorryserver_connect_event_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
8941 std::string test_protocol_name("test protocol");
8942 l7vs::test_protocol_module proto_test(test_protocol_name);
8944 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
8946 l7vs::protocol_module_base::EVENT_TAG chek_event[13];
8947 chek_event[0] = l7vs::protocol_module_base::ACCEPT;
8948 chek_event[1] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
8949 chek_event[2] = l7vs::protocol_module_base::CLIENT_RECV;
8950 chek_event[3] = l7vs::protocol_module_base::CLIENT_RESPONSE_SEND;
8951 chek_event[4] = l7vs::protocol_module_base::REALSERVER_SELECT;
8952 chek_event[5] = l7vs::protocol_module_base::REALSERVER_CONNECT;
8953 chek_event[6] = l7vs::protocol_module_base::REALSERVER_SEND;
8954 chek_event[7] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
8955 chek_event[8] = l7vs::protocol_module_base::SORRYSERVER_SELECT;
8956 chek_event[9] = l7vs::protocol_module_base::SORRYSERVER_CONNECT;
8957 chek_event[10] = l7vs::protocol_module_base::SORRYSERVER_SEND;
8958 chek_event[11] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
8959 chek_event[12] = l7vs::protocol_module_base::FINALIZE;
8961 // unit_test [1] up_thread_sorryserver_connect_event up_thread_next_call_function update check
8962 std::cout << "[1] up_thread_sorryserver_connect_event up_thread_next_call_function update check" << std::endl;
8963 for(int i = 0; i < 13;i++){
8964 proto_test.handle_sorryserver_connect_res_tag = chek_event[i];
8965 test_obj.test_call();
8966 BOOST_CHECK(test_obj.chk_up_thread_next_call_function(chek_event[i]));
8969 // unit_test [2] up_thread_sorryserver_connect_event module parameter check
8970 std::cout << "[2] up_thread_sorryserver_connect_event module parameter check" << std::endl;
8971 boost::thread::id def_id;
8972 boost::thread::id proc_id = boost::this_thread::get_id();
8973 test_obj.set_up_thread_id(proc_id);
8974 proto_test.handle_sorryserver_connect_thread_id = def_id;
8975 proto_test.handle_sorryserver_connect_res_tag = l7vs::protocol_module_base::FINALIZE;
8976 BOOST_CHECK(proto_test.handle_sorryserver_connect_thread_id != proc_id);
8977 char set_char = CHAR_MIN;
8978 for(int i = 0;i < MAX_BUFFER_SIZE;i++){
8979 proto_test.handle_sorryserver_connect_sendbuffer[i] = set_char;
8980 if(set_char == CHAR_MAX){
8981 set_char = CHAR_MIN;
8986 proto_test.handle_sorryserver_connect_datalen = MAX_BUFFER_SIZE;
8987 l7vs::tcp_data& test_data = test_obj.get_up_thread_data_dest_side();
8988 test_data.initialize();
8989 boost::asio::ip::tcp::endpoint server_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
8990 test_data.set_endpoint(server_end);
8992 test_obj.test_call();
8994 BOOST_CHECK(proto_test.handle_sorryserver_connect_thread_id == proc_id);
8995 BOOST_CHECK(proto_test.handle_sorryserver_connect_sendbuffer == test_data.get_data());
8996 BOOST_CHECK(proto_test.handle_sorryserver_connect_datalen == test_data.get_size());
8997 BOOST_CHECK(server_end == test_data.get_endpoint());
8999 // unit_test [3] up_thread_sorryserver_connect_event not fond function error check
9000 std::cout << "[3] up_thread_sorryserver_connect_event not fond function error check" << std::endl;
9001 test_obj.up_thread_function_array_clear();
9002 proto_test.handle_sorryserver_connect_res_tag = l7vs::protocol_module_base::FINALIZE;
9003 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
9004 l7vs::Logger::putLogError_id = 0;
9005 test_obj.test_call();
9006 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
9007 BOOST_CHECK_EQUAL(57,l7vs::Logger::putLogError_id);
9008 std::cout << l7vs::Logger::putLogError_message << std::endl;
9010 // unit_test [4] up_thread_sorryserver_connect_event returnd illegal EVENT_TAG error check
9011 std::cout << "[4] up_thread_sorryserver_connect_event returnd illegal EVENT_TAG error check" << std::endl;
9012 test_obj.up_thread_module_event_map_clear();
9013 proto_test.handle_sorryserver_connect_res_tag = l7vs::protocol_module_base::FINALIZE;
9014 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
9015 l7vs::Logger::putLogError_id = 0;
9016 test_obj.test_call();
9017 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
9018 BOOST_CHECK_EQUAL(56,l7vs::Logger::putLogError_id);
9019 std::cout << l7vs::Logger::putLogError_message << std::endl;
9021 BOOST_MESSAGE( "----- up_thread_sorryserver_connect_event test end -----" );
9023 // down_thread_client_connection_chk_event test
9024 // down_thread_client_connection_chk_event test class
9025 class down_thread_client_connection_chk_event_test_class : public module_event_map_test_base_class{
9027 // down_thread_client_connection_chk_event_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : module_event_map_test_base_class(vs,session_io){
9029 down_thread_client_connection_chk_event_test_class(
9030 l7vs::virtualservice_tcp& vs,
9031 boost::asio::io_service& session_io,
9032 l7vs::tcp_socket_option_info& set_socket_option,
9033 boost::asio::ip::tcp::endpoint listen_endpoint,
9035 boost::asio::ssl::context& set_ssl_context,
9036 bool set_ssl_cache_flag,
9037 int set_ssl_handshake_time_out,
9038 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
9045 set_ssl_handshake_time_out,
9046 set_access_logger){};
9048 ~down_thread_client_connection_chk_event_test_class(){};
9051 l7vs::tcp_session::down_thread_client_connection_chk_event(LOCAL_PROC);
9055 void down_thread_client_connection_chk_event_test(){
9056 BOOST_MESSAGE( "----- down_thread_client_connection_chk_event test start -----" );
9057 // boost::asio::io_service io;
9058 // l7vs::virtualservice_tcp vs;
9059 // down_thread_client_connection_chk_event_test_class test_obj(vs,io);
9060 l7vs::virtualservice_tcp vs;
9061 boost::asio::io_service io;
9062 l7vs::tcp_socket_option_info set_option;
9063 //! TCP_NODELAY (false:not set,true:set option)
9064 set_option.nodelay_opt = false;
9065 //! TCP_NODELAY option value (false:off,true:on)
9066 set_option.nodelay_val = false;
9067 //! TCP_CORK (false:not set,true:set option)
9068 set_option.cork_opt = false;
9069 //! TCP_CORK option value (false:off,true:on)
9070 set_option.cork_val = false;
9071 //! TCP_QUICKACK (false:not set,true:set option)
9072 set_option.quickack_opt = false;
9073 //! TCP_QUICKACK option value (false:off,true:on)
9074 set_option.quickack_val = false;
9076 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
9077 bool set_mode(false);
9078 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
9079 bool set_ssl_cache_flag(false);
9080 int set_ssl_handshake_time_out = 0;
9081 //std::string access_log_file_name = "test";
9082 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
9084 down_thread_client_connection_chk_event_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
9087 std::string test_protocol_name("test protocol");
9088 l7vs::test_protocol_module proto_test(test_protocol_name);
9090 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
9092 l7vs::protocol_module_base::EVENT_TAG chek_event[7];
9093 chek_event[0] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
9094 chek_event[1] = l7vs::protocol_module_base::CLIENT_CONNECTION_CHECK;
9095 chek_event[2] = l7vs::protocol_module_base::REALSERVER_RECV;
9096 chek_event[3] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
9097 chek_event[4] = l7vs::protocol_module_base::SORRYSERVER_RECV;
9098 chek_event[5] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
9099 chek_event[6] = l7vs::protocol_module_base::FINALIZE;
9101 // unit_test [1] down_thread_client_connection_chk_event down_thread_next_call_function update check
9102 std::cout << "[1] down_thread_client_connection_chk_event down_thread_next_call_function update check" << std::endl;
9103 for(int i = 0; i < 7;i++){
9104 proto_test.handle_client_connection_check_res_tag = chek_event[i];
9105 test_obj.test_call();
9106 BOOST_CHECK(test_obj.chk_down_thread_next_call_function(chek_event[i]));
9109 // unit_test [2] down_thread_client_connection_chk_event module parameter check
9110 std::cout << "[2] down_thread_client_connection_chk_event module parameter check" << std::endl;
9111 boost::thread::id def_id;
9112 boost::thread::id proc_id = boost::this_thread::get_id();
9113 test_obj.set_down_thread_id(proc_id);
9114 proto_test.handle_client_connection_check_thread_id = def_id;
9115 proto_test.handle_client_connection_check_res_tag = l7vs::protocol_module_base::FINALIZE;
9116 BOOST_CHECK(proto_test.handle_client_connection_check_thread_id != proc_id);
9117 char set_char = CHAR_MIN;
9118 for(int i = 0;i < MAX_BUFFER_SIZE;i++){
9119 proto_test.handle_client_connection_check_sendbuffer[i] = set_char;
9120 if(set_char == CHAR_MAX){
9121 set_char = CHAR_MIN;
9126 proto_test.handle_client_connection_check_datalen = MAX_BUFFER_SIZE;
9127 l7vs::tcp_data& test_data = test_obj.get_down_thread_data_client_side();
9128 test_data.initialize();
9130 test_obj.test_call();
9132 BOOST_CHECK(proto_test.handle_client_connection_check_thread_id == proc_id);
9133 BOOST_CHECK(proto_test.handle_client_connection_check_sendbuffer == test_data.get_data());
9134 BOOST_CHECK(proto_test.handle_client_connection_check_datalen == test_data.get_size());
9136 // unit_test [3] down_thread_client_connection_chk_event not fond function error check
9137 std::cout << "[3] down_thread_client_connection_chk_event not fond function error check" << std::endl;
9138 test_obj.down_thread_function_array_clear();
9139 proto_test.handle_client_connection_check_res_tag = l7vs::protocol_module_base::FINALIZE;
9140 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
9141 l7vs::Logger::putLogError_id = 0;
9142 test_obj.test_call();
9143 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
9144 BOOST_CHECK_EQUAL(79,l7vs::Logger::putLogError_id);
9145 std::cout << l7vs::Logger::putLogError_message << std::endl;
9147 // unit_test [4] down_thread_client_connection_chk_event returnd illegal EVENT_TAG error check
9148 std::cout << "[4] down_thread_client_connection_chk_event returnd illegal EVENT_TAG error check" << std::endl;
9149 test_obj.down_thread_module_event_map_clear();
9150 proto_test.handle_client_connection_check_res_tag = l7vs::protocol_module_base::FINALIZE;
9151 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
9152 l7vs::Logger::putLogError_id = 0;
9153 test_obj.test_call();
9154 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
9155 BOOST_CHECK_EQUAL(78,l7vs::Logger::putLogError_id);
9156 std::cout << l7vs::Logger::putLogError_message << std::endl;
9158 BOOST_MESSAGE( "----- down_thread_client_connection_chk_event test end -----" );
9160 // up_thread_realserver_connection_fail_event test
9161 // up_thread_realserver_connection_fail_event test class
9162 class up_thread_realserver_connection_fail_event_test_class : public module_event_map_test_base_class{
9164 // up_thread_realserver_connection_fail_event_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : module_event_map_test_base_class(vs,session_io){
9166 up_thread_realserver_connection_fail_event_test_class(
9167 l7vs::virtualservice_tcp& vs,
9168 boost::asio::io_service& session_io,
9169 l7vs::tcp_socket_option_info& set_socket_option,
9170 boost::asio::ip::tcp::endpoint listen_endpoint,
9172 boost::asio::ssl::context& set_ssl_context,
9173 bool set_ssl_cache_flag,
9174 int set_ssl_handshake_time_out,
9175 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
9182 set_ssl_handshake_time_out,
9183 set_access_logger){};
9185 ~up_thread_realserver_connection_fail_event_test_class(){};
9188 l7vs::tcp_session::up_thread_realserver_connection_fail_event(LOCAL_PROC);
9192 void up_thread_realserver_connection_fail_event_test(){
9193 BOOST_MESSAGE( "----- up_thread_realserver_connection_fail_event test start -----" );
9194 // boost::asio::io_service io;
9195 // l7vs::virtualservice_tcp vs;
9196 // up_thread_realserver_connection_fail_event_test_class test_obj(vs,io);
9197 l7vs::virtualservice_tcp vs;
9198 boost::asio::io_service io;
9199 l7vs::tcp_socket_option_info set_option;
9200 //! TCP_NODELAY (false:not set,true:set option)
9201 set_option.nodelay_opt = false;
9202 //! TCP_NODELAY option value (false:off,true:on)
9203 set_option.nodelay_val = false;
9204 //! TCP_CORK (false:not set,true:set option)
9205 set_option.cork_opt = false;
9206 //! TCP_CORK option value (false:off,true:on)
9207 set_option.cork_val = false;
9208 //! TCP_QUICKACK (false:not set,true:set option)
9209 set_option.quickack_opt = false;
9210 //! TCP_QUICKACK option value (false:off,true:on)
9211 set_option.quickack_val = false;
9213 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
9214 bool set_mode(false);
9215 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
9216 bool set_ssl_cache_flag(false);
9217 int set_ssl_handshake_time_out = 0;
9218 //std::string access_log_file_name = "test";
9219 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
9221 up_thread_realserver_connection_fail_event_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
9225 std::string test_protocol_name("test protocol");
9226 l7vs::test_protocol_module proto_test(test_protocol_name);
9228 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
9230 l7vs::protocol_module_base::EVENT_TAG chek_event[13];
9231 chek_event[0] = l7vs::protocol_module_base::ACCEPT;
9232 chek_event[1] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
9233 chek_event[2] = l7vs::protocol_module_base::CLIENT_RECV;
9234 chek_event[3] = l7vs::protocol_module_base::CLIENT_RESPONSE_SEND;
9235 chek_event[4] = l7vs::protocol_module_base::REALSERVER_SELECT;
9236 chek_event[5] = l7vs::protocol_module_base::REALSERVER_CONNECT;
9237 chek_event[6] = l7vs::protocol_module_base::REALSERVER_SEND;
9238 chek_event[7] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
9239 chek_event[8] = l7vs::protocol_module_base::SORRYSERVER_SELECT;
9240 chek_event[9] = l7vs::protocol_module_base::SORRYSERVER_CONNECT;
9241 chek_event[10] = l7vs::protocol_module_base::SORRYSERVER_SEND;
9242 chek_event[11] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
9243 chek_event[12] = l7vs::protocol_module_base::FINALIZE;
9245 // unit_test [1] up_thread_realserver_connection_fail_event up_thread_next_call_function update check
9246 std::cout << "[1] up_thread_realserver_connection_fail_event up_thread_next_call_function update check" << std::endl;
9247 for(int i = 0; i < 13;i++){
9248 proto_test.handle_realserver_connection_fail_res_tag = chek_event[i];
9249 test_obj.test_call();
9250 BOOST_CHECK(test_obj.chk_up_thread_next_call_function(chek_event[i]));
9253 // unit_test [2] up_thread_realserver_connection_fail_event module parameter check
9254 std::cout << "[2] up_thread_realserver_connection_fail_event module parameter check" << std::endl;
9255 boost::thread::id def_id;
9256 boost::thread::id proc_id = boost::this_thread::get_id();
9257 test_obj.set_up_thread_id(proc_id);
9258 proto_test.handle_realserver_connection_fail_thread_id = def_id;
9259 proto_test.handle_realserver_connection_fail_res_tag = l7vs::protocol_module_base::FINALIZE;
9260 BOOST_CHECK(proto_test.handle_realserver_connection_fail_thread_id != proc_id);
9261 boost::asio::ip::tcp::endpoint server_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
9262 l7vs::tcp_data& test_data = test_obj.get_up_thread_data_dest_side();
9263 test_data.set_endpoint(server_end);
9265 test_obj.test_call();
9267 BOOST_CHECK(proto_test.handle_realserver_connection_fail_thread_id == proc_id);
9268 BOOST_CHECK(server_end == test_data.get_endpoint());
9270 // unit_test [3] up_thread_realserver_connection_fail_event not fond function error check
9271 std::cout << "[3] up_thread_realserver_connection_fail_event not fond function error check" << std::endl;
9272 test_obj.up_thread_function_array_clear();
9273 proto_test.handle_realserver_connection_fail_res_tag = l7vs::protocol_module_base::FINALIZE;
9274 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
9275 l7vs::Logger::putLogError_id = 0;
9276 test_obj.test_call();
9277 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
9278 BOOST_CHECK_EQUAL(42,l7vs::Logger::putLogError_id);
9279 std::cout << l7vs::Logger::putLogError_message << std::endl;
9281 // unit_test [4] up_thread_realserver_connection_fail_event returnd illegal EVENT_TAG error check
9282 std::cout << "[4] up_thread_realserver_connection_fail_event returnd illegal EVENT_TAG error check" << std::endl;
9283 test_obj.up_thread_module_event_map_clear();
9284 proto_test.handle_realserver_connection_fail_res_tag = l7vs::protocol_module_base::FINALIZE;
9285 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
9286 l7vs::Logger::putLogError_id = 0;
9287 test_obj.test_call();
9288 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
9289 BOOST_CHECK_EQUAL(41,l7vs::Logger::putLogError_id);
9290 std::cout << l7vs::Logger::putLogError_message << std::endl;
9292 BOOST_MESSAGE( "----- up_thread_realserver_connection_fail_event test end -----" );
9295 // up_thread_sorryserver_connection_fail_event test
9296 // up_thread_sorryserver_connection_fail_event test class
9297 class up_thread_sorryserver_connection_fail_event_test_class : public module_event_map_test_base_class{
9299 // up_thread_sorryserver_connection_fail_event_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : module_event_map_test_base_class(vs,session_io){
9301 up_thread_sorryserver_connection_fail_event_test_class(
9302 l7vs::virtualservice_tcp& vs,
9303 boost::asio::io_service& session_io,
9304 l7vs::tcp_socket_option_info& set_socket_option,
9305 boost::asio::ip::tcp::endpoint listen_endpoint,
9307 boost::asio::ssl::context& set_ssl_context,
9308 bool set_ssl_cache_flag,
9309 int set_ssl_handshake_time_out,
9310 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
9317 set_ssl_handshake_time_out,
9318 set_access_logger){};
9320 ~up_thread_sorryserver_connection_fail_event_test_class(){};
9323 l7vs::tcp_session::up_thread_sorryserver_connection_fail_event(LOCAL_PROC);
9327 void up_thread_sorryserver_connection_fail_event_test(){
9328 BOOST_MESSAGE( "----- up_thread_sorryserver_connection_fail_event test start -----" );
9329 // boost::asio::io_service io;
9330 // l7vs::virtualservice_tcp vs;
9331 // up_thread_sorryserver_connection_fail_event_test_class test_obj(vs,io);
9332 l7vs::virtualservice_tcp vs;
9333 boost::asio::io_service io;
9334 l7vs::tcp_socket_option_info set_option;
9335 //! TCP_NODELAY (false:not set,true:set option)
9336 set_option.nodelay_opt = false;
9337 //! TCP_NODELAY option value (false:off,true:on)
9338 set_option.nodelay_val = false;
9339 //! TCP_CORK (false:not set,true:set option)
9340 set_option.cork_opt = false;
9341 //! TCP_CORK option value (false:off,true:on)
9342 set_option.cork_val = false;
9343 //! TCP_QUICKACK (false:not set,true:set option)
9344 set_option.quickack_opt = false;
9345 //! TCP_QUICKACK option value (false:off,true:on)
9346 set_option.quickack_val = false;
9348 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
9349 bool set_mode(false);
9350 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
9351 bool set_ssl_cache_flag(false);
9352 int set_ssl_handshake_time_out = 0;
9353 //std::string access_log_file_name = "test";
9354 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
9356 up_thread_sorryserver_connection_fail_event_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
9359 std::string test_protocol_name("test protocol");
9360 l7vs::test_protocol_module proto_test(test_protocol_name);
9362 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
9364 l7vs::protocol_module_base::EVENT_TAG chek_event[13];
9365 chek_event[0] = l7vs::protocol_module_base::ACCEPT;
9366 chek_event[1] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
9367 chek_event[2] = l7vs::protocol_module_base::CLIENT_RECV;
9368 chek_event[3] = l7vs::protocol_module_base::CLIENT_RESPONSE_SEND;
9369 chek_event[4] = l7vs::protocol_module_base::REALSERVER_SELECT;
9370 chek_event[5] = l7vs::protocol_module_base::REALSERVER_CONNECT;
9371 chek_event[6] = l7vs::protocol_module_base::REALSERVER_SEND;
9372 chek_event[7] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
9373 chek_event[8] = l7vs::protocol_module_base::SORRYSERVER_SELECT;
9374 chek_event[9] = l7vs::protocol_module_base::SORRYSERVER_CONNECT;
9375 chek_event[10] = l7vs::protocol_module_base::SORRYSERVER_SEND;
9376 chek_event[11] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
9377 chek_event[12] = l7vs::protocol_module_base::FINALIZE;
9379 // unit_test [1] up_thread_sorryserver_connection_fail_event up_thread_next_call_function update check
9380 std::cout << "[1] up_thread_sorryserver_connection_fail_event up_thread_next_call_function update check" << std::endl;
9381 for(int i = 0; i < 13;i++){
9382 proto_test.handle_sorryserver_connection_fail_res_tag = chek_event[i];
9383 test_obj.test_call();
9384 BOOST_CHECK(test_obj.chk_up_thread_next_call_function(chek_event[i]));
9387 // unit_test [2] up_thread_sorryserver_connection_fail_event module parameter check
9388 std::cout << "[2] up_thread_sorryserver_connection_fail_event module parameter check" << std::endl;
9389 boost::thread::id def_id;
9390 boost::thread::id proc_id = boost::this_thread::get_id();
9391 test_obj.set_up_thread_id(proc_id);
9392 proto_test.handle_sorryserver_connection_fail_thread_id = def_id;
9393 proto_test.handle_sorryserver_connection_fail_res_tag = l7vs::protocol_module_base::FINALIZE;
9394 BOOST_CHECK(proto_test.handle_sorryserver_connection_fail_thread_id != proc_id);
9395 boost::asio::ip::tcp::endpoint server_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
9396 l7vs::tcp_data& test_data = test_obj.get_up_thread_data_dest_side();
9397 test_data.set_endpoint(server_end);
9399 test_obj.test_call();
9401 BOOST_CHECK(proto_test.handle_sorryserver_connection_fail_thread_id == proc_id);
9402 BOOST_CHECK(server_end == test_data.get_endpoint());
9404 // unit_test [3] up_thread_sorryserver_connection_fail_event not fond function error check
9405 std::cout << "[3] up_thread_sorryserver_connection_fail_event not fond function error check" << std::endl;
9406 test_obj.up_thread_function_array_clear();
9407 proto_test.handle_sorryserver_connection_fail_res_tag = l7vs::protocol_module_base::FINALIZE;
9408 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
9409 l7vs::Logger::putLogError_id = 0;
9410 test_obj.test_call();
9411 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
9412 BOOST_CHECK_EQUAL(59,l7vs::Logger::putLogError_id);
9413 std::cout << l7vs::Logger::putLogError_message << std::endl;
9415 // unit_test [4] up_thread_sorryserver_connection_fail_event returnd illegal EVENT_TAG error check
9416 std::cout << "[4] up_thread_sorryserver_connection_fail_event returnd illegal EVENT_TAG error check" << std::endl;
9417 test_obj.up_thread_module_event_map_clear();
9418 proto_test.handle_sorryserver_connection_fail_res_tag = l7vs::protocol_module_base::FINALIZE;
9419 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
9420 l7vs::Logger::putLogError_id = 0;
9421 test_obj.test_call();
9422 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
9423 BOOST_CHECK_EQUAL(58,l7vs::Logger::putLogError_id);
9424 std::cout << l7vs::Logger::putLogError_message << std::endl;
9426 BOOST_MESSAGE( "----- up_thread_sorryserver_connection_fail_event test end -----" );
9429 // receive & send test class
9430 class receive_send_test_class : public l7vs::tcp_session{
9432 // receive_send_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){
9434 receive_send_test_class(
9435 l7vs::virtualservice_tcp& vs,
9436 boost::asio::io_service& session_io,
9437 l7vs::tcp_socket_option_info& set_socket_option,
9438 boost::asio::ip::tcp::endpoint listen_endpoint,
9440 boost::asio::ssl::context& set_ssl_context,
9441 bool set_ssl_cache_flag,
9442 int set_ssl_handshake_time_out,
9443 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
9450 set_ssl_handshake_time_out,
9451 set_access_logger){};
9453 ~receive_send_test_class(){};
9455 void test_call_client_receive(){
9456 l7vs::tcp_session::up_thread_client_receive(LOCAL_PROC);
9458 void test_call_client_send(){
9459 l7vs::tcp_session::down_thread_client_send(LOCAL_PROC);
9461 void test_call_realserver_receive(){
9462 l7vs::tcp_session::down_thread_realserver_receive(LOCAL_PROC);
9464 void test_call_realserver_send(){
9465 l7vs::tcp_session::up_thread_realserver_send(LOCAL_PROC);
9467 void test_call_sorryserver_receive(){
9468 l7vs::tcp_session::down_thread_sorryserver_receive(LOCAL_PROC);
9470 void test_call_sorryserver_send(){
9471 l7vs::tcp_session::up_thread_sorryserver_send(LOCAL_PROC);
9473 void set_protocol_module(l7vs::protocol_module_base* set_prot){
9474 protocol_module = set_prot;
9476 l7vs::tcp_data& get_up_thread_data_client_side(){
9477 return up_thread_data_client_side;
9479 l7vs::tcp_data& get_up_thread_data_dest_side(){
9480 return up_thread_data_dest_side;
9482 l7vs::tcp_data& get_down_thread_data_client_side(){
9483 return down_thread_data_client_side;
9485 l7vs::tcp_data& get_down_thread_data_dest_side(){
9486 return down_thread_data_dest_side;
9488 l7vs::tcp_socket& get_client_socket(){
9489 return client_socket;
9491 l7vs::tcp_ssl_socket& get_client_ssl_socket(){
9492 return client_ssl_socket;
9494 socket_element& get_sorryserver_socket(){
9495 return sorryserver_socket;
9497 std::list<socket_element>& get_down_thread_receive_realserver_socket_list(){
9498 return down_thread_receive_realserver_socket_list;
9500 std::map<endpoint,tcp_socket_ptr>& get_up_thread_send_realserver_socket_map(){
9501 return up_thread_send_realserver_socket_map;
9503 std::list<socket_element>::iterator& get_down_thread_current_receive_realserver_socket(){
9504 return down_thread_current_receive_realserver_socket;
9507 void set_up_thread_id(boost::thread::id set_id){
9508 up_thread_id = set_id;
9510 void set_down_thread_id(boost::thread::id set_id){
9511 down_thread_id = set_id;
9514 void next_up_function_call(){
9515 up_thread_next_call_function.second(LOCAL_PROC);
9517 void next_down_function_call(){
9518 down_thread_next_call_function.second(LOCAL_PROC);
9521 void set_up_thread_next_function_call_exit(){
9522 up_thread_function_pair fun_it = up_thread_function_array[UP_FUNC_EXIT];
9523 up_thread_next_call_function = fun_it;
9526 void set_down_thread_next_function_call_exit(){
9527 down_thread_function_pair fun_it = down_thread_function_array[DOWN_FUNC_EXIT];
9528 down_thread_next_call_function = fun_it;
9531 // next call function check
9532 void up_thread_realserver_get_destination_event(const TCP_PROCESS_TYPE_TAG process_type){
9533 up_thread_realserver_get_destination_event_call_check = true;
9535 bool up_thread_realserver_get_destination_event_call_check;
9536 void up_thread_sorryserver_get_destination_event(const TCP_PROCESS_TYPE_TAG process_type){
9537 up_thread_sorryserver_get_destination_event_call_check = true;
9539 bool up_thread_sorryserver_get_destination_event_call_check;
9541 void up_thread_client_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
9542 up_thread_client_disconnect_call_check = true;
9544 bool up_thread_client_disconnect_call_check;
9547 void down_thread_client_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
9548 down_thread_client_disconnect_call_check = true;
9550 bool down_thread_client_disconnect_call_check;
9552 void up_thread_realserver_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
9553 up_thread_realserver_disconnect_call_check = true;
9555 bool up_thread_realserver_disconnect_call_check;
9557 void up_thread_sorryserver_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
9558 up_thread_sorryserver_disconnect_call_check = true;
9560 bool up_thread_sorryserver_disconnect_call_check;
9562 void down_thread_realserver_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
9563 down_thread_realserver_disconnect_call_check = true;
9565 bool down_thread_realserver_disconnect_call_check;
9567 void down_thread_sorryserver_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
9568 down_thread_sorryserver_disconnect_call_check = true;
9570 bool down_thread_sorryserver_disconnect_call_check;
9572 void up_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
9573 up_thread_exit_call_check = true;
9575 bool up_thread_exit_call_check;
9577 void down_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
9578 down_thread_exit_call_check = true;
9580 bool down_thread_exit_call_check;
9582 void up_thread_client_receive(const TCP_PROCESS_TYPE_TAG process_type){
9583 up_thread_client_receive_call_check = true;
9584 tcp_session::up_thread_client_receive(process_type);
9586 bool up_thread_client_receive_call_check;
9588 void down_thread_realserver_receive(const TCP_PROCESS_TYPE_TAG process_type){
9589 down_thread_realserver_receive_call_check = true;
9590 tcp_session::down_thread_realserver_receive(process_type);
9592 bool down_thread_realserver_receive_call_check;
9594 void down_thread_sorryserver_receive(const TCP_PROCESS_TYPE_TAG process_type){
9595 down_thread_sorryserver_receive_call_check = true;
9596 tcp_session::down_thread_sorryserver_receive(process_type);
9598 bool down_thread_sorryserver_receive_call_check;
9600 void down_thread_client_send(const TCP_PROCESS_TYPE_TAG process_type){
9601 down_thread_client_send_call_check = true;
9603 bool down_thread_client_send_call_check;
9605 void up_thread_realserver_send(const TCP_PROCESS_TYPE_TAG process_type){
9606 up_thread_realserver_send_call_check = true;
9608 bool up_thread_realserver_send_call_check;
9610 void up_thread_sorryserver_send(const TCP_PROCESS_TYPE_TAG process_type){
9611 up_thread_sorryserver_send_call_check = true;
9613 bool up_thread_sorryserver_send_call_check;
9615 void down_thread_client_connection_chk_event(const TCP_PROCESS_TYPE_TAG process_type){
9616 down_thread_client_connection_chk_event_call_check = true;;
9618 bool down_thread_client_connection_chk_event_call_check;
9621 void up_thread_function_array_clear(){
9622 for(int i = 0;i <= UP_FUNC_EXIT;i++){
9623 up_thread_function_array[i].second = NULL;
9626 void down_thread_function_array_clear(){
9627 for(int i = 0; i <= DOWN_FUNC_EXIT;i++){
9628 down_thread_function_array[i].second = NULL;
9632 void up_thread_module_event_map_clear(){
9633 up_thread_module_event_map.clear();
9636 void down_thread_module_event_map_clear(){
9637 down_thread_module_event_map.clear();
9641 // up_thread_client_receive test
9642 void up_thread_client_receive_test(){
9643 BOOST_MESSAGE( "----- up_thread_client_receive test end -----" );
9645 l7vs::virtualservice_tcp vs;
9646 boost::asio::io_service io;
9647 l7vs::tcp_socket_option_info set_option;
9648 //! TCP_NODELAY (false:not set,true:set option)
9649 set_option.nodelay_opt = false;
9650 //! TCP_NODELAY option value (false:off,true:on)
9651 set_option.nodelay_val = false;
9652 //! TCP_CORK (false:not set,true:set option)
9653 set_option.cork_opt = false;
9654 //! TCP_CORK option value (false:off,true:on)
9655 set_option.cork_val = false;
9656 //! TCP_QUICKACK (false:not set,true:set option)
9657 set_option.quickack_opt = false;
9658 //! TCP_QUICKACK option value (false:off,true:on)
9659 set_option.quickack_val = false;
9661 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
9662 bool set_mode(false);
9663 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
9664 bool set_ssl_cache_flag(false);
9665 int set_ssl_handshake_time_out = 0;
9666 //std::string access_log_file_name = "test";
9667 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
9669 std::string test_protocol_name("test protocol");
9670 l7vs::test_protocol_module proto_test(test_protocol_name);
9671 // up_thread_client_receive
9672 receive_send_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
9674 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
9675 boost::thread::id proc_id = boost::this_thread::get_id();
9677 l7vs::tcp_data& up_thread_data_client_side = test_obj.get_up_thread_data_client_side();
9680 // get client socket
9681 l7vs::tcp_socket& socket = test_obj.get_client_socket();
9682 // dummy server client socket connect
9683 boost::system::error_code ec;
9684 test_mirror_server test_server;
9686 test_server.breq_acc_flag = true;
9688 test_server.breq_close_wait_flag = true;
9690 test_server.req_recv_cnt = 0;
9691 // test server start
9692 boost::thread server_thread(boost::bind(&test_mirror_server::run,&test_server));
9693 while( !test_server.brun_flag ){
9698 boost::asio::ip::tcp::endpoint connect_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
9699 socket.get_socket().connect(connect_end,ec);
9701 socket.is_open_res = true;
9703 while(!test_server.bconnect_flag){
9706 boost::asio::ip::tcp::endpoint local_endpoint = socket.get_socket().local_endpoint(ec);
9710 up_thread_data_client_side.initialize();
9711 test_obj.set_up_thread_id(proc_id);
9712 test_obj.set_down_thread_id(boost::thread::id());
9713 test_obj.up_thread_realserver_get_destination_event_call_check = false;
9714 test_obj.up_thread_client_disconnect_call_check = false;
9715 test_obj.up_thread_exit_call_check = false;
9716 test_obj.up_thread_client_receive_call_check = false;
9718 vs.get_wait_upstream_res = 0;
9719 vs.update_up_recv_size_in = 0;
9721 socket.read_some_res = MAX_BUFFER_SIZE;
9722 socket.read_some_ec.clear();
9723 char set_char = CHAR_MIN;
9724 for(int i = 0;i < MAX_BUFFER_SIZE;i++){
9725 socket.read_some_buffers_out[i] = set_char;
9726 if(set_char == CHAR_MAX)
9727 set_char = CHAR_MIN;
9731 socket.read_some_buffers_size_in = 0;
9732 socket.read_some_call_check = false;
9733 // protocol module set
9734 proto_test.handle_client_recv_res_tag = l7vs::protocol_module_base::REALSERVER_SELECT;
9735 proto_test.handle_client_recv_in_thread_id = boost::thread::id();
9736 for(int i = 0;i < MAX_BUFFER_SIZE;i++){
9737 proto_test.handle_client_recv_in_recvbuffer[i] = '\0';
9739 proto_test.handle_client_recv_in_recvlen = 0;
9741 l7vs::Logger::test_loglevel = l7vs::LOG_LV_DEBUG;
9742 l7vs::Logger::putLogDebug_category = l7vs::LOG_CAT_NONE;
9743 l7vs::Logger::putLogDebug_id = 0;
9745 test_obj.test_call_client_receive();
9747 // unit_test [1] up_thread_client_receive client_socket read_some call check
9748 std::cout << "[1] up_thread_client_receive client_socket read_some call check" << std::endl;
9749 BOOST_CHECK(socket.read_some_call_check);
9750 BOOST_CHECK(socket.read_some_buffers_out == up_thread_data_client_side.get_data());
9751 BOOST_CHECK(socket.read_some_buffers_size_in == MAX_BUFFER_SIZE);
9752 BOOST_CHECK(socket.read_some_res == up_thread_data_client_side.get_size());
9754 // unit_test [2] up_thread_client_receive virtualservice update_up_recv_size_in call check
9755 std::cout << "[2] up_thread_client_receive virtualservice update_up_recv_size_in call check" << std::endl;
9756 BOOST_CHECK(vs.update_up_recv_size_in == MAX_BUFFER_SIZE);
9758 // unit_test [3] up_thread_client_receive protocol module handle_client_recv call check
9759 std::cout << "[3] up_thread_client_receive protocol module handle_client_recv call check" << std::endl;
9760 BOOST_CHECK(proto_test.handle_client_recv_in_thread_id == proc_id);
9761 BOOST_CHECK(proto_test.handle_client_recv_in_recvlen == socket.read_some_res);
9762 BOOST_CHECK(proto_test.handle_client_recv_in_recvbuffer == socket.read_some_buffers_out);
9764 // unit_test [4] up_thread_client_receive up_thread_next_call_function update check
9765 std::cout << "[4] up_thread_client_receive up_thread_next_call_function update check" << std::endl;
9766 test_obj.next_up_function_call();
9767 BOOST_CHECK(test_obj.up_thread_realserver_get_destination_event_call_check);
9769 // unit_test [5] up_thread_client_receive qos check
9770 std::cout << "[5] up_thread_client_receive qos check" << std::endl;
9771 socket.read_some_res = 0;
9772 vs.get_wait_upstream_res = 1;
9774 // wait = 0 >> receive
9775 socket.read_some_call_check = false;
9776 vs.get_wait_upstream_res = 0;
9777 test_obj.test_call_client_receive();
9778 BOOST_CHECK(socket.read_some_call_check);
9780 // wait = 1 >> not receive
9781 socket.read_some_call_check = false;
9782 vs.get_wait_upstream_res = 1;
9783 test_obj.test_call_client_receive();
9784 BOOST_CHECK(!socket.read_some_call_check);
9785 std::cout << l7vs::Logger::putLogDebug_message << std::endl;
9787 socket.read_some_res = MAX_BUFFER_SIZE;
9788 vs.get_throughput_upstream_res = 0;
9789 vs.get_wait_upstream_res = 0;
9791 // unit_test [6] up_thread_client_receive receive size 0 check
9792 std::cout << "[6] up_thread_client_receive receive size 0 check" << std::endl;
9793 test_obj.set_up_thread_next_function_call_exit();
9794 socket.read_some_res = 0;
9795 test_obj.test_call_client_receive();
9796 test_obj.up_thread_client_receive_call_check = false;
9797 test_obj.next_up_function_call();
9798 BOOST_CHECK(test_obj.up_thread_client_receive_call_check);
9799 socket.read_some_res = MAX_BUFFER_SIZE;
9801 // unit_test [7] up_thread_client_receive socket error (try_again) check
9802 std::cout << "[7] up_thread_client_receive socket error (try_again) check" << std::endl;
9803 test_obj.set_up_thread_next_function_call_exit();
9804 socket.read_some_ec = boost::asio::error::try_again;
9805 test_obj.test_call_client_receive();
9806 test_obj.up_thread_client_receive_call_check = false;
9807 test_obj.next_up_function_call();
9808 BOOST_CHECK(test_obj.up_thread_client_receive_call_check);
9809 socket.read_some_ec.clear();
9811 // unit_test [8] up_thread_client_receive socket error (eof) check
9812 std::cout << "[8] up_thread_client_receive socket error (eof) check" << std::endl;
9813 test_obj.set_up_thread_next_function_call_exit();
9814 socket.read_some_ec = boost::asio::error::eof;
9815 test_obj.test_call_client_receive();
9816 test_obj.up_thread_client_disconnect_call_check = false;
9817 test_obj.next_up_function_call();
9818 BOOST_CHECK(test_obj.up_thread_client_disconnect_call_check);
9819 socket.read_some_ec.clear();
9821 // unit_test [9] up_thread_client_receive socket error (connection_reset) check
9822 std::cout << "[9] up_thread_client_receive socket error (connection_reset) check" << std::endl;
9823 test_obj.set_up_thread_next_function_call_exit();
9824 socket.read_some_ec = boost::asio::error::connection_reset;
9825 test_obj.test_call_client_receive();
9826 test_obj.up_thread_client_disconnect_call_check = false;
9827 test_obj.next_up_function_call();
9828 BOOST_CHECK(test_obj.up_thread_client_disconnect_call_check);
9829 socket.read_some_ec.clear();
9831 // unit_test [10] up_thread_client_receive socket error (bad_descriptor) check
9832 std::cout << "[10] up_thread_client_receive socket error (bad_descriptor) check" << std::endl;
9833 test_obj.set_up_thread_next_function_call_exit();
9834 socket.read_some_ec = boost::asio::error::bad_descriptor;
9835 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
9836 l7vs::Logger::putLogError_id = 0;
9837 test_obj.test_call_client_receive();
9838 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_NONE,l7vs::Logger::putLogError_category);
9839 BOOST_CHECK_EQUAL(0,l7vs::Logger::putLogError_id);
9840 test_obj.up_thread_client_disconnect_call_check = false;
9841 test_obj.next_up_function_call();
9842 BOOST_CHECK(test_obj.up_thread_client_disconnect_call_check);
9843 socket.read_some_ec.clear();
9845 // unit_test [11] up_thread_client_receive closed socket error (bad_descriptor) check
9846 std::cout << "[11] up_thread_client_receive closed socket error (bad_descriptor) check" << std::endl;
9847 test_obj.set_up_thread_next_function_call_exit();
9848 socket.read_some_ec = boost::asio::error::bad_descriptor;
9849 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
9850 l7vs::Logger::putLogError_id = 0;
9851 socket.is_open_res = false;
9852 test_obj.test_call_client_receive();
9853 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_NONE,l7vs::Logger::putLogError_category);
9854 BOOST_CHECK_EQUAL(0,l7vs::Logger::putLogError_id);
9855 test_obj.up_thread_client_disconnect_call_check = false;
9856 test_obj.next_up_function_call();
9857 BOOST_CHECK(test_obj.up_thread_client_disconnect_call_check);
9858 socket.read_some_ec.clear();
9860 // unit_test [12] up_thread_client_receive not fond function error check
9861 std::cout << "[12] up_thread_client_receive not fond function error check" << std::endl;
9862 test_obj.up_thread_function_array_clear();
9863 test_obj.up_thread_exit_call_check = false;
9864 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
9865 l7vs::Logger::putLogError_id = 0;
9866 test_obj.test_call_client_receive();
9867 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
9868 BOOST_CHECK_EQUAL(21,l7vs::Logger::putLogError_id);
9869 std::cout << l7vs::Logger::putLogError_message << std::endl;
9870 BOOST_CHECK(test_obj.up_thread_exit_call_check);
9872 // unit_test [13] up_thread_client_receive returnd illegal EVENT_TAG error check
9873 std::cout << "[13] up_thread_client_receive returnd illegal EVENT_TAG error check" << std::endl;
9874 test_obj.up_thread_module_event_map_clear();
9875 test_obj.up_thread_exit_call_check = false;
9876 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
9877 l7vs::Logger::putLogError_id = 0;
9878 test_obj.test_call_client_receive();
9879 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
9880 BOOST_CHECK_EQUAL(20,l7vs::Logger::putLogError_id);
9881 std::cout << l7vs::Logger::putLogError_message << std::endl;
9882 BOOST_CHECK(test_obj.up_thread_exit_call_check);
9884 // dummy server stop
9885 test_server.breq_close_wait_flag = false;
9886 test_server.bstop_flag = true;
9887 server_thread.join();
9891 receive_send_test_class test_ssl_mode_obj(vs,io,set_option,listen_endpoint,true,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
9892 test_ssl_mode_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
9893 l7vs::tcp_ssl_socket& ssl_socket = test_ssl_mode_obj.get_client_ssl_socket();
9894 l7vs::tcp_data& up_thread_data_ssl_client_side = test_ssl_mode_obj.get_up_thread_data_client_side();
9897 up_thread_data_ssl_client_side.initialize();
9898 test_ssl_mode_obj.set_up_thread_id(proc_id);
9899 test_ssl_mode_obj.set_down_thread_id(boost::thread::id());
9900 test_ssl_mode_obj.up_thread_realserver_get_destination_event_call_check = false;
9901 test_ssl_mode_obj.up_thread_client_disconnect_call_check = false;
9902 test_ssl_mode_obj.up_thread_exit_call_check = false;
9903 test_ssl_mode_obj.up_thread_client_receive_call_check = false;
9906 vs.get_wait_upstream_res = 0;
9907 vs.update_up_recv_size_in = 0;
9910 ssl_socket.read_some_res = MAX_BUFFER_SIZE;
9911 ssl_socket.read_some_ec.clear();
9912 set_char = CHAR_MIN;
9913 for(int i = 0;i < MAX_BUFFER_SIZE;i++){
9914 ssl_socket.read_some_buffers_out[i] = set_char;
9915 if(set_char == CHAR_MAX)
9916 set_char = CHAR_MIN;
9920 ssl_socket.read_some_buffers_size_in = 0;
9921 ssl_socket.read_some_call_check = false;
9923 // protocol module set
9924 proto_test.handle_client_recv_res_tag = l7vs::protocol_module_base::REALSERVER_SELECT;
9925 proto_test.handle_client_recv_in_thread_id = boost::thread::id();
9926 for(int i = 0;i < MAX_BUFFER_SIZE;i++){
9927 proto_test.handle_client_recv_in_recvbuffer[i] = '\0';
9929 proto_test.handle_client_recv_in_recvlen = 0;
9931 l7vs::Logger::test_loglevel = l7vs::LOG_LV_DEBUG;
9932 l7vs::Logger::putLogDebug_category = l7vs::LOG_CAT_NONE;
9933 l7vs::Logger::putLogDebug_id = 0;
9935 test_ssl_mode_obj.test_call_client_receive();
9937 // unit_test [14] up_thread_client_receive ssl mode client_ssl_socket read_some call check
9938 std::cout << "[14] up_thread_client_receive ssl mode client_ssl_socket read_some call check" << std::endl;
9939 BOOST_CHECK(ssl_socket.read_some_call_check);
9940 BOOST_CHECK(ssl_socket.read_some_buffers_out == up_thread_data_ssl_client_side.get_data());
9941 BOOST_CHECK(ssl_socket.read_some_buffers_size_in == MAX_BUFFER_SIZE);
9942 BOOST_CHECK(ssl_socket.read_some_res == up_thread_data_ssl_client_side.get_size());
9944 BOOST_MESSAGE( "----- up_thread_client_receive test end -----" );
9948 // down_thread_realserver_receive test
9949 void down_thread_realserver_receive_test(){
9950 BOOST_MESSAGE( "----- down_thread_realserver_receive test start -----" );
9951 // boost::asio::io_service io;
9952 // l7vs::virtualservice_tcp vs;
9953 l7vs::virtualservice_tcp vs;
9954 boost::asio::io_service io;
9955 l7vs::tcp_socket_option_info set_option;
9956 //! TCP_NODELAY (false:not set,true:set option)
9957 set_option.nodelay_opt = false;
9958 //! TCP_NODELAY option value (false:off,true:on)
9959 set_option.nodelay_val = false;
9960 //! TCP_CORK (false:not set,true:set option)
9961 set_option.cork_opt = false;
9962 //! TCP_CORK option value (false:off,true:on)
9963 set_option.cork_val = false;
9964 //! TCP_QUICKACK (false:not set,true:set option)
9965 set_option.quickack_opt = false;
9966 //! TCP_QUICKACK option value (false:off,true:on)
9967 set_option.quickack_val = false;
9969 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
9970 bool set_mode(false);
9971 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
9972 bool set_ssl_cache_flag(false);
9973 int set_ssl_handshake_time_out = 0;
9974 //std::string access_log_file_name = "test";
9975 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
9977 std::string test_protocol_name("test protocol");
9978 l7vs::test_protocol_module proto_test(test_protocol_name);
9979 // receive_send_test_class test_obj(vs,io);
9980 receive_send_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
9983 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
9984 boost::thread::id proc_id = boost::this_thread::get_id();
9986 l7vs::tcp_data& down_thread_data_dest_side = test_obj.get_down_thread_data_dest_side();
9988 // set realserver socket
9989 std::list< std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > >& rs_list = test_obj.get_down_thread_receive_realserver_socket_list();
9990 std::list< std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > >::iterator& rs_cur = test_obj.get_down_thread_current_receive_realserver_socket();
9991 std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > push_pair;
9993 for(int i = 0 ; i < 3 ;i++){
9994 boost::shared_ptr< l7vs::tcp_socket > new_socket(new l7vs::tcp_socket(io));
9995 push_pair.first.address(boost::asio::ip::address::from_string(DUMMI_SERVER_IP));
9996 push_pair.first.port(7000+i);
9997 push_pair.second = new_socket;
9999 new_socket->read_some_res = MAX_BUFFER_SIZE;
10000 new_socket->read_some_ec.clear();
10001 new_socket->is_open_res = true;
10002 char set_char = CHAR_MIN;
10003 for(int j = 0;j < MAX_BUFFER_SIZE;j++){
10004 new_socket->read_some_buffers_out[j] = set_char;
10005 if(set_char == CHAR_MAX)
10006 set_char = CHAR_MIN;
10010 new_socket->read_some_buffers_size_in = 0;
10011 new_socket->read_some_call_check = false;
10012 rs_list.push_back(push_pair);
10014 rs_cur = rs_list.begin();
10017 down_thread_data_dest_side.initialize();
10018 test_obj.set_down_thread_id(proc_id);
10019 test_obj.set_up_thread_id(boost::thread::id());
10020 test_obj.down_thread_client_connection_chk_event_call_check = false;
10021 test_obj.down_thread_realserver_disconnect_call_check = false;
10022 test_obj.down_thread_exit_call_check = false;
10023 test_obj.down_thread_realserver_receive_call_check = false;
10025 // vs.get_qos_downstream_res = 104857600;
10026 // vs.get_throughput_downstream_res = 0;
10027 vs.get_wait_downstream_res = 0;
10028 vs.update_down_recv_size_in = 0;
10029 // protocol module set
10030 proto_test.handle_realserver_recv_tcp_res_tag = l7vs::protocol_module_base::CLIENT_CONNECTION_CHECK;
10031 proto_test.handle_realserver_recv_tcp_in_thread_id = boost::thread::id();
10032 for(int i = 0;i < MAX_BUFFER_SIZE;i++){
10033 proto_test.handle_realserver_recv_tcp_in_recvbuffer[i] = '\0';
10035 proto_test.handle_realserver_recv_tcp_in_recvlen = 0;
10036 proto_test.handle_realserver_recv_tcp_in_rs_endpoint = boost::asio::ip::tcp::endpoint();
10038 boost::asio::ip::tcp::endpoint rs_end = rs_cur->first;
10039 l7vs::tcp_socket& socket = *(rs_cur->second);
10040 l7vs::Logger::test_loglevel = l7vs::LOG_LV_DEBUG;
10041 l7vs::Logger::putLogDebug_category = l7vs::LOG_CAT_NONE;
10042 l7vs::Logger::putLogDebug_id = 0;
10044 test_obj.test_call_realserver_receive();
10046 // unit_test [1] down_thread_realserver_receive realserver read_some call check
10047 std::cout << "[1] down_thread_realserver_receive realserver read_some call check" << std::endl;
10048 BOOST_CHECK(socket.read_some_call_check);
10049 BOOST_CHECK(socket.read_some_buffers_out == down_thread_data_dest_side.get_data());
10050 BOOST_CHECK(socket.read_some_buffers_size_in == MAX_BUFFER_SIZE);
10051 BOOST_CHECK(socket.read_some_res == down_thread_data_dest_side.get_size());
10052 BOOST_CHECK(rs_end == down_thread_data_dest_side.get_endpoint());
10054 // unit_test [2] down_thread_realserver_receive virtualservice update_down_recv_size_in call check
10055 std::cout << "[2] down_thread_realserver_receive virtualservice update_down_recv_size_in call check" << std::endl;
10056 BOOST_CHECK(vs.update_down_recv_size_in == MAX_BUFFER_SIZE);
10058 // unit_test [3] down_thread_realserver_receive protocol module handle_realserver_recv call check
10059 std::cout << "[3] down_thread_realserver_receive protocol module handle_realserver_recv call check" << std::endl;
10060 BOOST_CHECK(proto_test.handle_realserver_recv_tcp_in_thread_id == proc_id);
10061 BOOST_CHECK(proto_test.handle_realserver_recv_tcp_in_recvlen == socket.read_some_res);
10062 BOOST_CHECK(proto_test.handle_realserver_recv_tcp_in_recvbuffer == socket.read_some_buffers_out);
10063 BOOST_CHECK(proto_test.handle_realserver_recv_tcp_in_rs_endpoint == rs_end);
10065 // unit_test [4] down_thread_realserver_receive down_thread_next_call_function update check
10066 std::cout << "[4] down_thread_realserver_receive down_thread_next_call_function update check" << std::endl;
10067 test_obj.next_down_function_call();
10068 BOOST_CHECK(test_obj.down_thread_client_connection_chk_event_call_check);
10070 // unit_test [5] down_thread_realserver_receive realserver_recv down_thread_current_receive_realserver_socket inclement & cyclic check
10071 std::cout << "[5] down_thread_realserver_receive realserver_recv down_thread_current_receive_realserver_socket inclement & cyclic check" << std::endl;
10072 std::list< std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > >::iterator check_it;
10073 rs_cur = rs_list.begin();
10074 check_it = rs_list.begin();
10075 test_obj.test_call_realserver_receive();
10077 BOOST_CHECK(check_it == rs_cur);
10078 test_obj.test_call_realserver_receive();
10080 BOOST_CHECK(check_it == rs_cur);
10081 test_obj.test_call_realserver_receive();
10082 check_it = rs_list.begin();
10083 BOOST_CHECK(check_it == rs_cur);
10085 // unit_test [6] down_thread_realserver_receive qos check
10086 std::cout << "[6] down_thread_realserver_receive qos check" << std::endl;
10087 socket.read_some_res = 0;
10089 // wait = 0 >> receive
10090 rs_cur = rs_list.begin();
10091 socket.read_some_call_check = false;
10092 vs.get_wait_downstream_res = 0;
10093 test_obj.test_call_realserver_receive();
10094 BOOST_CHECK(socket.read_some_call_check);
10096 // wait = 1 >> not receive
10097 rs_cur = rs_list.begin();
10098 socket.read_some_call_check = false;
10099 vs.get_wait_downstream_res = 1;
10100 test_obj.test_call_realserver_receive();
10101 BOOST_CHECK(!socket.read_some_call_check);
10103 socket.read_some_res = MAX_BUFFER_SIZE;
10104 vs.get_throughput_downstream_res = 0;
10105 vs.get_wait_downstream_res = 0;
10107 // unit_test [7] down_thread_realserver_receive receive size 0 check
10108 std::cout << "[7] down_thread_realserver_receive receive size 0 check" << std::endl;
10109 rs_cur = rs_list.begin();
10110 test_obj.set_down_thread_next_function_call_exit();
10111 socket.read_some_res = 0;
10112 test_obj.test_call_realserver_receive();
10113 test_obj.down_thread_realserver_receive_call_check = false;
10114 test_obj.next_down_function_call();
10115 BOOST_CHECK(test_obj.down_thread_realserver_receive_call_check);
10116 socket.read_some_res = MAX_BUFFER_SIZE;
10118 // unit_test [8] down_thread_realserver_receive socket error (try_again) check
10119 std::cout << "[8] down_thread_realserver_receive socket error (try_again) check" << std::endl;
10120 rs_cur = rs_list.begin();
10121 test_obj.set_down_thread_next_function_call_exit();
10122 socket.read_some_ec = boost::asio::error::try_again;
10123 test_obj.test_call_realserver_receive();
10124 test_obj.down_thread_realserver_receive_call_check = false;
10125 test_obj.next_down_function_call();
10126 BOOST_CHECK(test_obj.down_thread_realserver_receive_call_check);
10127 socket.read_some_ec.clear();
10129 // unit_test [9] down_thread_realserver_receive socket error (eof) check
10130 std::cout << "[9] down_thread_realserver_receive socket error (eof) check" << std::endl;
10131 rs_cur = rs_list.begin();
10132 test_obj.set_down_thread_next_function_call_exit();
10133 socket.read_some_ec = boost::asio::error::eof;
10134 test_obj.test_call_realserver_receive();
10135 test_obj.down_thread_realserver_disconnect_call_check = false;
10136 test_obj.next_down_function_call();
10137 BOOST_CHECK(test_obj.down_thread_realserver_disconnect_call_check);
10138 socket.read_some_ec.clear();
10140 // unit_test [10] down_thread_realserver_receive socket error (connection_reset) check
10141 std::cout << "[10] down_thread_realserver_receive socket error (connection_reset) check" << std::endl;
10142 rs_cur = rs_list.begin();
10143 test_obj.set_down_thread_next_function_call_exit();
10144 socket.read_some_ec = boost::asio::error::connection_reset;
10145 test_obj.test_call_realserver_receive();
10146 test_obj.down_thread_realserver_disconnect_call_check = false;
10147 test_obj.next_down_function_call();
10148 BOOST_CHECK(test_obj.down_thread_realserver_disconnect_call_check);
10149 socket.read_some_ec.clear();
10151 // unit_test [11] down_thread_realserver_receive socket error (bad_descriptor) check
10152 std::cout << "[11] down_thread_realserver_receive socket error (bad_descriptor) check" << std::endl;
10153 rs_cur = rs_list.begin();
10154 test_obj.set_down_thread_next_function_call_exit();
10155 socket.read_some_ec = boost::asio::error::bad_descriptor;
10156 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
10157 l7vs::Logger::putLogError_id = 0;
10158 test_obj.test_call_realserver_receive();
10159 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_NONE,l7vs::Logger::putLogError_category);
10160 BOOST_CHECK_EQUAL(0,l7vs::Logger::putLogError_id);
10161 std::cout << l7vs::Logger::putLogError_message << std::endl;
10162 test_obj.down_thread_realserver_disconnect_call_check = false;
10163 test_obj.next_down_function_call();
10164 BOOST_CHECK(test_obj.down_thread_realserver_disconnect_call_check);
10165 socket.read_some_ec.clear();
10167 // unit_test [12] down_thread_realserver_receive closed socket error (bad_descriptor) check
10168 std::cout << "[12] down_thread_realserver_receive closed socket error (bad_descriptor) check" << std::endl;
10169 rs_cur = rs_list.begin();
10170 test_obj.set_down_thread_next_function_call_exit();
10171 socket.read_some_ec = boost::asio::error::bad_descriptor;
10172 socket.is_open_res = false;
10173 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
10174 l7vs::Logger::putLogError_id = 0;
10175 test_obj.test_call_realserver_receive();
10176 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_NONE,l7vs::Logger::putLogError_category);
10177 BOOST_CHECK_EQUAL(0,l7vs::Logger::putLogError_id);
10178 test_obj.down_thread_realserver_disconnect_call_check = false;
10179 test_obj.next_down_function_call();
10180 BOOST_CHECK(test_obj.down_thread_realserver_disconnect_call_check);
10181 socket.read_some_ec.clear();
10183 // unit_test [13] down_thread_realserver_receive not fond function error check
10184 std::cout << "[13] down_thread_realserver_receive not fond function error check" << std::endl;
10185 test_obj.down_thread_function_array_clear();
10186 test_obj.down_thread_exit_call_check = false;
10187 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
10188 l7vs::Logger::putLogError_id = 0;
10189 test_obj.test_call_realserver_receive();
10190 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
10191 BOOST_CHECK_EQUAL(71,l7vs::Logger::putLogError_id);
10192 std::cout << l7vs::Logger::putLogError_message << std::endl;
10193 BOOST_CHECK(test_obj.down_thread_exit_call_check);
10195 // unit_test [14] down_thread_realserver_receive returnd illegal EVENT_TAG error check
10196 std::cout << "[14] down_thread_realserver_receive returnd illegal EVENT_TAG error check" << std::endl;
10197 test_obj.down_thread_module_event_map_clear();
10198 test_obj.down_thread_exit_call_check = false;
10199 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
10200 l7vs::Logger::putLogError_id = 0;
10201 test_obj.test_call_realserver_receive();
10202 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
10203 BOOST_CHECK_EQUAL(70,l7vs::Logger::putLogError_id);
10204 std::cout << l7vs::Logger::putLogError_message << std::endl;
10205 BOOST_CHECK(test_obj.down_thread_exit_call_check);
10207 // unit_test [15] down_thread_realserver_receive empty down_thread_receive_realserver_socket_list check
10208 std::cout << "[15] down_thread_realserver_receive empty down_thread_receive_realserver_socket_list check" << std::endl;
10209 rs_cur = rs_list.begin();
10210 std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > sock_pair = *rs_cur;
10212 // BOOST_CHECK(*rs_cur == sock_pair);
10213 socket.read_some_call_check = false;
10214 test_obj.test_call_realserver_receive();
10215 BOOST_CHECK(!socket.read_some_call_check);
10217 BOOST_MESSAGE( "----- down_thread_realserver_receive test end -----" );
10220 // down_thread_sorryserver_receive test
10221 void down_thread_sorryserver_receive_test(){
10222 BOOST_MESSAGE( "----- down_thread_sorryserver_receive test start -----" );
10223 // boost::asio::io_service io;
10224 // l7vs::virtualservice_tcp vs;
10225 l7vs::virtualservice_tcp vs;
10226 boost::asio::io_service io;
10227 l7vs::tcp_socket_option_info set_option;
10228 //! TCP_NODELAY (false:not set,true:set option)
10229 set_option.nodelay_opt = false;
10230 //! TCP_NODELAY option value (false:off,true:on)
10231 set_option.nodelay_val = false;
10232 //! TCP_CORK (false:not set,true:set option)
10233 set_option.cork_opt = false;
10234 //! TCP_CORK option value (false:off,true:on)
10235 set_option.cork_val = false;
10236 //! TCP_QUICKACK (false:not set,true:set option)
10237 set_option.quickack_opt = false;
10238 //! TCP_QUICKACK option value (false:off,true:on)
10239 set_option.quickack_val = false;
10241 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
10242 bool set_mode(false);
10243 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
10244 bool set_ssl_cache_flag(false);
10245 int set_ssl_handshake_time_out = 0;
10246 //std::string access_log_file_name = "test";
10247 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
10249 std::string test_protocol_name("test protocol");
10250 l7vs::test_protocol_module proto_test(test_protocol_name);
10251 // receive_send_test_class test_obj(vs,io);
10252 receive_send_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
10254 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
10255 boost::thread::id proc_id = boost::this_thread::get_id();
10257 l7vs::tcp_data& down_thread_data_dest_side = test_obj.get_down_thread_data_dest_side();
10259 // set sorryserver socket
10260 std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > >& socket_pair = test_obj.get_sorryserver_socket();
10261 boost::asio::ip::tcp::endpoint& sorry_end = socket_pair.first;
10262 l7vs::tcp_socket& socket = *(socket_pair.second);
10263 sorry_end.address(boost::asio::ip::address::from_string(DUMMI_SERVER_IP));
10264 sorry_end.port(7000);
10266 socket.read_some_res = MAX_BUFFER_SIZE;
10267 socket.read_some_ec.clear();
10268 socket.is_open_res = true;
10269 char set_char = CHAR_MIN;
10270 for(int j = 0;j < MAX_BUFFER_SIZE;j++){
10271 socket.read_some_buffers_out[j] = set_char;
10272 if(set_char == CHAR_MAX)
10273 set_char = CHAR_MIN;
10277 socket.read_some_buffers_size_in = 0;
10278 socket.read_some_call_check = false;
10280 down_thread_data_dest_side.initialize();
10281 test_obj.set_down_thread_id(proc_id);
10282 test_obj.set_up_thread_id(boost::thread::id());
10283 test_obj.down_thread_client_connection_chk_event_call_check = false;
10284 test_obj.down_thread_realserver_disconnect_call_check = false;
10285 test_obj.down_thread_exit_call_check = false;
10286 test_obj.down_thread_realserver_receive_call_check = false;
10288 vs.get_qos_downstream_res = 104857600;
10289 vs.get_throughput_downstream_res = 0;
10290 vs.update_down_recv_size_in = 0;
10291 // protocol module set
10292 proto_test.handle_sorryserver_recv_res_tag = l7vs::protocol_module_base::CLIENT_CONNECTION_CHECK;
10293 proto_test.handle_sorryserver_recv_in_thread_id = boost::thread::id();
10294 for(int i = 0;i < MAX_BUFFER_SIZE;i++){
10295 proto_test.handle_sorryserver_recv_in_recvbuffer[i] = '\0';
10297 proto_test.handle_sorryserver_recv_in_recvlen = 0;
10298 proto_test.handle_sorryserver_recv_in_sorry_endpoint = boost::asio::ip::tcp::endpoint();
10300 l7vs::Logger::test_loglevel = l7vs::LOG_LV_DEBUG;
10301 l7vs::Logger::putLogDebug_category = l7vs::LOG_CAT_NONE;
10302 l7vs::Logger::putLogDebug_id = 0;
10304 test_obj.test_call_sorryserver_receive();
10306 // unit_test [1] down_thread_sorryserver_receive sorryserver read_some call check
10307 std::cout << "[1] down_thread_sorryserver_receive sorryserver read_some call check" << std::endl;
10308 BOOST_CHECK(socket.read_some_call_check);
10309 BOOST_CHECK(socket.read_some_buffers_out == down_thread_data_dest_side.get_data());
10310 BOOST_CHECK(socket.read_some_buffers_size_in == MAX_BUFFER_SIZE);
10311 BOOST_CHECK(socket.read_some_res == down_thread_data_dest_side.get_size());
10312 BOOST_CHECK(sorry_end == down_thread_data_dest_side.get_endpoint());
10314 // unit_test [2] down_thread_sorryserver_receive protocol module handle_sorryserver_recv call check
10315 std::cout << "[2] down_thread_sorryserver_receive protocol module handle_sorryserver_recv call check" << std::endl;
10316 BOOST_CHECK(proto_test.handle_sorryserver_recv_in_thread_id == proc_id);
10317 BOOST_CHECK(proto_test.handle_sorryserver_recv_in_recvlen == socket.read_some_res);
10318 BOOST_CHECK(proto_test.handle_sorryserver_recv_in_recvbuffer == socket.read_some_buffers_out);
10319 BOOST_CHECK(proto_test.handle_sorryserver_recv_in_sorry_endpoint == sorry_end);
10321 // unit_test [3] down_thread_sorryserver_receive down_thread_next_call_function update check
10322 std::cout << "[3] down_thread_sorryserver_receive down_thread_next_call_function update check" << std::endl;
10323 test_obj.next_down_function_call();
10324 BOOST_CHECK(test_obj.down_thread_client_connection_chk_event_call_check);
10326 // unit_test [4] down_thread_sorryserver_receive receive size 0 check
10327 std::cout << "[4] down_thread_sorryserver_receive receive size 0 check" << std::endl;
10328 test_obj.set_down_thread_next_function_call_exit();
10329 socket.read_some_res = 0;
10330 test_obj.test_call_sorryserver_receive();
10331 test_obj.down_thread_sorryserver_receive_call_check = false;
10332 test_obj.next_down_function_call();
10333 BOOST_CHECK(test_obj.down_thread_sorryserver_receive_call_check);
10334 socket.read_some_res = MAX_BUFFER_SIZE;
10336 // unit_test [5] down_thread_sorryserver_receive socket error (try_again) check
10337 std::cout << "[5] down_thread_sorryserver_receive socket error (try_again) check" << std::endl;
10338 test_obj.set_down_thread_next_function_call_exit();
10339 socket.read_some_ec = boost::asio::error::try_again;
10340 test_obj.test_call_sorryserver_receive();
10341 test_obj.down_thread_sorryserver_receive_call_check = false;
10342 test_obj.next_down_function_call();
10343 BOOST_CHECK(test_obj.down_thread_sorryserver_receive_call_check);
10344 socket.read_some_ec.clear();
10346 // unit_test [6] down_thread_sorryserver_receive socket error (eof) check
10347 std::cout << "[6] down_thread_sorryserver_receive socket error (eof) check" << std::endl;
10348 test_obj.set_down_thread_next_function_call_exit();
10349 socket.read_some_ec = boost::asio::error::eof;
10350 test_obj.test_call_sorryserver_receive();
10351 test_obj.down_thread_sorryserver_disconnect_call_check = false;
10352 test_obj.next_down_function_call();
10353 BOOST_CHECK(test_obj.down_thread_sorryserver_disconnect_call_check);
10354 socket.read_some_ec.clear();
10356 // unit_test [7] down_thread_sorryserver_receive socket error (connection_reset) check
10357 std::cout << "[7] down_thread_sorryserver_receive socket error (connection_reset) check" << std::endl;
10358 test_obj.set_down_thread_next_function_call_exit();
10359 socket.read_some_ec = boost::asio::error::connection_reset;
10360 test_obj.test_call_sorryserver_receive();
10361 test_obj.down_thread_sorryserver_disconnect_call_check = false;
10362 test_obj.next_down_function_call();
10363 BOOST_CHECK(test_obj.down_thread_sorryserver_disconnect_call_check);
10364 socket.read_some_ec.clear();
10366 // unit_test [8] down_thread_sorryserver_receive socket error (bad_descriptor) check
10367 std::cout << "[8] down_thread_sorryserver_receive socket error (bad_descriptor) check" << std::endl;
10368 test_obj.set_down_thread_next_function_call_exit();
10369 socket.read_some_ec = boost::asio::error::bad_descriptor;
10370 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
10371 l7vs::Logger::putLogError_id = 0;
10372 test_obj.test_call_sorryserver_receive();
10373 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_NONE,l7vs::Logger::putLogError_category);
10374 BOOST_CHECK_EQUAL(0,l7vs::Logger::putLogError_id);
10375 std::cout << l7vs::Logger::putLogError_message << std::endl;
10376 test_obj.down_thread_sorryserver_disconnect_call_check = false;
10377 test_obj.next_down_function_call();
10378 BOOST_CHECK(test_obj.down_thread_sorryserver_disconnect_call_check);
10379 socket.read_some_ec.clear();
10381 // unit_test [9] down_thread_sorryserver_receive closed socket error (bad_descriptor) check
10382 std::cout << "[9] down_thread_sorryserver_receive closed socket error (bad_descriptor) check" << std::endl;
10383 test_obj.set_down_thread_next_function_call_exit();
10384 socket.read_some_ec = boost::asio::error::bad_descriptor;
10385 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
10386 l7vs::Logger::putLogError_id = 0;
10387 socket.is_open_res = false;
10388 test_obj.test_call_sorryserver_receive();
10389 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_NONE,l7vs::Logger::putLogError_category);
10390 BOOST_CHECK_EQUAL(0,l7vs::Logger::putLogError_id);
10391 test_obj.down_thread_sorryserver_disconnect_call_check = false;
10392 test_obj.next_down_function_call();
10393 BOOST_CHECK(test_obj.down_thread_sorryserver_disconnect_call_check);
10394 socket.read_some_ec.clear();
10396 // unit_test [10] down_thread_sorryserver_receive not fond function error check
10397 std::cout << "[10] down_thread_sorryserver_receive not fond function error check" << std::endl;
10398 test_obj.down_thread_function_array_clear();
10399 test_obj.down_thread_exit_call_check = false;
10400 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
10401 l7vs::Logger::putLogError_id = 0;
10402 test_obj.test_call_sorryserver_receive();
10403 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
10404 BOOST_CHECK_EQUAL(89,l7vs::Logger::putLogError_id);
10405 std::cout << l7vs::Logger::putLogError_message << std::endl;
10406 BOOST_CHECK(test_obj.down_thread_exit_call_check);
10408 // unit_test [11] down_thread_sorryserver_receive returnd illegal EVENT_TAG error check
10409 std::cout << "[11] down_thread_sorryserver_receive returnd illegal EVENT_TAG error check" << std::endl;
10410 test_obj.down_thread_module_event_map_clear();
10411 test_obj.down_thread_exit_call_check = false;
10412 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
10413 l7vs::Logger::putLogError_id = 0;
10414 test_obj.test_call_sorryserver_receive();
10415 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
10416 BOOST_CHECK_EQUAL(88,l7vs::Logger::putLogError_id);
10417 std::cout << l7vs::Logger::putLogError_message << std::endl;
10418 BOOST_CHECK(test_obj.down_thread_exit_call_check);
10420 BOOST_MESSAGE( "----- down_thread_sorryserver_receive test end -----" );
10423 // up_thread_realserver_send test
10424 void up_thread_realserver_send_test(){
10425 BOOST_MESSAGE( "----- up_thread_realserver_send test end -----" );
10426 // boost::asio::io_service io;
10427 // l7vs::virtualservice_tcp vs;
10428 l7vs::virtualservice_tcp vs;
10429 boost::asio::io_service io;
10430 l7vs::tcp_socket_option_info set_option;
10431 //! TCP_NODELAY (false:not set,true:set option)
10432 set_option.nodelay_opt = false;
10433 //! TCP_NODELAY option value (false:off,true:on)
10434 set_option.nodelay_val = false;
10435 //! TCP_CORK (false:not set,true:set option)
10436 set_option.cork_opt = false;
10437 //! TCP_CORK option value (false:off,true:on)
10438 set_option.cork_val = false;
10439 //! TCP_QUICKACK (false:not set,true:set option)
10440 set_option.quickack_opt = false;
10441 //! TCP_QUICKACK option value (false:off,true:on)
10442 set_option.quickack_val = false;
10444 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
10445 bool set_mode(false);
10446 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
10447 bool set_ssl_cache_flag(false);
10448 int set_ssl_handshake_time_out = 0;
10449 //std::string access_log_file_name = "test";
10450 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
10452 std::string test_protocol_name("test protocol");
10453 l7vs::test_protocol_module proto_test(test_protocol_name);
10454 // up_thread_realserver_send
10455 // receive_send_test_class test_obj(vs,io);
10456 receive_send_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
10458 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
10459 boost::thread::id proc_id = boost::this_thread::get_id();
10461 l7vs::tcp_data& send_data = test_obj.get_up_thread_data_dest_side();
10463 // set realserver socket
10464 std::map<boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > >& rs_map = test_obj.get_up_thread_send_realserver_socket_map();
10465 std::map<boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > >::iterator rs_it;
10466 std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > push_pair;
10467 for(int i = 0 ; i < 3 ;i++){
10468 boost::shared_ptr< l7vs::tcp_socket > new_socket(new l7vs::tcp_socket(io));
10469 push_pair.first.address(boost::asio::ip::address::from_string(DUMMI_SERVER_IP));
10470 push_pair.first.port(7000+i);
10471 push_pair.second = new_socket;
10472 new_socket->write_some_res = MAX_BUFFER_SIZE;
10473 new_socket->write_some_ec.clear();
10474 new_socket->write_some_buffers_in = NULL;
10475 new_socket->write_some_buffers_size_in = 0;
10476 new_socket->write_some_call_check = false;
10477 rs_map.insert(push_pair);
10481 send_data.initialize();
10482 send_data.set_size(MAX_BUFFER_SIZE);
10483 boost::asio::ip::tcp::endpoint send_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP),7002);
10484 send_data.set_endpoint(send_end);
10485 test_obj.set_up_thread_id(proc_id);
10486 test_obj.set_down_thread_id(boost::thread::id());
10487 test_obj.up_thread_client_receive_call_check = false;
10488 test_obj.up_thread_realserver_disconnect_call_check = false;
10489 test_obj.up_thread_exit_call_check = false;
10490 test_obj.up_thread_realserver_get_destination_event_call_check = false;
10492 vs.update_up_send_size_in = 0;
10493 // protocol module set
10494 proto_test.handle_realserver_send_res_tag = l7vs::protocol_module_base::CLIENT_RECV;
10495 proto_test.handle_realserver_send_in_thread_id = boost::thread::id();
10497 rs_it = rs_map.find(send_end);
10498 l7vs::tcp_socket& socket = *(rs_it->second);
10500 l7vs::Logger::test_loglevel = l7vs::LOG_LV_DEBUG;
10501 l7vs::Logger::putLogDebug_category = l7vs::LOG_CAT_NONE;
10502 l7vs::Logger::putLogDebug_id = 0;
10504 test_obj.test_call_realserver_send();
10506 // unit_test [1] up_thread_realserver_send realserver_socket write_some call check
10507 std::cout << "[1] up_thread_realserver_send realserver_socket write_some call check" << std::endl;
10508 BOOST_CHECK(socket.write_some_call_check);
10509 BOOST_CHECK(socket.write_some_buffers_in == (void*)&(send_data.get_data()));
10510 BOOST_CHECK(socket.write_some_buffers_size_in == MAX_BUFFER_SIZE);
10511 BOOST_CHECK(socket.write_some_res == send_data.get_send_size());
10513 // unit_test [2] up_thread_realserver_send virtualservice update_up_send_size_in call check
10514 std::cout << "[2] up_thread_realserver_send virtualservice update_up_send_size_in call check" << std::endl;
10515 BOOST_CHECK(vs.update_up_send_size_in == MAX_BUFFER_SIZE);
10517 // unit_test [3] up_thread_realserver_send protocol module handle_realserver_send call check
10518 std::cout << "[3] up_thread_realserver_send protocol module handle_realserver_send call check" << std::endl;
10519 BOOST_CHECK(proto_test.handle_realserver_send_in_thread_id == proc_id);
10521 // unit_test [4] up_thread_realserver_send up_thread_next_call_function update check
10522 std::cout << "[4] up_thread_realserver_send up_thread_next_call_function update check" << std::endl;
10523 test_obj.next_up_function_call();
10524 BOOST_CHECK(test_obj.up_thread_client_receive_call_check);
10526 // unit_test [5] up_thread_realserver_send send size check
10527 std::cout << "[5] up_thread_realserver_send send size check" << std::endl;
10528 send_data.set_send_size(0);
10529 socket.write_some_res = 0;
10530 test_obj.set_up_thread_next_function_call_exit();
10531 socket.write_some_buffers_in = NULL;
10532 test_obj.test_call_realserver_send();
10533 // BOOST_CHECK((char*)socket.write_some_buffers_in == (char*)&(send_data.get_data()) + 0);
10534 BOOST_CHECK((char*)socket.write_some_buffers_in == (send_data.get_data().data() + 0));
10535 test_obj.up_thread_realserver_send_call_check = false;
10536 test_obj.next_up_function_call();
10537 BOOST_CHECK(test_obj.up_thread_realserver_send_call_check);
10539 socket.write_some_res = MAX_BUFFER_SIZE / 3;
10540 test_obj.set_up_thread_next_function_call_exit();
10541 socket.write_some_buffers_in = NULL;
10542 test_obj.test_call_realserver_send();
10543 // BOOST_CHECK((char*)socket.write_some_buffers_in == (char*)&(send_data.get_data()) + 0);
10544 BOOST_CHECK((char*)socket.write_some_buffers_in == (send_data.get_data().data() + 0));
10545 test_obj.up_thread_realserver_send_call_check = false;
10546 test_obj.next_up_function_call();
10547 BOOST_CHECK(test_obj.up_thread_realserver_send_call_check);
10549 socket.write_some_res = MAX_BUFFER_SIZE / 3;
10550 test_obj.set_up_thread_next_function_call_exit();
10551 socket.write_some_buffers_in = NULL;
10552 test_obj.test_call_realserver_send();
10553 // BOOST_CHECK((char*)socket.write_some_buffers_in == (char*)(&(send_data.get_data()) + (MAX_BUFFER_SIZE / 3)));
10554 BOOST_CHECK((char*)socket.write_some_buffers_in == (send_data.get_data().data() + (MAX_BUFFER_SIZE / 3)));
10555 test_obj.up_thread_realserver_send_call_check = false;
10556 test_obj.next_up_function_call();
10557 BOOST_CHECK(test_obj.up_thread_realserver_send_call_check);
10559 socket.write_some_res = MAX_BUFFER_SIZE - send_data.get_send_size();
10560 test_obj.set_up_thread_next_function_call_exit();
10561 socket.write_some_buffers_in = NULL;
10562 test_obj.test_call_realserver_send();
10563 // BOOST_CHECK((char*)socket.write_some_buffers_in == (char*)(&(send_data.get_data()) + (MAX_BUFFER_SIZE / 3) * 2));
10564 BOOST_CHECK((char*)socket.write_some_buffers_in == (send_data.get_data().data() + (MAX_BUFFER_SIZE / 3) * 2));
10565 test_obj.up_thread_client_receive_call_check = false;
10566 test_obj.next_up_function_call();
10567 BOOST_CHECK(test_obj.up_thread_client_receive_call_check);
10569 socket.write_some_res = MAX_BUFFER_SIZE;
10571 // unit_test [6] up_thread_realserver_send socket error (try_again) check
10572 std::cout << "[6] up_thread_realserver_send socket error (try_again) check" << std::endl;
10573 send_data.set_send_size(0);
10574 test_obj.set_up_thread_next_function_call_exit();
10575 socket.write_some_ec = boost::asio::error::try_again;
10576 test_obj.test_call_realserver_send();
10577 test_obj.up_thread_realserver_send_call_check = false;
10578 test_obj.next_up_function_call();
10579 BOOST_CHECK(test_obj.up_thread_realserver_send_call_check);
10580 socket.read_some_ec.clear();
10582 // unit_test [7] up_thread_realserver_send socket error (eof) check
10583 std::cout << "[7] up_thread_realserver_send socket error (eof) check" << std::endl;
10584 send_data.set_send_size(0);
10585 test_obj.set_up_thread_next_function_call_exit();
10586 socket.write_some_ec = boost::asio::error::eof;
10587 test_obj.test_call_realserver_send();
10588 test_obj.up_thread_realserver_disconnect_call_check = false;
10589 test_obj.next_up_function_call();
10590 BOOST_CHECK(test_obj.up_thread_realserver_disconnect_call_check);
10591 socket.read_some_ec.clear();
10593 // unit_test [8] up_thread_realserver_send socket error (connection_reset) check
10594 std::cout << "[8] up_thread_realserver_send socket error (connection_reset) check" << std::endl;
10595 send_data.set_send_size(0);
10596 test_obj.set_up_thread_next_function_call_exit();
10597 socket.write_some_ec = boost::asio::error::connection_reset;
10598 test_obj.test_call_realserver_send();
10599 test_obj.up_thread_realserver_disconnect_call_check = false;
10600 test_obj.next_up_function_call();
10601 BOOST_CHECK(test_obj.up_thread_realserver_disconnect_call_check);
10602 socket.read_some_ec.clear();
10604 // unit_test [9] up_thread_realserver_send socket error (bad_descriptor) check
10605 std::cout << "[9] up_thread_realserver_send socket error (bad_descriptor) check" << std::endl;
10606 send_data.set_send_size(0);
10607 test_obj.set_up_thread_next_function_call_exit();
10608 socket.write_some_ec = boost::asio::error::bad_descriptor;
10609 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
10610 l7vs::Logger::putLogError_id = 0;
10611 test_obj.test_call_realserver_send();
10612 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_NONE,l7vs::Logger::putLogError_category);
10613 BOOST_CHECK_EQUAL(0,l7vs::Logger::putLogError_id);
10614 test_obj.up_thread_realserver_disconnect_call_check = false;
10615 test_obj.next_up_function_call();
10616 BOOST_CHECK(test_obj.up_thread_realserver_disconnect_call_check);
10617 socket.read_some_ec.clear();
10619 // unit_test [10] up_thread_realserver_send not fond function error check
10620 std::cout << "[10] up_thread_realserver_send not fond function error check" << std::endl;
10621 send_data.set_send_size(0);
10622 test_obj.up_thread_function_array_clear();
10623 test_obj.up_thread_exit_call_check = false;
10624 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
10625 l7vs::Logger::putLogError_id = 0;
10626 test_obj.test_call_realserver_send();
10627 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
10628 BOOST_CHECK_EQUAL(31,l7vs::Logger::putLogError_id);
10629 std::cout << l7vs::Logger::putLogError_message << std::endl;
10630 BOOST_CHECK(test_obj.up_thread_exit_call_check);
10632 // unit_test [11] up_thread_realserver_send returnd illegal EVENT_TAG error check
10633 std::cout << "[11] up_thread_realserver_send returnd illegal EVENT_TAG error check" << std::endl;
10634 send_data.set_send_size(0);
10635 send_data.set_size(MAX_BUFFER_SIZE);
10636 socket.write_some_ec.clear();
10637 test_obj.up_thread_module_event_map_clear();
10638 test_obj.up_thread_exit_call_check = false;
10639 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
10640 l7vs::Logger::putLogError_id = 0;
10641 test_obj.test_call_realserver_send();
10642 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
10643 BOOST_CHECK_EQUAL(30,l7vs::Logger::putLogError_id);
10644 std::cout << l7vs::Logger::putLogError_message << std::endl;
10645 BOOST_CHECK(test_obj.up_thread_exit_call_check);
10647 BOOST_MESSAGE( "----- up_thread_realserver_send test end -----" );
10650 // up_thread_sorryserver_send test
10651 void up_thread_sorryserver_send_test(){
10652 BOOST_MESSAGE( "----- up_thread_sorryserver_send test end -----" );
10653 // boost::asio::io_service io;
10654 // l7vs::virtualservice_tcp vs;
10655 l7vs::virtualservice_tcp vs;
10656 boost::asio::io_service io;
10657 l7vs::tcp_socket_option_info set_option;
10658 //! TCP_NODELAY (false:not set,true:set option)
10659 set_option.nodelay_opt = false;
10660 //! TCP_NODELAY option value (false:off,true:on)
10661 set_option.nodelay_val = false;
10662 //! TCP_CORK (false:not set,true:set option)
10663 set_option.cork_opt = false;
10664 //! TCP_CORK option value (false:off,true:on)
10665 set_option.cork_val = false;
10666 //! TCP_QUICKACK (false:not set,true:set option)
10667 set_option.quickack_opt = false;
10668 //! TCP_QUICKACK option value (false:off,true:on)
10669 set_option.quickack_val = false;
10671 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
10672 bool set_mode(false);
10673 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
10674 bool set_ssl_cache_flag(false);
10675 int set_ssl_handshake_time_out = 0;
10676 //std::string access_log_file_name = "test";
10677 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
10679 std::string test_protocol_name("test protocol");
10680 l7vs::test_protocol_module proto_test(test_protocol_name);
10681 // up_thread_sorryserver_send
10682 // receive_send_test_class test_obj(vs,io);
10683 receive_send_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
10685 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
10686 boost::thread::id proc_id = boost::this_thread::get_id();
10688 l7vs::tcp_data& send_data = test_obj.get_up_thread_data_dest_side();
10690 // set sorryserver socket
10691 std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > >& sorry_pair = test_obj.get_sorryserver_socket();
10692 sorry_pair.first = boost::asio::ip::tcp::endpoint();
10695 send_data.initialize();
10696 send_data.set_size(MAX_BUFFER_SIZE);
10697 boost::asio::ip::tcp::endpoint send_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP),7000);
10698 send_data.set_endpoint(send_end);
10699 test_obj.set_up_thread_id(proc_id);
10700 test_obj.set_down_thread_id(boost::thread::id());
10701 test_obj.up_thread_client_receive_call_check = false;
10702 test_obj.up_thread_sorryserver_disconnect_call_check = false;
10703 test_obj.up_thread_exit_call_check = false;
10704 test_obj.up_thread_sorryserver_get_destination_event_call_check = false;
10706 vs.update_up_send_size_in = 0;
10707 // protocol module set
10708 proto_test.handle_sorryserver_send_res_tag = l7vs::protocol_module_base::CLIENT_RECV;
10709 proto_test.handle_sorryserver_send_in_thread_id = boost::thread::id();
10711 l7vs::tcp_socket& socket = *(sorry_pair.second);
10712 socket.write_some_res = MAX_BUFFER_SIZE;
10713 socket.write_some_ec.clear();
10714 socket.write_some_buffers_in = NULL;
10715 socket.write_some_buffers_size_in = 0;
10716 socket.write_some_call_check = false;
10718 l7vs::Logger::test_loglevel = l7vs::LOG_LV_DEBUG;
10719 l7vs::Logger::putLogDebug_category = l7vs::LOG_CAT_NONE;
10720 l7vs::Logger::putLogDebug_id = 0;
10722 test_obj.test_call_sorryserver_send();
10724 // unit_test [1] up_thread_sorryserver_send realserver_socket write_some call check
10725 std::cout << "[1] up_thread_sorryserver_send realserver_socket write_some call check" << std::endl;
10726 BOOST_CHECK(socket.write_some_call_check);
10727 BOOST_CHECK(socket.write_some_buffers_in == (void*)&(send_data.get_data()));
10728 BOOST_CHECK(socket.write_some_buffers_size_in == MAX_BUFFER_SIZE);
10729 BOOST_CHECK(socket.write_some_res == send_data.get_send_size());
10731 // unit_test [2] up_thread_sorryserver_send protocol module handle_realserver_send call check
10732 std::cout << "[2] up_thread_sorryserver_send protocol module handle_realserver_send call check" << std::endl;
10733 BOOST_CHECK(proto_test.handle_sorryserver_send_in_thread_id == proc_id);
10735 // unit_test [3] up_thread_sorryserver_send up_thread_next_call_function update check
10736 std::cout << "[3] up_thread_sorryserver_send up_thread_next_call_function update check" << std::endl;
10737 test_obj.next_up_function_call();
10738 BOOST_CHECK(test_obj.up_thread_client_receive_call_check);
10740 // unit_test [4] up_thread_sorryserver_send send size check
10741 std::cout << "[4] up_thread_sorryserver_send send size check" << std::endl;
10742 send_data.set_send_size(0);
10743 socket.write_some_res = 0;
10744 test_obj.set_up_thread_next_function_call_exit();
10745 socket.write_some_buffers_in = NULL;
10746 test_obj.test_call_sorryserver_send();
10747 // BOOST_CHECK((char*)socket.write_some_buffers_in == (char*)&(send_data.get_data()) + 0);
10748 BOOST_CHECK((char*)socket.write_some_buffers_in == (send_data.get_data().data() + 0));
10749 test_obj.up_thread_sorryserver_send_call_check = false;
10750 test_obj.next_up_function_call();
10751 BOOST_CHECK(test_obj.up_thread_sorryserver_send_call_check);
10753 socket.write_some_res = MAX_BUFFER_SIZE / 3;
10754 test_obj.set_up_thread_next_function_call_exit();
10755 socket.write_some_buffers_in = NULL;
10756 test_obj.test_call_sorryserver_send();
10757 // BOOST_CHECK((char*)socket.write_some_buffers_in == (char*)&(send_data.get_data()) + 0);
10758 BOOST_CHECK((char*)socket.write_some_buffers_in == (send_data.get_data().data() + 0));
10759 test_obj.up_thread_sorryserver_send_call_check = false;
10760 test_obj.next_up_function_call();
10761 BOOST_CHECK(test_obj.up_thread_sorryserver_send_call_check);
10763 socket.write_some_res = MAX_BUFFER_SIZE / 3;
10764 test_obj.set_up_thread_next_function_call_exit();
10765 socket.write_some_buffers_in = NULL;
10766 test_obj.test_call_sorryserver_send();
10767 // BOOST_CHECK((char*)socket.write_some_buffers_in == (char*)(&(send_data.get_data()) + (MAX_BUFFER_SIZE / 3)));
10768 BOOST_CHECK((char*)socket.write_some_buffers_in == (send_data.get_data().data() + (MAX_BUFFER_SIZE / 3)));
10769 test_obj.up_thread_sorryserver_send_call_check = false;
10770 test_obj.next_up_function_call();
10771 BOOST_CHECK(test_obj.up_thread_sorryserver_send_call_check);
10773 socket.write_some_res = MAX_BUFFER_SIZE - send_data.get_send_size();
10774 test_obj.set_up_thread_next_function_call_exit();
10775 socket.write_some_buffers_in = NULL;
10776 test_obj.test_call_sorryserver_send();
10777 // BOOST_CHECK((char*)socket.write_some_buffers_in == (char*)(&(send_data.get_data()) + (MAX_BUFFER_SIZE / 3) * 2));
10778 BOOST_CHECK((char*)socket.write_some_buffers_in == (send_data.get_data().data() + (MAX_BUFFER_SIZE / 3) * 2));
10779 test_obj.up_thread_client_receive_call_check = false;
10780 test_obj.next_up_function_call();
10781 BOOST_CHECK(test_obj.up_thread_client_receive_call_check);
10783 socket.write_some_res = MAX_BUFFER_SIZE;
10785 // unit_test [5] up_thread_sorryserver_send socket error (try_again) check
10786 std::cout << "[5] up_thread_sorryserver_send socket error (try_again) check" << std::endl;
10787 send_data.set_send_size(0);
10788 test_obj.set_up_thread_next_function_call_exit();
10789 socket.write_some_ec = boost::asio::error::try_again;
10790 test_obj.test_call_sorryserver_send();
10791 test_obj.up_thread_sorryserver_send_call_check = false;
10792 test_obj.next_up_function_call();
10793 BOOST_CHECK(test_obj.up_thread_sorryserver_send_call_check);
10794 socket.read_some_ec.clear();
10796 // unit_test [6] up_thread_sorryserver_send socket error (eof) check
10797 std::cout << "[6] up_thread_sorryserver_send socket error (eof) check" << std::endl;
10798 send_data.set_send_size(0);
10799 test_obj.set_up_thread_next_function_call_exit();
10800 socket.write_some_ec = boost::asio::error::eof;
10801 test_obj.test_call_sorryserver_send();
10802 test_obj.up_thread_sorryserver_disconnect_call_check = false;
10803 test_obj.next_up_function_call();
10804 BOOST_CHECK(test_obj.up_thread_sorryserver_disconnect_call_check);
10805 socket.read_some_ec.clear();
10807 // unit_test [7] up_thread_sorryserver_send socket error (connection_reset) check
10808 std::cout << "[7] up_thread_sorryserver_send socket error (connection_reset) check" << std::endl;
10809 send_data.set_send_size(0);
10810 test_obj.set_up_thread_next_function_call_exit();
10811 socket.write_some_ec = boost::asio::error::connection_reset;
10812 test_obj.test_call_sorryserver_send();
10813 test_obj.up_thread_sorryserver_disconnect_call_check = false;
10814 test_obj.next_up_function_call();
10815 BOOST_CHECK(test_obj.up_thread_sorryserver_disconnect_call_check);
10816 socket.read_some_ec.clear();
10818 // unit_test [8] up_thread_sorryserver_send socket error (bad_descriptor) check
10819 std::cout << "[8] up_thread_sorryserver_send socket error (bad_descriptor) check" << std::endl;
10820 send_data.set_send_size(0);
10821 test_obj.set_up_thread_next_function_call_exit();
10822 socket.write_some_ec = boost::asio::error::bad_descriptor;
10823 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
10824 l7vs::Logger::putLogError_id = 0;
10825 test_obj.test_call_sorryserver_send();
10826 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_NONE,l7vs::Logger::putLogError_category);
10827 BOOST_CHECK_EQUAL(0,l7vs::Logger::putLogError_id);
10828 std::cout << l7vs::Logger::putLogError_message << std::endl;
10829 test_obj.up_thread_sorryserver_disconnect_call_check = false;
10830 test_obj.next_up_function_call();
10831 BOOST_CHECK(test_obj.up_thread_sorryserver_disconnect_call_check);
10832 socket.write_some_ec.clear();
10834 // unit_test [9] up_thread_sorryserver_send not fond function error check
10835 std::cout << "[9] up_thread_sorryserver_send not fond function error check" << std::endl;
10836 send_data.set_send_size(0);
10837 test_obj.up_thread_function_array_clear();
10838 test_obj.up_thread_exit_call_check = false;
10839 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
10840 l7vs::Logger::putLogError_id = 0;
10841 test_obj.test_call_sorryserver_send();
10842 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
10843 BOOST_CHECK_EQUAL(50,l7vs::Logger::putLogError_id);
10844 std::cout << l7vs::Logger::putLogError_message << std::endl;
10845 BOOST_CHECK(test_obj.up_thread_exit_call_check);
10847 // unit_test [10] up_thread_sorryserver_send returnd illegal EVENT_TAG error check
10848 std::cout << "[10] up_thread_sorryserver_send returnd illegal EVENT_TAG error check" << std::endl;
10849 send_data.set_size(MAX_BUFFER_SIZE);
10850 send_data.set_send_size(0);
10851 test_obj.up_thread_module_event_map_clear();
10852 test_obj.up_thread_exit_call_check = false;
10853 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
10854 l7vs::Logger::putLogError_id = 0;
10855 test_obj.test_call_sorryserver_send();
10856 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
10857 BOOST_CHECK_EQUAL(49,l7vs::Logger::putLogError_id);
10858 std::cout << l7vs::Logger::putLogError_message << std::endl;
10859 BOOST_CHECK(test_obj.up_thread_exit_call_check);
10861 BOOST_MESSAGE( "----- up_thread_sorryserver_send test end -----" );
10864 // down_thread_client_send test
10865 void down_thread_client_send_test(){
10866 BOOST_MESSAGE( "----- down_thread_client_send test end -----" );
10867 // boost::asio::io_service io;
10868 // l7vs::virtualservice_tcp vs;
10869 l7vs::virtualservice_tcp vs;
10870 boost::asio::io_service io;
10871 l7vs::tcp_socket_option_info set_option;
10872 //! TCP_NODELAY (false:not set,true:set option)
10873 set_option.nodelay_opt = false;
10874 //! TCP_NODELAY option value (false:off,true:on)
10875 set_option.nodelay_val = false;
10876 //! TCP_CORK (false:not set,true:set option)
10877 set_option.cork_opt = false;
10878 //! TCP_CORK option value (false:off,true:on)
10879 set_option.cork_val = false;
10880 //! TCP_QUICKACK (false:not set,true:set option)
10881 set_option.quickack_opt = false;
10882 //! TCP_QUICKACK option value (false:off,true:on)
10883 set_option.quickack_val = false;
10885 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
10886 bool set_mode(false);
10887 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
10888 bool set_ssl_cache_flag(false);
10889 int set_ssl_handshake_time_out = 0;
10890 //std::string access_log_file_name = "test";
10891 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
10893 std::string test_protocol_name("test protocol");
10894 l7vs::test_protocol_module proto_test(test_protocol_name);
10895 // up_thread_sorryserver_send
10896 receive_send_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
10898 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
10899 boost::thread::id proc_id = boost::this_thread::get_id();
10901 l7vs::tcp_data& send_data = test_obj.get_down_thread_data_client_side();
10903 // get client socket
10904 l7vs::tcp_socket& socket = test_obj.get_client_socket();
10906 // dummy server client socket connect
10907 boost::system::error_code ec;
10908 test_mirror_server test_server;
10910 test_server.breq_acc_flag = true;
10912 test_server.breq_close_wait_flag = true;
10914 test_server.req_recv_cnt = 0;
10915 // test server start
10916 boost::thread server_thread(boost::bind(&test_mirror_server::run,&test_server));
10917 while( !test_server.brun_flag ){
10921 boost::asio::ip::tcp::endpoint connect_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
10922 socket.get_socket().connect(connect_end,ec);
10924 socket.is_open_res = true;
10926 while(!test_server.bconnect_flag){
10929 boost::asio::ip::tcp::endpoint local_endpoint = socket.get_socket().local_endpoint(ec);
10933 send_data.initialize();
10934 send_data.set_size(MAX_BUFFER_SIZE);
10935 test_obj.set_up_thread_id(boost::thread::id());
10936 test_obj.set_down_thread_id(proc_id);
10937 test_obj.down_thread_realserver_receive_call_check = false;
10938 test_obj.down_thread_client_disconnect_call_check = false;
10939 test_obj.down_thread_exit_call_check = false;
10940 test_obj.down_thread_client_connection_chk_event_call_check = false;
10943 vs.update_down_send_size_in = 0;
10944 // protocol module set
10945 proto_test.handle_client_send_res_tag = l7vs::protocol_module_base::REALSERVER_RECV;
10946 proto_test.handle_client_send_in_thread_id = boost::thread::id();
10948 socket.write_some_res = MAX_BUFFER_SIZE;
10949 socket.write_some_ec.clear();
10950 socket.write_some_buffers_in = NULL;
10951 socket.write_some_buffers_size_in = 0;
10952 socket.write_some_call_check = false;
10954 l7vs::Logger::test_loglevel = l7vs::LOG_LV_DEBUG;
10955 l7vs::Logger::putLogDebug_category = l7vs::LOG_CAT_NONE;
10956 l7vs::Logger::putLogDebug_id = 0;
10958 test_obj.test_call_client_send();
10960 // unit_test [1] down_thread_client_send socket write_some call check
10961 std::cout << "[1] down_thread_client_send socket write_some call check" << std::endl;
10962 BOOST_CHECK(socket.write_some_call_check);
10963 BOOST_CHECK(socket.write_some_buffers_in == (void*)&(send_data.get_data()));
10964 BOOST_CHECK(socket.write_some_buffers_size_in == MAX_BUFFER_SIZE);
10965 BOOST_CHECK(socket.write_some_res == send_data.get_send_size());
10967 // unit_test [2] down_thread_client_send protocol module handle_client_send call check
10968 std::cout << "[2] down_thread_client_send protocol module handle_client_send call check" << std::endl;
10969 BOOST_CHECK(proto_test.handle_client_send_in_thread_id == proc_id);
10971 // unit_test [3] down_thread_client_send up_thread_next_call_function update check
10972 std::cout << "[3] down_thread_client_send up_thread_next_call_function update check" << std::endl;
10973 test_obj.next_down_function_call();
10974 BOOST_CHECK(test_obj.down_thread_realserver_receive_call_check);
10976 // unit_test [4] down_thread_client_send send size check
10977 std::cout << "[4] down_thread_client_send send size check" << std::endl;
10978 send_data.set_send_size(0);
10979 socket.write_some_res = 0;
10980 test_obj.set_down_thread_next_function_call_exit();
10981 socket.write_some_buffers_in = NULL;
10982 test_obj.test_call_client_send();
10983 // BOOST_CHECK((char*)socket.write_some_buffers_in == (char*)&(send_data.get_data()) + 0);
10984 BOOST_CHECK((char*)socket.write_some_buffers_in == (send_data.get_data().data() + 0));
10985 test_obj.down_thread_client_send_call_check = false;
10986 test_obj.next_down_function_call();
10987 BOOST_CHECK(test_obj.down_thread_client_send_call_check);
10989 socket.write_some_res = MAX_BUFFER_SIZE / 3;
10990 test_obj.set_down_thread_next_function_call_exit();
10991 socket.write_some_buffers_in = NULL;
10992 test_obj.test_call_client_send();
10993 // BOOST_CHECK((char*)socket.write_some_buffers_in == (char*)&(send_data.get_data()) + 0);
10994 BOOST_CHECK((char*)socket.write_some_buffers_in == (send_data.get_data().data() + 0));
10995 test_obj.down_thread_client_send_call_check = false;
10996 test_obj.next_down_function_call();
10997 BOOST_CHECK(test_obj.down_thread_client_send_call_check);
10999 socket.write_some_res = MAX_BUFFER_SIZE / 3;
11000 test_obj.set_down_thread_next_function_call_exit();
11001 socket.write_some_buffers_in = NULL;
11002 test_obj.test_call_client_send();
11003 // BOOST_CHECK((char*)socket.write_some_buffers_in == (char*)(&(send_data.get_data()) + (MAX_BUFFER_SIZE / 3)));
11004 BOOST_CHECK((char*)socket.write_some_buffers_in == (send_data.get_data().data() + (MAX_BUFFER_SIZE / 3)));
11005 test_obj.down_thread_client_send_call_check = false;
11006 test_obj.next_down_function_call();
11007 BOOST_CHECK(test_obj.down_thread_client_send_call_check);
11009 socket.write_some_res = MAX_BUFFER_SIZE - send_data.get_send_size();
11010 test_obj.set_down_thread_next_function_call_exit();
11011 socket.write_some_buffers_in = NULL;
11012 test_obj.test_call_client_send();
11013 // BOOST_CHECK((char*)socket.write_some_buffers_in == (char*)(&(send_data.get_data()) + (MAX_BUFFER_SIZE / 3) * 2));
11014 BOOST_CHECK((char*)socket.write_some_buffers_in == (send_data.get_data().data() + (MAX_BUFFER_SIZE / 3) * 2));
11015 test_obj.down_thread_realserver_receive_call_check = false;
11016 test_obj.next_down_function_call();
11017 BOOST_CHECK(test_obj.down_thread_realserver_receive_call_check);
11019 socket.write_some_res = MAX_BUFFER_SIZE;
11021 // unit_test [5] down_thread_client_send socket error (try_again) check
11022 std::cout << "[5] down_thread_client_send socket error (try_again) check" << std::endl;
11023 send_data.set_send_size(0);
11024 test_obj.set_down_thread_next_function_call_exit();
11025 socket.write_some_ec = boost::asio::error::try_again;
11026 test_obj.test_call_client_send();
11027 test_obj.down_thread_client_send_call_check = false;
11028 test_obj.next_down_function_call();
11029 BOOST_CHECK(test_obj.down_thread_client_send_call_check);
11030 socket.read_some_ec.clear();
11032 // unit_test [6] down_thread_client_send socket error (eof) check
11033 std::cout << "[6] down_thread_client_send socket error (eof) check" << std::endl;
11034 send_data.set_send_size(0);
11035 test_obj.set_down_thread_next_function_call_exit();
11036 socket.write_some_ec = boost::asio::error::eof;
11037 test_obj.test_call_client_send();
11038 test_obj.down_thread_client_disconnect_call_check = false;
11039 test_obj.next_down_function_call();
11040 BOOST_CHECK(test_obj.down_thread_client_disconnect_call_check);
11041 socket.read_some_ec.clear();
11043 // unit_test [7] down_thread_client_send socket error (connection_reset) check
11044 std::cout << "[7] down_thread_client_send socket error (connection_reset) check" << std::endl;
11045 send_data.set_send_size(0);
11046 test_obj.set_down_thread_next_function_call_exit();
11047 socket.write_some_ec = boost::asio::error::connection_reset;
11048 test_obj.test_call_client_send();
11049 test_obj.down_thread_client_disconnect_call_check = false;
11050 test_obj.next_down_function_call();
11051 BOOST_CHECK(test_obj.down_thread_client_disconnect_call_check);
11052 socket.read_some_ec.clear();
11054 // unit_test [8] down_thread_client_send socket error (bad_descriptor) check
11055 std::cout << "[8] down_thread_client_send socket error (bad_descriptor) check" << std::endl;
11056 send_data.set_send_size(0);
11057 test_obj.set_down_thread_next_function_call_exit();
11058 socket.write_some_ec = boost::asio::error::bad_descriptor;
11059 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
11060 l7vs::Logger::putLogError_id = 0;
11061 test_obj.test_call_client_send();
11062 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_NONE,l7vs::Logger::putLogError_category);
11063 BOOST_CHECK_EQUAL(0,l7vs::Logger::putLogError_id);
11064 std::cout << l7vs::Logger::putLogError_message << std::endl;
11065 test_obj.down_thread_client_disconnect_call_check = false;
11066 test_obj.next_down_function_call();
11067 BOOST_CHECK(test_obj.down_thread_client_disconnect_call_check);
11068 socket.write_some_ec.clear();
11070 // unit_test [9] down_thread_client_send not fond function error check
11071 std::cout << "[9] down_thread_client_send not fond function error check" << std::endl;
11072 send_data.set_send_size(0);
11073 test_obj.down_thread_function_array_clear();
11074 test_obj.down_thread_exit_call_check = false;
11075 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
11076 l7vs::Logger::putLogError_id = 0;
11077 test_obj.test_call_client_send();
11078 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
11079 BOOST_CHECK_EQUAL(83,l7vs::Logger::putLogError_id);
11080 std::cout << l7vs::Logger::putLogError_message << std::endl;
11081 BOOST_CHECK(test_obj.down_thread_exit_call_check);
11083 // unit_test [10] down_thread_client_send returnd illegal EVENT_TAG error check
11084 std::cout << "[10] down_thread_client_send returnd illegal EVENT_TAG error check" << std::endl;
11085 send_data.set_send_size(0);
11086 test_obj.down_thread_module_event_map_clear();
11087 test_obj.down_thread_exit_call_check = false;
11088 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
11089 l7vs::Logger::putLogError_id = 0;
11090 test_obj.test_call_client_send();
11091 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
11092 BOOST_CHECK_EQUAL(82,l7vs::Logger::putLogError_id);
11093 std::cout << l7vs::Logger::putLogError_message << std::endl;
11094 BOOST_CHECK(test_obj.down_thread_exit_call_check);
11096 // dummy server stop
11097 test_server.breq_close_wait_flag = false;
11098 test_server.bstop_flag = true;
11099 server_thread.join();
11103 receive_send_test_class ssl_test_obj(vs,io,set_option,listen_endpoint,true,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
11105 ssl_test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
11107 l7vs::tcp_data& ssl_send_data = ssl_test_obj.get_down_thread_data_client_side();
11109 // get client socket
11110 l7vs::tcp_ssl_socket& ssl_socket = ssl_test_obj.get_client_ssl_socket();
11113 ssl_send_data.initialize();
11114 ssl_send_data.set_size(MAX_BUFFER_SIZE);
11115 ssl_test_obj.set_up_thread_id(boost::thread::id());
11116 ssl_test_obj.set_down_thread_id(proc_id);
11117 ssl_test_obj.down_thread_realserver_receive_call_check = false;
11118 ssl_test_obj.down_thread_client_disconnect_call_check = false;
11119 ssl_test_obj.down_thread_exit_call_check = false;
11120 ssl_test_obj.down_thread_client_connection_chk_event_call_check = false;
11123 vs.update_down_send_size_in = 0;
11124 // protocol module set
11125 proto_test.handle_client_send_res_tag = l7vs::protocol_module_base::REALSERVER_RECV;
11126 proto_test.handle_client_send_in_thread_id = boost::thread::id();
11128 ssl_socket.write_some_res = MAX_BUFFER_SIZE;
11129 ssl_socket.write_some_ec.clear();
11130 ssl_socket.write_some_buffers_in = NULL;
11131 ssl_socket.write_some_buffers_size_in = 0;
11132 ssl_socket.write_some_call_check = false;
11134 ssl_test_obj.test_call_client_send();
11136 // unit_test [11] down_thread_client_send ssl mode socket write_some call check
11137 std::cout << "[11] down_thread_client_send ssl mode socket write_some call check" << std::endl;
11138 BOOST_CHECK(ssl_socket.write_some_call_check);
11139 BOOST_CHECK(ssl_socket.write_some_buffers_in == (void*)&(ssl_send_data.get_data()));
11140 BOOST_CHECK(ssl_socket.write_some_buffers_size_in == MAX_BUFFER_SIZE);
11141 BOOST_CHECK(ssl_socket.write_some_res == ssl_send_data.get_send_size());
11144 BOOST_MESSAGE( "----- down_thread_client_send test end -----" );
11148 //up_thread_realserver_connect test
11149 //up_thread_realserver_connect test class
11150 class up_thread_realserver_connect_test_class : public l7vs::tcp_session{
11152 up_thread_realserver_connect_test_class(
11153 l7vs::virtualservice_tcp& vs,
11154 boost::asio::io_service& session_io,
11155 l7vs::tcp_socket_option_info& set_socket_option,
11156 boost::asio::ip::tcp::endpoint listen_endpoint,
11158 boost::asio::ssl::context& set_ssl_context,
11159 bool set_ssl_cache_flag,
11160 int set_ssl_handshake_time_out,
11161 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
11167 set_ssl_cache_flag,
11168 set_ssl_handshake_time_out,
11169 set_access_logger){};
11171 ~up_thread_realserver_connect_test_class(){};
11174 l7vs::tcp_session::up_thread_realserver_connect(LOCAL_PROC);
11177 void set_protocol_module(l7vs::protocol_module_base* set_prot){
11178 protocol_module = set_prot;
11180 l7vs::tcp_data& get_up_thread_data_client_side(){
11181 return up_thread_data_client_side;
11183 l7vs::tcp_data& get_up_thread_data_dest_side(){
11184 return up_thread_data_dest_side;
11186 l7vs::tcp_data& get_down_thread_data_client_side(){
11187 return down_thread_data_client_side;
11189 l7vs::tcp_data& get_down_thread_data_dest_side(){
11190 return down_thread_data_dest_side;
11192 l7vs::tcp_socket& get_client_socket(){
11193 return client_socket;
11195 socket_element& get_sorryserver_socket(){
11196 return sorryserver_socket;
11198 std::list<socket_element>& get_down_thread_receive_realserver_socket_list(){
11199 return down_thread_receive_realserver_socket_list;
11201 std::map<endpoint,tcp_socket_ptr>& get_up_thread_send_realserver_socket_map(){
11202 return up_thread_send_realserver_socket_map;
11204 std::list<socket_element>::iterator& get_down_thread_current_receive_realserver_socket(){
11205 return down_thread_current_receive_realserver_socket;
11207 l7vs::tcp_realserver_connect_socket_list& get_down_thread_connect_socket_list(){
11208 return down_thread_connect_socket_list;
11212 void set_up_thread_id(boost::thread::id set_id){
11213 up_thread_id = set_id;
11215 void set_down_thread_id(boost::thread::id set_id){
11216 down_thread_id = set_id;
11219 void next_up_function_call(){
11220 up_thread_next_call_function.second(LOCAL_PROC);
11222 void next_down_function_call(){
11223 down_thread_next_call_function.second(LOCAL_PROC);
11226 void set_up_thread_next_function_call_exit(){
11227 up_thread_function_pair fun_it = up_thread_function_array[UP_FUNC_EXIT];
11228 up_thread_next_call_function = fun_it;
11231 void set_down_thread_next_function_call_exit(){
11232 down_thread_function_pair fun_it = down_thread_function_array[DOWN_FUNC_EXIT];
11233 down_thread_next_call_function = fun_it;
11236 // next call function check
11237 void up_thread_realserver_connect_event(const TCP_PROCESS_TYPE_TAG process_type){
11238 up_thread_realserver_connect_event_call_check = true;
11240 bool up_thread_realserver_connect_event_call_check;
11241 void up_thread_realserver_connection_fail_event(const TCP_PROCESS_TYPE_TAG process_type){
11242 up_thread_realserver_connection_fail_event_check = true;
11244 bool up_thread_realserver_connection_fail_event_check;
11246 void up_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
11247 up_thread_exit_call_check = true;
11249 bool up_thread_exit_call_check;
11251 void down_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
11252 down_thread_exit_call_check = true;
11254 bool down_thread_exit_call_check;
11257 void up_thread_function_array_clear(){
11258 for(int i = 0;i <= UP_FUNC_EXIT;i++){
11259 up_thread_function_array[i].second = NULL;
11262 void down_thread_function_array_clear(){
11263 for(int i = 0;i <= DOWN_FUNC_EXIT;i++){
11264 down_thread_function_array[i].second = NULL;
11268 void up_thread_module_event_map_clear(){
11269 up_thread_module_event_map.clear();
11272 void down_thread_module_event_map_clear(){
11273 down_thread_module_event_map.clear();
11277 void up_thread_realserver_connect_test(){
11278 BOOST_MESSAGE( "----- up_thread_realserver_connect test start -----" );
11280 boost::asio::io_service io;
11281 l7vs::virtualservice_tcp vs;
11284 std::string test_protocol_name("test protocol");
11285 l7vs::test_protocol_module proto_test(test_protocol_name);
11287 l7vs::tcp_socket_option_info set_option;
11288 //! TCP_NODELAY (false:not set,true:set option)
11289 set_option.nodelay_opt = true;
11290 //! TCP_NODELAY option value (false:off,true:on)
11291 set_option.nodelay_val = true;
11292 //! TCP_CORK (false:not set,true:set option)
11293 set_option.cork_opt = true;
11294 //! TCP_CORK option value (false:off,true:on)
11295 set_option.cork_val = true;
11296 //! TCP_QUICKACK (false:not set,true:set option)
11297 set_option.quickack_opt = true;
11298 //! TCP_QUICKACK option value (false:off,true:on)
11299 set_option.quickack_val = true;
11301 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
11302 bool set_mode(false);
11303 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
11304 bool set_ssl_cache_flag(false);
11305 int set_ssl_handshake_time_out = 0;
11306 l7vs::logger_implement_access* plogger = NULL;// new l7vs::logger_implement_access(access_log_file_name);
11308 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);
11310 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
11311 boost::thread::id proc_id = boost::this_thread::get_id();
11313 l7vs::tcp_data& con_data = test_obj.get_up_thread_data_dest_side();
11314 boost::asio::ip::tcp::endpoint con_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP),DUMMI_SERVER_PORT);
11316 //up_thread_data_dest_side set
11317 con_data.initialize();
11318 con_data.set_endpoint(con_end);
11320 test_obj.set_up_thread_id(boost::thread::id());
11321 test_obj.set_down_thread_id(proc_id);
11323 l7vs::tcp_socket::connect_res = true;
11324 l7vs::tcp_socket::connect_connect_endpoint = boost::asio::ip::tcp::endpoint();
11325 l7vs::tcp_socket::connect_ec = NULL;
11326 l7vs::tcp_socket::connect_call_check = false;
11327 l7vs::tcp_socket::is_connect = true;
11329 vs.connection_active_list.clear();
11331 std::map< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > >& rs_map = test_obj.get_up_thread_send_realserver_socket_map();
11333 // connection list set
11334 l7vs::tcp_realserver_connect_socket_list& con_list = test_obj.get_down_thread_connect_socket_list();
11337 test_obj.set_up_thread_next_function_call_exit();
11338 test_obj.up_thread_realserver_connect_event_call_check = false;
11341 test_mirror_server test_server;
11343 test_server.breq_acc_flag = true;
11345 test_server.breq_close_wait_flag = true;
11347 test_server.req_recv_cnt = 0;
11348 // test server start
11349 boost::thread server_thread(boost::bind(&test_mirror_server::run,&test_server));
11350 while( !test_server.brun_flag ){
11354 test_obj.test_call();
11356 // unit_test [1] up_thread_realserver_connect socket connect call check
11357 std::cout << "[1] up_thread_realserver_connect socket connect call check" << std::endl;
11358 BOOST_CHECK(con_end == l7vs::tcp_socket::connect_connect_endpoint);
11359 BOOST_CHECK(l7vs::tcp_socket::connect_ec != NULL);
11360 BOOST_CHECK(l7vs::tcp_socket::connect_call_check);
11362 // unit_test [2] up_thread_realserver_connect virtualservice connection_active call check
11363 std::cout << "[2] up_thread_realserver_connect virtualservice connection_active call check" << std::endl;
11364 BOOST_CHECK(!vs.connection_active_list.empty());
11365 BOOST_CHECK(*(vs.connection_active_list.begin()) == con_end);
11367 // unit_test [3] up_thread_realserver_connect up_thread_send_realserver_socket_map insert check
11368 std::cout << "[3] up_thread_realserver_connect up_thread_send_realserver_socket_map insert check" << std::endl;
11369 BOOST_CHECK(!rs_map.empty());
11370 BOOST_CHECK(rs_map.begin()->first == con_end);
11371 BOOST_CHECK(rs_map.begin()->second != NULL);
11372 std::cout << l7vs::Logger::putLogError_message << std::endl;
11374 // unit_test [4] up_thread_realserver_connect down_thread_connect_socket_list push check
11375 std::cout << "[4] up_thread_realserver_connect down_thread_connect_socket_list push check" << std::endl;
11376 BOOST_CHECK(!con_list.empty());
11377 std::pair<boost::asio::ip::tcp::endpoint,boost::shared_ptr<l7vs::tcp_socket> > set_socket = con_list.get_socket();
11378 BOOST_CHECK(set_socket.first == con_end);
11379 BOOST_CHECK(set_socket.second == rs_map.begin()->second);
11382 // unit_test [5] constructer realserver socket set socket option check
11383 std::cout << "[5] constructer realserver socket set socket option check" << std::endl;
11385 BOOST_CHECK_EQUAL(rs_map.begin()->second->opt_info.nodelay_opt , set_option.nodelay_opt);
11386 BOOST_CHECK_EQUAL(rs_map.begin()->second->opt_info.nodelay_val , set_option.nodelay_val);
11388 BOOST_CHECK_EQUAL(rs_map.begin()->second->opt_info.cork_opt , set_option.cork_opt);
11389 BOOST_CHECK_EQUAL(rs_map.begin()->second->opt_info.cork_val , set_option.cork_val);
11391 BOOST_CHECK_EQUAL(rs_map.begin()->second->opt_info.quickack_opt , set_option.quickack_opt);
11392 BOOST_CHECK_EQUAL(rs_map.begin()->second->opt_info.quickack_val , set_option.quickack_val);
11396 // unit_test [6] up_thread_realserver_connect up_thread_next_call_function update check
11397 std::cout << "[6] up_thread_realserver_connect up_thread_next_call_function update check" << std::endl;
11398 test_obj.next_up_function_call();
11399 BOOST_CHECK(test_obj.up_thread_realserver_connect_event_call_check);
11401 l7vs::tcp_socket::is_connect = false;
11403 // unit_test [7] up_thread_realserver_connect duplication check
11404 std::cout << "[7] up_thread_realserver_connect duplication check" << std::endl;
11405 l7vs::tcp_socket::connect_call_check = false;
11406 test_obj.test_call();
11407 BOOST_CHECK(!l7vs::tcp_socket::connect_call_check);
11408 test_obj.up_thread_realserver_connect_event_call_check = false;
11409 test_obj.next_up_function_call();
11410 BOOST_CHECK(test_obj.up_thread_realserver_connect_event_call_check);
11412 // unit_test [8] up_thread_realserver_connect connect fail check
11413 std::cout << "[8] up_thread_realserver_connect connect fail check" << std::endl;
11416 l7vs::tcp_socket::connect_res = false;
11417 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
11418 l7vs::Logger::putLogError_id = 0;
11419 test_obj.test_call();
11420 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
11421 BOOST_CHECK_EQUAL(37,l7vs::Logger::putLogError_id);
11422 std::cout << l7vs::Logger::putLogError_message << std::endl;
11423 BOOST_CHECK(rs_map.empty());
11424 BOOST_CHECK(con_list.empty());
11425 test_obj.up_thread_realserver_connection_fail_event_check = false;
11426 test_obj.next_up_function_call();
11427 BOOST_CHECK(test_obj.up_thread_realserver_connection_fail_event_check);
11429 l7vs::tcp_socket::connect_res = true;
11431 // unit_test [9] up_thread_realserver_connect set non blocking fail check
11432 std::cout << "[9] up_thread_realserver_connect set non blocking fail check" << std::endl;
11435 l7vs::tcp_socket::set_non_blocking_mode_res = false;
11436 l7vs::tcp_socket::set_non_blocking_mode_ec = boost::asio::error::bad_descriptor;
11437 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
11438 l7vs::Logger::putLogError_id = 0;
11439 test_obj.up_thread_exit_call_check = false;
11440 test_obj.test_call();
11441 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
11442 BOOST_CHECK_EQUAL(34,l7vs::Logger::putLogError_id);
11443 std::cout << l7vs::Logger::putLogError_message << std::endl;
11444 BOOST_CHECK(test_obj.up_thread_exit_call_check);
11445 l7vs::tcp_socket::set_non_blocking_mode_res = true;
11446 l7vs::tcp_socket::set_non_blocking_mode_ec.clear();
11448 // unit_test [10] up_thread_realserver_connect not fond function error check
11449 std::cout << "[10] up_thread_realserver_connect not fond function error check" << std::endl;
11452 test_obj.up_thread_function_array_clear();
11453 test_obj.up_thread_exit_call_check = false;
11454 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
11455 l7vs::Logger::putLogError_id = 0;
11456 test_obj.test_call();
11457 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
11458 BOOST_CHECK_EQUAL(35,l7vs::Logger::putLogError_id);
11459 std::cout << l7vs::Logger::putLogError_message << std::endl;
11460 BOOST_CHECK(test_obj.up_thread_exit_call_check);
11463 set_socket.second->get_socket().close();
11465 // dummy server stop
11466 test_server.breq_close_wait_flag = false;
11467 test_server.bstop_flag = true;
11468 server_thread.join();
11470 BOOST_MESSAGE( "----- up_thread_realserver_connect test end -----" );
11473 //up_thread_realserver_connect access log test
11474 //up_thread_realserver_connect access log class
11475 class up_thread_realserver_connect_access_log_test_class : public l7vs::tcp_session{
11477 up_thread_realserver_connect_access_log_test_class(
11478 l7vs::virtualservice_tcp& vs,
11479 boost::asio::io_service& session_io,
11480 l7vs::tcp_socket_option_info& set_socket_option,
11481 boost::asio::ip::tcp::endpoint listen_endpoint,
11483 boost::asio::ssl::context& set_ssl_context,
11484 bool set_ssl_cache_flag,
11485 int set_ssl_handshake_time_out,
11486 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
11492 set_ssl_cache_flag,
11493 set_ssl_handshake_time_out,
11494 set_access_logger){};
11496 ~up_thread_realserver_connect_access_log_test_class(){};
11499 l7vs::tcp_session::up_thread_realserver_connect(LOCAL_PROC);
11502 void set_protocol_module(l7vs::protocol_module_base* set_prot){
11503 protocol_module = set_prot;
11505 l7vs::tcp_data& get_up_thread_data_client_side(){
11506 return up_thread_data_client_side;
11508 l7vs::tcp_data& get_up_thread_data_dest_side(){
11509 return up_thread_data_dest_side;
11511 l7vs::tcp_data& get_down_thread_data_client_side(){
11512 return down_thread_data_client_side;
11514 l7vs::tcp_data& get_down_thread_data_dest_side(){
11515 return down_thread_data_dest_side;
11517 l7vs::tcp_socket& get_client_socket(){
11518 return client_socket;
11520 socket_element& get_sorryserver_socket(){
11521 return sorryserver_socket;
11523 std::list<socket_element>& get_down_thread_receive_realserver_socket_list(){
11524 return down_thread_receive_realserver_socket_list;
11526 std::map<endpoint,tcp_socket_ptr>& get_up_thread_send_realserver_socket_map(){
11527 return up_thread_send_realserver_socket_map;
11529 std::list<socket_element>::iterator& get_down_thread_current_receive_realserver_socket(){
11530 return down_thread_current_receive_realserver_socket;
11532 l7vs::tcp_realserver_connect_socket_list& get_down_thread_connect_socket_list(){
11533 return down_thread_connect_socket_list;
11537 void set_up_thread_id(boost::thread::id set_id){
11538 up_thread_id = set_id;
11540 void set_down_thread_id(boost::thread::id set_id){
11541 down_thread_id = set_id;
11544 void next_up_function_call(){
11545 up_thread_next_call_function.second(LOCAL_PROC);
11547 void next_down_function_call(){
11548 down_thread_next_call_function.second(LOCAL_PROC);
11551 void set_up_thread_next_function_call_exit(){
11552 up_thread_function_pair fun_it = up_thread_function_array[UP_FUNC_EXIT];
11553 up_thread_next_call_function = fun_it;
11556 void set_down_thread_next_function_call_exit(){
11557 down_thread_function_pair fun_it = down_thread_function_array[DOWN_FUNC_EXIT];
11558 down_thread_next_call_function = fun_it;
11561 // next call function check
11562 void up_thread_realserver_connect_event(const TCP_PROCESS_TYPE_TAG process_type){
11563 up_thread_realserver_connect_event_call_check = true;
11565 bool up_thread_realserver_connect_event_call_check;
11566 void up_thread_realserver_connection_fail_event(const TCP_PROCESS_TYPE_TAG process_type){
11567 up_thread_realserver_connection_fail_event_check = true;
11569 bool up_thread_realserver_connection_fail_event_check;
11571 void up_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
11572 up_thread_exit_call_check = true;
11574 bool up_thread_exit_call_check;
11576 void down_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
11577 down_thread_exit_call_check = true;
11579 bool down_thread_exit_call_check;
11582 void up_thread_function_array_clear(){
11583 for(int i = 0;i <= UP_FUNC_EXIT;i++){
11584 up_thread_function_array[i].second = NULL;
11587 void down_thread_function_array_clear(){
11588 for(int i = 0;i <= DOWN_FUNC_EXIT;i++){
11589 down_thread_function_array[i].second = NULL;
11593 void up_thread_module_event_map_clear(){
11594 up_thread_module_event_map.clear();
11597 void down_thread_module_event_map_clear(){
11598 down_thread_module_event_map.clear();
11602 void set_client_endpoint(boost::asio::ip::tcp::endpoint& set_endpoint){
11603 client_endpoint = set_endpoint;
11606 std::string get_test_string(boost::asio::ip::tcp::endpoint& set_endpoint){
11607 return endpoint_to_string(set_endpoint);
11610 void set_access_log_flag( bool set_flag ){
11611 access_log_flag = set_flag;
11615 void up_thread_realserver_connect_access_log_test(){
11616 BOOST_MESSAGE( "----- up_thread_realserver_connect access log test start -----" );
11618 boost::asio::io_service io;
11619 l7vs::virtualservice_tcp vs;
11621 std::string test_protocol_name("test protocol");
11622 l7vs::test_protocol_module proto_test(test_protocol_name);
11624 l7vs::tcp_socket_option_info set_option;
11625 //! TCP_NODELAY (false:not set,true:set option)
11626 set_option.nodelay_opt = false;
11627 //! TCP_NODELAY option value (false:off,true:on)
11628 set_option.nodelay_val = false;
11629 //! TCP_CORK (false:not set,true:set option)
11630 set_option.cork_opt = false;
11631 //! TCP_CORK option value (false:off,true:on)
11632 set_option.cork_val = false;
11633 //! TCP_QUICKACK (false:not set,true:set option)
11634 set_option.quickack_opt = false;
11635 //! TCP_QUICKACK option value (false:off,true:on)
11636 set_option.quickack_val = false;
11638 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string("192.168.0.1"), 8080);
11639 bool set_mode(false);
11640 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
11641 bool set_ssl_cache_flag(false);
11642 int set_ssl_handshake_time_out = 0;
11643 l7vs::logger_implement_access* plogger = new l7vs::logger_implement_access( "test.log" );
11645 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);
11646 test_obj.set_access_log_flag(true);
11649 boost::asio::ip::tcp::endpoint client_src_endpoint(boost::asio::ip::address::from_string("192.168.10.20"), 54321);
11650 test_obj.set_client_endpoint(client_src_endpoint);
11652 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
11653 boost::thread::id proc_id = boost::this_thread::get_id();
11655 l7vs::tcp_data& con_data = test_obj.get_up_thread_data_dest_side();
11656 boost::asio::ip::tcp::endpoint con_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP),DUMMI_SERVER_PORT);
11658 //up_thread_data_dest_side set
11659 con_data.initialize();
11660 con_data.set_endpoint(con_end);
11662 test_obj.set_up_thread_id(boost::thread::id());
11663 test_obj.set_down_thread_id(proc_id);
11665 l7vs::tcp_socket::connect_res = true;
11666 l7vs::tcp_socket::connect_connect_endpoint = boost::asio::ip::tcp::endpoint();
11667 l7vs::tcp_socket::connect_ec = NULL;
11668 l7vs::tcp_socket::connect_call_check = false;
11669 l7vs::tcp_socket::is_connect = true;
11671 vs.connection_active_list.clear();
11673 std::map< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > >& rs_map = test_obj.get_up_thread_send_realserver_socket_map();
11675 // connection list set
11676 l7vs::tcp_realserver_connect_socket_list& con_list = test_obj.get_down_thread_connect_socket_list();
11679 test_obj.set_up_thread_next_function_call_exit();
11680 test_obj.up_thread_realserver_connect_event_call_check = false;
11683 test_mirror_server test_server;
11685 test_server.breq_acc_flag = true;
11687 test_server.breq_close_wait_flag = true;
11689 test_server.req_recv_cnt = 0;
11690 // test server start
11691 boost::thread server_thread(boost::bind(&test_mirror_server::run,&test_server));
11692 while( !test_server.brun_flag ){
11696 test_obj.test_call();
11698 BOOST_CHECK(con_end == l7vs::tcp_socket::connect_connect_endpoint);
11699 BOOST_CHECK(l7vs::tcp_socket::connect_ec != NULL);
11700 BOOST_CHECK(l7vs::tcp_socket::connect_call_check);
11702 BOOST_CHECK(!con_list.empty());
11703 std::pair<boost::asio::ip::tcp::endpoint,boost::shared_ptr<l7vs::tcp_socket> > set_socket = con_list.get_socket();
11704 BOOST_CHECK(set_socket.first == con_end);
11705 BOOST_CHECK(set_socket.second == rs_map.begin()->second);
11707 std::string cl_rm_end = test_obj.get_test_string( client_src_endpoint );
11708 std::string cl_lo_end = test_obj.get_test_string( listen_endpoint );
11709 boost::asio::ip::tcp::endpoint rs_local = set_socket.second->get_socket().local_endpoint();
11710 std::string rs_lo_end = test_obj.get_test_string( rs_local );
11711 std::string rs_rm_end = test_obj.get_test_string( con_end );
11713 // unit_test [1] up_thread_realserver_connect client endpoint string check
11714 std::cout << "[1] up_thread_realserver_connect client endpoint string check" << std::endl;
11715 BOOST_CHECK_EQUAL( cl_rm_end , plogger->putLog_cl_con_org );
11716 // unit_test [2] up_thread_realserver_connect virtualservice endpoint string check
11717 std::cout << "[2] up_thread_realserver_connect virtualservice endpoint string check" << std::endl;
11718 BOOST_CHECK_EQUAL( cl_lo_end , plogger->putLog_vsinfo );
11719 // unit_test [3] up_thread_realserver_connect realserver local endpoint string check
11720 std::cout << "[3] up_thread_realserver_connect realserver local endpoint string check" << std::endl;
11721 BOOST_CHECK_EQUAL( rs_lo_end , plogger->putLog_rs_con_org );
11722 // unit_test [4] up_thread_realserver_connect realserver remote endpoint string check
11723 std::cout << "[4] up_thread_realserver_connect realserver remote endpoint string check" << std::endl;
11724 BOOST_CHECK_EQUAL( rs_rm_end , plogger->putLog_rs_con_dest );
11725 // unit_test [5] up_thread_realserver_connect realserver local endpoint string check
11726 std::cout << "[5] up_thread_realserver_connect realserver local endpoint string check" << std::endl;
11727 BOOST_CHECK_EQUAL( "" , plogger->putLog_msg );
11732 set_socket.second->get_socket().close();
11734 // dummy server stop
11735 test_server.breq_close_wait_flag = false;
11736 test_server.bstop_flag = true;
11737 server_thread.join();
11742 BOOST_MESSAGE( "----- up_thread_realserver_connect access log end -----" );
11745 //up_thread_sorryserver_connect test
11746 //up_thread_sorryserver_connect test class
11747 class up_thread_sorryserver_connect_test_class : public l7vs::tcp_session{
11749 // up_thread_sorryserver_connect_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){
11751 up_thread_sorryserver_connect_test_class(
11752 l7vs::virtualservice_tcp& vs,
11753 boost::asio::io_service& session_io,
11754 l7vs::tcp_socket_option_info& set_socket_option,
11755 boost::asio::ip::tcp::endpoint listen_endpoint,
11757 boost::asio::ssl::context& set_ssl_context,
11758 bool set_ssl_cache_flag,
11759 int set_ssl_handshake_time_out,
11760 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
11766 set_ssl_cache_flag,
11767 set_ssl_handshake_time_out,
11768 set_access_logger){};
11770 ~up_thread_sorryserver_connect_test_class(){};
11773 l7vs::tcp_session::up_thread_sorryserver_connect(LOCAL_PROC);
11776 void set_protocol_module(l7vs::protocol_module_base* set_prot){
11777 protocol_module = set_prot;
11779 l7vs::tcp_data& get_up_thread_data_client_side(){
11780 return up_thread_data_client_side;
11782 l7vs::tcp_data& get_up_thread_data_dest_side(){
11783 return up_thread_data_dest_side;
11785 l7vs::tcp_data& get_down_thread_data_client_side(){
11786 return down_thread_data_client_side;
11788 l7vs::tcp_data& get_down_thread_data_dest_side(){
11789 return down_thread_data_dest_side;
11791 l7vs::tcp_socket& get_client_socket(){
11792 return client_socket;
11794 socket_element& get_sorryserver_socket(){
11795 return sorryserver_socket;
11797 std::list<socket_element>& get_down_thread_receive_realserver_socket_list(){
11798 return down_thread_receive_realserver_socket_list;
11800 std::map<endpoint,tcp_socket_ptr>& get_up_thread_send_realserver_socket_map(){
11801 return up_thread_send_realserver_socket_map;
11803 std::list<socket_element>::iterator& get_down_thread_current_receive_realserver_socket(){
11804 return down_thread_current_receive_realserver_socket;
11806 l7vs::tcp_realserver_connect_socket_list& get_down_thread_connect_socket_list(){
11807 return down_thread_connect_socket_list;
11811 void set_up_thread_id(boost::thread::id set_id){
11812 up_thread_id = set_id;
11814 void set_down_thread_id(boost::thread::id set_id){
11815 down_thread_id = set_id;
11818 void next_up_function_call(){
11819 up_thread_next_call_function.second(LOCAL_PROC);
11821 void next_down_function_call(){
11822 down_thread_next_call_function.second(LOCAL_PROC);
11825 void set_up_thread_next_function_call_exit(){
11826 up_thread_function_pair fun_it = up_thread_function_array[UP_FUNC_EXIT];
11827 up_thread_next_call_function = fun_it;
11830 void set_down_thread_next_function_call_exit(){
11831 down_thread_function_pair fun_it = down_thread_function_array[DOWN_FUNC_EXIT];
11832 down_thread_next_call_function = fun_it;
11835 // next call function check
11836 void up_thread_sorryserver_connect_event(const TCP_PROCESS_TYPE_TAG process_type){
11837 up_thread_sorryserver_connect_event_call_check = true;
11839 bool up_thread_sorryserver_connect_event_call_check;
11841 void up_thread_sorryserver_connection_fail_event(const TCP_PROCESS_TYPE_TAG process_type){
11842 up_thread_sorryserver_connection_fail_event_check = true;
11844 bool up_thread_sorryserver_connection_fail_event_check;
11846 void up_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
11847 up_thread_exit_call_check = true;
11849 bool up_thread_exit_call_check;
11851 void down_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
11852 down_thread_exit_call_check = true;
11854 bool down_thread_exit_call_check;
11857 void up_thread_function_array_clear(){
11858 for(int i = 0;i <= UP_FUNC_EXIT;i++){
11859 up_thread_function_array[i].second = NULL;
11862 void down_thread_function_map_clear(){
11863 for(int i = 0;i <= DOWN_FUNC_EXIT;i++){
11864 down_thread_function_array[i].second = NULL;
11868 void up_thread_module_event_map_clear(){
11869 up_thread_module_event_map.clear();
11872 void down_thread_module_event_map_clear(){
11873 down_thread_module_event_map.clear();
11877 void up_thread_sorryserver_connect_test(){
11878 BOOST_MESSAGE( "----- up_thread_sorryserver_connect test start -----" );
11879 l7vs::virtualservice_tcp vs;
11880 boost::asio::io_service io;
11881 l7vs::tcp_socket_option_info set_option;
11882 //! TCP_NODELAY (false:not set,true:set option)
11883 set_option.nodelay_opt = false;
11884 //! TCP_NODELAY option value (false:off,true:on)
11885 set_option.nodelay_val = false;
11886 //! TCP_CORK (false:not set,true:set option)
11887 set_option.cork_opt = false;
11888 //! TCP_CORK option value (false:off,true:on)
11889 set_option.cork_val = false;
11890 //! TCP_QUICKACK (false:not set,true:set option)
11891 set_option.quickack_opt = false;
11892 //! TCP_QUICKACK option value (false:off,true:on)
11893 set_option.quickack_val = false;
11895 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
11896 bool set_mode(false);
11897 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
11898 bool set_ssl_cache_flag(false);
11899 int set_ssl_handshake_time_out = 0;
11900 //std::string access_log_file_name = "test";
11901 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
11903 std::string test_protocol_name("test protocol");
11904 l7vs::test_protocol_module proto_test(test_protocol_name);
11905 // up_thread_sorryserver_send
11906 // up_thread_sorryserver_connect_test_class test_obj(vs,io);
11907 up_thread_sorryserver_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);
11909 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
11910 boost::thread::id proc_id = boost::this_thread::get_id();
11912 l7vs::tcp_data& con_data = test_obj.get_up_thread_data_dest_side();
11913 boost::asio::ip::tcp::endpoint con_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP),7000);
11915 //up_thread_data_dest_side set
11916 con_data.initialize();
11917 con_data.set_endpoint(con_end);
11919 test_obj.set_up_thread_id(boost::thread::id());
11920 test_obj.set_down_thread_id(proc_id);
11922 l7vs::tcp_socket::connect_res = true;
11923 l7vs::tcp_socket::connect_connect_endpoint = boost::asio::ip::tcp::endpoint();
11924 l7vs::tcp_socket::connect_ec = NULL;
11925 l7vs::tcp_socket::connect_call_check = false;
11927 test_obj.set_up_thread_next_function_call_exit();
11928 test_obj.up_thread_sorryserver_connect_event_call_check = false;
11930 test_obj.test_call();
11932 // unit_test [1] up_thread_sorryserver_connect socket connect call check
11933 std::cout << "[1] up_thread_sorryserver_connect socket connect call check" << std::endl;
11934 BOOST_CHECK(con_end == l7vs::tcp_socket::connect_connect_endpoint);
11935 BOOST_CHECK(l7vs::tcp_socket::connect_ec != NULL);
11936 BOOST_CHECK(l7vs::tcp_socket::connect_call_check);
11938 // unit_test [2] up_thread_sorryserver_connect up_thread_next_call_function update check
11939 std::cout << "[2] up_thread_sorryserver_connect up_thread_next_call_function update check" << std::endl;
11940 test_obj.next_up_function_call();
11941 BOOST_CHECK(test_obj.up_thread_sorryserver_connect_event_call_check);
11943 // unit_test [3] up_thread_sorryserver_connect connect fail check
11944 std::cout << "[3] up_thread_sorryserver_connect connect fail check" << std::endl;
11945 l7vs::tcp_socket::connect_res = false;
11946 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
11947 l7vs::Logger::putLogError_id = 0;
11948 test_obj.test_call();
11949 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
11950 BOOST_CHECK_EQUAL(54,l7vs::Logger::putLogError_id);
11951 std::cout << l7vs::Logger::putLogError_message << std::endl;
11952 test_obj.up_thread_sorryserver_connection_fail_event_check = false;
11953 test_obj.next_up_function_call();
11954 BOOST_CHECK(test_obj.up_thread_sorryserver_connection_fail_event_check);
11956 l7vs::tcp_socket::connect_res = true;
11958 // unit_test [4] up_thread_realserver_connect set non blocking fail check
11959 std::cout << "[4] up_thread_realserver_connect set non blocking fail check" << std::endl;
11960 l7vs::tcp_socket::set_non_blocking_mode_res = false;
11961 l7vs::tcp_socket::set_non_blocking_mode_ec = boost::asio::error::bad_descriptor;
11962 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
11963 l7vs::Logger::putLogError_id = 0;
11964 test_obj.up_thread_exit_call_check = false;
11965 test_obj.test_call();
11966 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
11967 BOOST_CHECK_EQUAL(53,l7vs::Logger::putLogError_id);
11968 std::cout << l7vs::Logger::putLogError_message << std::endl;
11969 BOOST_CHECK(test_obj.up_thread_exit_call_check);
11970 l7vs::tcp_socket::set_non_blocking_mode_res = true;
11971 l7vs::tcp_socket::set_non_blocking_mode_ec.clear();
11973 // unit_test [5] up_thread_sorryserver_connect not fond function error check
11974 std::cout << "[5] up_thread_sorryserver_connect not fond function error check" << std::endl;
11975 test_obj.up_thread_function_array_clear();
11976 test_obj.up_thread_exit_call_check = false;
11977 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
11978 l7vs::Logger::putLogError_id = 0;
11979 test_obj.test_call();
11980 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
11981 BOOST_CHECK_EQUAL(55,l7vs::Logger::putLogError_id);
11982 std::cout << l7vs::Logger::putLogError_message << std::endl;
11983 BOOST_CHECK(test_obj.up_thread_exit_call_check);
11985 BOOST_MESSAGE( "----- up_thread_sorryserver_connect test end -----" );
11988 //realserver_disconnect test class
11989 class realserver_disconnect_test_class : public l7vs::tcp_session{
11991 // realserver_disconnect_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){
11993 realserver_disconnect_test_class(
11994 l7vs::virtualservice_tcp& vs,
11995 boost::asio::io_service& session_io,
11996 l7vs::tcp_socket_option_info& set_socket_option,
11997 boost::asio::ip::tcp::endpoint listen_endpoint,
11999 boost::asio::ssl::context& set_ssl_context,
12000 bool set_ssl_cache_flag,
12001 int set_ssl_handshake_time_out,
12002 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
12008 set_ssl_cache_flag,
12009 set_ssl_handshake_time_out,
12010 set_access_logger){};
12012 ~realserver_disconnect_test_class(){};
12015 void test_up_call(){
12016 l7vs::tcp_session::up_thread_realserver_disconnect(LOCAL_PROC);
12018 void test_down_call(){
12019 l7vs::tcp_session::down_thread_realserver_disconnect(LOCAL_PROC);
12022 void test_up_all_call(){
12023 l7vs::tcp_session::up_thread_all_realserver_disconnect(LOCAL_PROC);
12025 void test_down_all_call(){
12026 l7vs::tcp_session::down_thread_all_realserver_disconnect(LOCAL_PROC);
12029 module_function_realserver_disconnect_mutex.wrlock();
12031 void mutex_unlock(){
12032 module_function_realserver_disconnect_mutex.unlock();
12034 // bool mutex_trylock(){
12035 // return module_function_realserver_disconnect_mutex.try_lock();
12038 void set_protocol_module(l7vs::protocol_module_base* set_prot){
12039 protocol_module = set_prot;
12041 l7vs::tcp_data& get_up_thread_data_client_side(){
12042 return up_thread_data_client_side;
12044 l7vs::tcp_data& get_up_thread_data_dest_side(){
12045 return up_thread_data_dest_side;
12047 l7vs::tcp_data& get_down_thread_data_client_side(){
12048 return down_thread_data_client_side;
12050 l7vs::tcp_data& get_down_thread_data_dest_side(){
12051 return down_thread_data_dest_side;
12053 l7vs::tcp_socket& get_client_socket(){
12054 return client_socket;
12056 socket_element& get_sorryserver_socket(){
12057 return sorryserver_socket;
12059 std::list<socket_element>& get_down_thread_receive_realserver_socket_list(){
12060 return down_thread_receive_realserver_socket_list;
12062 std::map<endpoint,tcp_socket_ptr>& get_up_thread_send_realserver_socket_map(){
12063 return up_thread_send_realserver_socket_map;
12065 std::list<socket_element>::iterator& get_down_thread_current_receive_realserver_socket(){
12066 return down_thread_current_receive_realserver_socket;
12068 l7vs::tcp_realserver_connect_socket_list& get_down_thread_connect_socket_list(){
12069 return down_thread_connect_socket_list;
12071 l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_down_thread_message_que(){
12072 return down_thread_message_que;
12074 l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_up_thread_message_que(){
12075 return up_thread_message_que;
12078 void set_up_thread_id(boost::thread::id set_id){
12079 up_thread_id = set_id;
12081 void set_down_thread_id(boost::thread::id set_id){
12082 down_thread_id = set_id;
12085 void next_up_function_call(){
12086 up_thread_next_call_function.second(LOCAL_PROC);
12088 void next_down_function_call(){
12089 down_thread_next_call_function.second(LOCAL_PROC);
12092 void set_up_thread_next_function_call_exit(){
12093 up_thread_function_pair fun_it = up_thread_function_array[UP_FUNC_EXIT];
12094 up_thread_next_call_function = fun_it;
12097 void set_down_thread_next_function_call_exit(){
12098 down_thread_function_pair fun_it = down_thread_function_array[DOWN_FUNC_EXIT];
12099 down_thread_next_call_function = fun_it;
12102 // next call function check
12103 void up_thread_realserver_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){
12104 up_thread_realserver_disconnect_event_call_check = true;
12106 bool up_thread_realserver_disconnect_event_call_check;
12108 void down_thread_realserver_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){
12109 down_thread_realserver_disconnect_event_call_check = true;
12111 bool down_thread_realserver_disconnect_event_call_check;
12113 void up_thread_client_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
12114 up_thread_client_disconnect_call_check = true;
12116 bool up_thread_client_disconnect_call_check;
12118 void down_thread_client_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
12119 down_thread_client_disconnect_call_check = true;
12121 bool down_thread_client_disconnect_call_check;
12123 void up_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
12124 up_thread_exit_call_check = true;
12126 bool up_thread_exit_call_check;
12128 void down_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
12129 down_thread_exit_call_check = true;
12131 bool down_thread_exit_call_check;
12134 void up_thread_function_array_clear(){
12135 for(int i = 0;i <= UP_FUNC_EXIT;i++){
12136 up_thread_function_array[i].second = NULL;
12139 void down_thread_function_array_clear(){
12140 for(int i = 0;i <= DOWN_FUNC_EXIT;i++){
12141 down_thread_function_array[i].second = NULL;
12145 void up_thread_module_event_map_clear(){
12146 up_thread_module_event_map.clear();
12149 void down_thread_module_event_map_clear(){
12150 down_thread_module_event_map.clear();
12153 void up_thread_message_down_thread_function_map_clear(){
12154 up_thread_message_down_thread_function_map.clear();
12157 void down_thread_message_up_thread_function_map_clear(){
12158 down_thread_message_up_thread_function_map.clear();
12162 //up_thread_realserver_disconnect test
12163 void up_thread_realserver_disconnect_test(){
12164 BOOST_MESSAGE( "----- up_thread_realserver_disconnect test start -----" );
12166 boost::asio::io_service io;
12167 l7vs::virtualservice_tcp vs;
12168 l7vs::tcp_socket_option_info set_option;
12169 //! TCP_NODELAY (false:not set,true:set option)
12170 set_option.nodelay_opt = false;
12171 //! TCP_NODELAY option value (false:off,true:on)
12172 set_option.nodelay_val = false;
12173 //! TCP_CORK (false:not set,true:set option)
12174 set_option.cork_opt = false;
12175 //! TCP_CORK option value (false:off,true:on)
12176 set_option.cork_val = false;
12177 //! TCP_QUICKACK (false:not set,true:set option)
12178 set_option.quickack_opt = false;
12179 //! TCP_QUICKACK option value (false:off,true:on)
12180 set_option.quickack_val = false;
12182 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
12183 bool set_mode(false);
12184 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
12185 bool set_ssl_cache_flag(false);
12186 int set_ssl_handshake_time_out = 0;
12187 //std::string access_log_file_name = "test";
12188 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
12190 std::string test_protocol_name("test protocol");
12191 l7vs::test_protocol_module proto_test(test_protocol_name);
12192 // realserver_disconnect_test_class test_obj(vs,io);
12193 realserver_disconnect_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
12195 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
12196 boost::thread::id proc_id = boost::this_thread::get_id();
12198 l7vs::tcp_data& discon_data = test_obj.get_up_thread_data_dest_side();
12200 //up_thread_data_dest_side set
12201 boost::asio::ip::tcp::endpoint discon_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP),7001);
12202 discon_data.initialize();
12203 discon_data.set_endpoint(discon_end);
12205 test_obj.set_down_thread_id(boost::thread::id());
12206 test_obj.set_up_thread_id(proc_id);
12208 vs.connection_inactive_list.clear();
12210 // set realserver socket
12211 std::map<boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > >& rs_map = test_obj.get_up_thread_send_realserver_socket_map();
12212 std::map<boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > >::iterator rs_it;
12213 std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > push_pair;
12214 for(int i = 0 ; i < 3 ;i++){
12215 boost::shared_ptr< l7vs::tcp_socket > new_socket(new l7vs::tcp_socket(io));
12216 push_pair.first.address(boost::asio::ip::address::from_string(DUMMI_SERVER_IP));
12217 push_pair.first.port(7000+i);
12218 push_pair.second = new_socket;
12219 new_socket->close_res = true;
12220 new_socket->close_out_ec.clear();
12221 new_socket->close_call_check = false;
12222 rs_map.insert(push_pair);
12225 l7vs::lockfree_queue<l7vs::tcp_thread_message>& down_thread_message_que = test_obj.get_down_thread_message_que();
12226 l7vs::lockfree_queue<l7vs::tcp_thread_message>& up_thread_message_que = test_obj.get_up_thread_message_que();
12227 while( !down_thread_message_que.empty() ){
12228 l7vs::tcp_thread_message* tmp_ptr = down_thread_message_que.pop();
12231 while( !up_thread_message_que.empty() ){
12232 l7vs::tcp_thread_message* tmp_ptr = up_thread_message_que.pop();
12237 test_obj.set_up_thread_next_function_call_exit();
12238 test_obj.up_thread_realserver_disconnect_event_call_check = false;
12240 test_obj.test_up_call();
12242 rs_it = rs_map.find(discon_end);
12244 // unit_test [1] up_thread_realserver_disconnect socket close call check
12245 std::cout << "[1] up_thread_realserver_disconnect socket close call check" << std::endl;
12246 BOOST_CHECK(rs_it != rs_map.end());
12247 BOOST_CHECK(rs_it->second->close_call_check);
12249 // unit_test [2] up_thread_realserver_disconnect virtualservice connection_inactive call check
12250 std::cout << "[2] up_thread_realserver_disconnect virtualservice connection_inactive call check" << std::endl;
12251 BOOST_CHECK(!vs.connection_inactive_list.empty());
12252 BOOST_CHECK(*(vs.connection_inactive_list.begin()) == discon_end);
12254 // unit_test [3] up_thread_realserver_disconnect up thread message set check
12255 std::cout << "[3] up_thread_realserver_disconnect up thread message set check" << std::endl;
12256 BOOST_CHECK(!up_thread_message_que.empty());
12257 l7vs::tcp_thread_message* up_msg = up_thread_message_que.pop();
12258 BOOST_CHECK(up_thread_message_que.empty());
12259 BOOST_CHECK(up_msg->endpoint_info == discon_end);
12260 test_obj.up_thread_realserver_disconnect_event_call_check = false;
12261 up_msg->message(l7vs::tcp_session::MESSAGE_PROC);
12262 BOOST_CHECK(test_obj.up_thread_realserver_disconnect_event_call_check);
12265 // unit_test [4] up_thread_realserver_disconnect down thread message set check
12266 std::cout << "[4] up_thread_realserver_disconnect down thread message set check" << std::endl;
12267 BOOST_CHECK(!down_thread_message_que.empty());
12268 l7vs::tcp_thread_message* down_msg = down_thread_message_que.pop();
12269 BOOST_CHECK(down_thread_message_que.empty());
12270 BOOST_CHECK(down_msg->endpoint_info == discon_end);
12271 test_obj.down_thread_realserver_disconnect_event_call_check = false;
12272 down_msg->message(l7vs::tcp_session::MESSAGE_PROC);
12273 BOOST_CHECK(test_obj.down_thread_realserver_disconnect_event_call_check);
12276 // unit_test [5] up_thread_realserver_disconnect closed socket not set message check
12277 std::cout << "[5] up_thread_realserver_disconnect closed socket not set message check" << std::endl;
12278 rs_it->second->close_res = false;
12279 test_obj.test_up_call();
12280 BOOST_CHECK(up_thread_message_que.empty());
12281 BOOST_CHECK(down_thread_message_que.empty());
12283 rs_it->second->close_res = true;
12285 // unit_test [6] up_thread_realserver_disconnect not fond down_thread_realserver_disconnect_event function error check
12286 std::cout << "[6] up_thread_realserver_disconnect not fond down_thread_realserver_disconnect_event function error check" << std::endl;
12287 test_obj.up_thread_message_down_thread_function_map_clear();
12288 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
12289 l7vs::Logger::putLogError_id = 0;
12290 test_obj.up_thread_exit_call_check = false;
12291 test_obj.test_up_call();
12292 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
12293 BOOST_CHECK_EQUAL(44,l7vs::Logger::putLogError_id);
12294 std::cout << l7vs::Logger::putLogError_message << std::endl;
12295 BOOST_CHECK(test_obj.up_thread_exit_call_check);
12297 // unit_test [7] up_thread_realserver_disconnect not fond up_thread_sorryserver_disconnect_event function error check
12298 std::cout << "[7] up_thread_realserver_disconnect not fond up_thread_sorryserver_disconnect_event function error check" << std::endl;
12299 test_obj.up_thread_function_array_clear();
12300 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
12301 l7vs::Logger::putLogError_id = 0;
12302 test_obj.up_thread_exit_call_check = false;
12303 test_obj.test_up_call();
12304 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
12305 BOOST_CHECK_EQUAL(43,l7vs::Logger::putLogError_id);
12306 std::cout << l7vs::Logger::putLogError_message << std::endl;
12307 BOOST_CHECK(test_obj.up_thread_exit_call_check);
12309 BOOST_MESSAGE( "----- up_thread_realserver_disconnect test end -----" );
12312 //down_thread_realserver_disconnect test
12313 void down_thread_realserver_disconnect_test(){
12314 BOOST_MESSAGE( "----- down_thread_realserver_disconnect test start -----" );
12316 boost::asio::io_service io;
12317 l7vs::virtualservice_tcp vs;
12318 l7vs::tcp_socket_option_info set_option;
12319 //! TCP_NODELAY (false:not set,true:set option)
12320 set_option.nodelay_opt = false;
12321 //! TCP_NODELAY option value (false:off,true:on)
12322 set_option.nodelay_val = false;
12323 //! TCP_CORK (false:not set,true:set option)
12324 set_option.cork_opt = false;
12325 //! TCP_CORK option value (false:off,true:on)
12326 set_option.cork_val = false;
12327 //! TCP_QUICKACK (false:not set,true:set option)
12328 set_option.quickack_opt = false;
12329 //! TCP_QUICKACK option value (false:off,true:on)
12330 set_option.quickack_val = false;
12332 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
12333 bool set_mode(false);
12334 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
12335 bool set_ssl_cache_flag(false);
12336 int set_ssl_handshake_time_out = 0;
12337 //std::string access_log_file_name = "test";
12338 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
12340 std::string test_protocol_name("test protocol");
12341 l7vs::test_protocol_module proto_test(test_protocol_name);
12342 // realserver_disconnect_test_class test_obj(vs,io);
12343 realserver_disconnect_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
12345 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
12346 boost::thread::id proc_id = boost::this_thread::get_id();
12348 l7vs::tcp_data& discon_data = test_obj.get_down_thread_data_dest_side();
12350 //up_thread_data_dest_side set
12351 boost::asio::ip::tcp::endpoint discon_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP),7001);
12352 discon_data.initialize();
12353 discon_data.set_endpoint(discon_end);
12355 test_obj.set_up_thread_id(boost::thread::id());
12356 test_obj.set_down_thread_id(proc_id);
12358 vs.connection_inactive_list.clear();
12360 // set realserver socket
12361 std::list< std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > >& rs_list = test_obj.get_down_thread_receive_realserver_socket_list();
12362 std::list< std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > >::iterator rs_it;
12363 std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > push_pair;
12364 for(int i = 0 ; i < 3 ;i++){
12365 boost::shared_ptr< l7vs::tcp_socket > new_socket(new l7vs::tcp_socket(io));
12366 push_pair.first.address(boost::asio::ip::address::from_string(DUMMI_SERVER_IP));
12367 push_pair.first.port(7000+i);
12368 push_pair.second = new_socket;
12369 new_socket->close_res = true;
12370 new_socket->close_out_ec.clear();
12371 new_socket->close_call_check = false;
12372 rs_list.push_back(push_pair);
12376 l7vs::lockfree_queue<l7vs::tcp_thread_message>& down_thread_message_que = test_obj.get_down_thread_message_que();
12377 l7vs::lockfree_queue<l7vs::tcp_thread_message>& up_thread_message_que = test_obj.get_up_thread_message_que();
12378 while( !down_thread_message_que.empty() ){
12379 l7vs::tcp_thread_message* tmp_ptr = down_thread_message_que.pop();
12382 while( !up_thread_message_que.empty() ){
12383 l7vs::tcp_thread_message* tmp_ptr = up_thread_message_que.pop();
12388 test_obj.set_down_thread_next_function_call_exit();
12389 test_obj.down_thread_realserver_disconnect_event_call_check = false;
12391 test_obj.test_down_call();
12393 rs_it = rs_list.begin();
12394 while(rs_it != rs_list.end()){
12395 if( rs_it->first == discon_end )
12400 // unit_test [1] down_thread_realserver_disconnect socket close call check
12401 std::cout << "[1] down_thread_realserver_disconnect socket close call check" << std::endl;
12402 BOOST_CHECK(rs_it != rs_list.end());
12403 BOOST_CHECK(rs_it->second->close_call_check);
12405 // unit_test [2] down_thread_realserver_disconnect virtualservice connection_inactive call check
12406 std::cout << "[2] down_thread_realserver_disconnect virtualservice connection_inactive call check" << std::endl;
12407 BOOST_CHECK(!vs.connection_inactive_list.empty());
12408 BOOST_CHECK(*(vs.connection_inactive_list.begin()) == discon_end);
12410 // unit_test [3] down_thread_realserver_disconnect up thread message set check
12411 std::cout << "[3] down_thread_realserver_disconnect up thread message set check" << std::endl;
12412 BOOST_CHECK(!up_thread_message_que.empty());
12413 l7vs::tcp_thread_message* up_msg = up_thread_message_que.pop();
12414 BOOST_CHECK(up_thread_message_que.empty());
12415 BOOST_CHECK(up_msg->endpoint_info == discon_end);
12416 test_obj.up_thread_realserver_disconnect_event_call_check = false;
12417 up_msg->message(l7vs::tcp_session::MESSAGE_PROC);
12418 BOOST_CHECK(test_obj.up_thread_realserver_disconnect_event_call_check);
12421 // unit_test [4] up_thread_sorryserver_disconnect down thread message set check
12422 std::cout << "[4] up_thread_sorryserver_disconnect down thread message set check" << std::endl;
12423 BOOST_CHECK(!down_thread_message_que.empty());
12424 l7vs::tcp_thread_message* down_msg = down_thread_message_que.pop();
12425 BOOST_CHECK(down_thread_message_que.empty());
12426 BOOST_CHECK(down_msg->endpoint_info == discon_end);
12427 test_obj.down_thread_realserver_disconnect_event_call_check = false;
12428 down_msg->message(l7vs::tcp_session::MESSAGE_PROC);
12429 BOOST_CHECK(test_obj.down_thread_realserver_disconnect_event_call_check);
12432 // unit_test [5] down_thread_realserver_disconnect closed socket not set message check
12433 std::cout << "[5] down_thread_realserver_disconnect closed socket not set message check" << std::endl;
12434 rs_it->second->close_res = false;
12435 test_obj.test_down_call();
12436 BOOST_CHECK(up_thread_message_que.empty());
12437 BOOST_CHECK(down_thread_message_que.empty());
12439 rs_it->second->close_res = true;
12441 // unit_test [6] down_thread_realserver_disconnect not fond down_thread_realserver_disconnect_event function error check
12442 std::cout << "[6] down_thread_realserver_disconnect not fond down_thread_realserver_disconnect_event function error check" << std::endl;
12443 test_obj.down_thread_message_up_thread_function_map_clear();
12444 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
12445 l7vs::Logger::putLogError_id = 0;
12446 test_obj.down_thread_exit_call_check = false;
12447 test_obj.test_down_call();
12448 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
12449 BOOST_CHECK_EQUAL(73,l7vs::Logger::putLogError_id);
12450 std::cout << l7vs::Logger::putLogError_message << std::endl;
12451 BOOST_CHECK(test_obj.down_thread_exit_call_check);
12453 // unit_test [7] down_thread_realserver_disconnect not fond up_thread_sorryserver_disconnect_event function error check
12454 std::cout << "[7] down_thread_realserver_disconnect not fond up_thread_sorryserver_disconnect_event function error check" << std::endl;
12455 test_obj.down_thread_function_array_clear();
12456 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
12457 l7vs::Logger::putLogError_id = 0;
12458 test_obj.down_thread_exit_call_check = false;
12459 test_obj.test_down_call();
12460 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
12461 BOOST_CHECK_EQUAL(72,l7vs::Logger::putLogError_id);
12462 std::cout << l7vs::Logger::putLogError_message << std::endl;
12463 BOOST_CHECK(test_obj.down_thread_exit_call_check);
12465 BOOST_MESSAGE( "----- down_thread_realserver_disconnect test end -----" );
12469 //up_thread_all_realserver_disconnect test
12470 void up_thread_all_realserver_disconnect_test(){
12471 BOOST_MESSAGE( "----- up_thread_all_realserver_disconnect test start -----" );
12473 boost::asio::io_service io;
12474 l7vs::virtualservice_tcp vs;
12475 l7vs::tcp_socket_option_info set_option;
12476 //! TCP_NODELAY (false:not set,true:set option)
12477 set_option.nodelay_opt = false;
12478 //! TCP_NODELAY option value (false:off,true:on)
12479 set_option.nodelay_val = false;
12480 //! TCP_CORK (false:not set,true:set option)
12481 set_option.cork_opt = false;
12482 //! TCP_CORK option value (false:off,true:on)
12483 set_option.cork_val = false;
12484 //! TCP_QUICKACK (false:not set,true:set option)
12485 set_option.quickack_opt = false;
12486 //! TCP_QUICKACK option value (false:off,true:on)
12487 set_option.quickack_val = false;
12489 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
12490 bool set_mode(false);
12491 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
12492 bool set_ssl_cache_flag(false);
12493 int set_ssl_handshake_time_out = 0;
12494 //std::string access_log_file_name = "test";
12495 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
12497 std::string test_protocol_name("test protocol");
12498 l7vs::test_protocol_module proto_test(test_protocol_name);
12499 // realserver_disconnect_test_class test_obj(vs,io);
12500 realserver_disconnect_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
12501 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
12502 boost::thread::id proc_id = boost::this_thread::get_id();
12504 l7vs::tcp_data& discon_data = test_obj.get_up_thread_data_dest_side();
12506 //up_thread_data_dest_side set
12507 boost::asio::ip::tcp::endpoint discon_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP),7001);
12508 discon_data.initialize();
12509 discon_data.set_endpoint(discon_end);
12511 test_obj.set_down_thread_id(boost::thread::id());
12512 test_obj.set_up_thread_id(proc_id);
12514 vs.connection_inactive_list.clear();
12516 // set realserver socket
12517 std::map<boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > >& rs_map = test_obj.get_up_thread_send_realserver_socket_map();
12518 std::map<boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > >::iterator rs_it;
12519 std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > push_pair;
12520 std::list< std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > > ref_rs_list;
12521 std::list< std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > >::iterator ref_rs_it;
12522 for(int i = 0 ; i < 3 ;i++){
12523 boost::shared_ptr< l7vs::tcp_socket > new_socket(new l7vs::tcp_socket(io));
12524 push_pair.first.address(boost::asio::ip::address::from_string(DUMMI_SERVER_IP));
12525 push_pair.first.port(7000+i);
12526 push_pair.second = new_socket;
12527 new_socket->close_res = true;
12528 new_socket->close_out_ec.clear();
12529 new_socket->close_call_check = false;
12530 rs_map.insert(push_pair);
12531 ref_rs_list.push_back(push_pair);
12534 l7vs::lockfree_queue<l7vs::tcp_thread_message>& down_thread_message_que = test_obj.get_down_thread_message_que();
12535 l7vs::lockfree_queue<l7vs::tcp_thread_message>& up_thread_message_que = test_obj.get_up_thread_message_que();
12536 while( !down_thread_message_que.empty() ){
12537 l7vs::tcp_thread_message* tmp_ptr = down_thread_message_que.pop();
12540 while( !up_thread_message_que.empty() ){
12541 l7vs::tcp_thread_message* tmp_ptr = up_thread_message_que.pop();
12546 test_obj.set_up_thread_next_function_call_exit();
12547 test_obj.up_thread_client_disconnect_call_check = false;
12549 //protocol module set
12550 proto_test.handle_realserver_disconnect_res_tag = l7vs::protocol_module_base::CLIENT_DISCONNECT;
12551 proto_test.handle_realserver_disconnect_thread_id = boost::thread::id();
12552 proto_test.handle_realserver_disconnect_rs_endpoint_list.clear();
12554 test_obj.test_up_all_call();
12556 // unit_test [1] up_thread_all_realserver_disconnect socket close call check
12557 std::cout << "[1] up_thread_all_realserver_disconnect socket close call check" << std::endl;
12558 ref_rs_it = ref_rs_list.begin();
12559 while(ref_rs_it != ref_rs_list.end()){
12560 BOOST_CHECK(ref_rs_it->second->close_call_check);
12564 // unit_test [2] up_thread_all_realserver_disconnect virtualservice connection_inactive call check
12565 std::cout << "[2] up_thread_all_realserver_disconnect virtualservice connection_inactive call check" << std::endl;
12566 BOOST_CHECK(!vs.connection_inactive_list.empty());
12567 ref_rs_it = ref_rs_list.begin();
12568 while(ref_rs_it != ref_rs_list.end()){
12569 std::list<boost::asio::ip::tcp::endpoint>::iterator end_list_it = vs.connection_inactive_list.begin();
12570 while(end_list_it == vs.connection_inactive_list.end()){
12571 if(ref_rs_it->first == *end_list_it)
12575 BOOST_CHECK(end_list_it != vs.connection_inactive_list.end());
12579 // unit_test [3] up_thread_all_realserver_disconnect handle_realserver_disconnect call check
12580 std::cout << "[3] up_thread_all_realserver_disconnect handle_realserver_disconnect call check" << std::endl;
12581 BOOST_CHECK(proto_test.handle_realserver_disconnect_thread_id == proc_id);
12582 BOOST_CHECK(!proto_test.handle_realserver_disconnect_rs_endpoint_list.empty());
12583 ref_rs_it = ref_rs_list.begin();
12584 while(ref_rs_it != ref_rs_list.end()){
12585 std::list<boost::asio::ip::tcp::endpoint>::iterator end_list_it = proto_test.handle_realserver_disconnect_rs_endpoint_list.begin();
12586 while(end_list_it == vs.connection_inactive_list.end()){
12587 if(ref_rs_it->first == *end_list_it)
12591 BOOST_CHECK(end_list_it != proto_test.handle_realserver_disconnect_rs_endpoint_list.end());
12595 // unit_test [4] up_thread_all_realserver_disconnect update up_thread_next_call_function check
12596 std::cout << "[4] up_thread_all_realserver_disconnect update up_thread_next_call_function check" << std::endl;
12597 test_obj.next_up_function_call();
12598 BOOST_CHECK(test_obj.up_thread_client_disconnect_call_check);
12600 // unit_test [5] up_thread_all_realserver_disconnect realserver not fond check
12601 std::cout << "[5] up_thread_all_realserver_disconnect realserver not fond check" << std::endl;
12602 proto_test.handle_realserver_disconnect_thread_id = boost::thread::id();
12603 proto_test.handle_realserver_disconnect_rs_endpoint_list.clear();
12604 test_obj.up_thread_client_disconnect_call_check = false;
12606 test_obj.test_up_all_call();
12608 BOOST_CHECK(proto_test.handle_realserver_disconnect_thread_id == proc_id);
12609 BOOST_CHECK(!proto_test.handle_realserver_disconnect_rs_endpoint_list.empty());
12610 BOOST_CHECK( *(proto_test.handle_realserver_disconnect_rs_endpoint_list.begin()) == boost::asio::ip::tcp::endpoint() );
12611 test_obj.next_up_function_call();
12612 BOOST_CHECK(test_obj.up_thread_client_disconnect_call_check);
12614 // unit_test [6] up_thread_all_realserver_disconnect handle_realserver_disconnect mutex lock check
12615 std::cout << "[6] up_thread_all_realserver_disconnect handle_realserver_disconnect mutex lock check" << std::endl;
12616 ref_rs_it = ref_rs_list.begin();
12617 while(ref_rs_it != ref_rs_list.end()){
12618 rs_map.insert(*ref_rs_it);
12621 proto_test.handle_realserver_disconnect_thread_id = boost::thread::id();
12622 test_obj.mutex_lock();
12623 boost::thread test_thread(boost::bind(&realserver_disconnect_test_class::test_up_all_call,&test_obj));
12625 BOOST_CHECK(proto_test.handle_realserver_disconnect_thread_id == boost::thread::id());
12627 // unit_test [7] up_thread_all_realserver_disconnect handle_realserver_disconnect mutex unlock run check
12628 std::cout << "[7] up_thread_all_realserver_disconnect handle_realserver_disconnect mutex unlock run check" << std::endl;
12629 boost::thread::id test_id = test_thread.get_id();
12630 test_obj.set_up_thread_id(test_id);
12631 test_obj.mutex_unlock();
12633 BOOST_CHECK(proto_test.handle_realserver_disconnect_thread_id == test_id);
12634 test_thread.join();
12636 // unit_test [8] up_thread_all_realserver_disconnect not fond function error check
12637 std::cout << "[8] up_thread_all_realserver_disconnect not fond function error check" << std::endl;
12638 ref_rs_it = ref_rs_list.begin();
12639 while(ref_rs_it != ref_rs_list.end()){
12640 rs_map.insert(*ref_rs_it);
12643 test_obj.up_thread_function_array_clear();
12644 test_obj.up_thread_exit_call_check = false;
12645 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
12646 l7vs::Logger::putLogError_id = 0;
12647 test_obj.test_up_all_call();
12648 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
12649 BOOST_CHECK_EQUAL(48,l7vs::Logger::putLogError_id);
12650 std::cout << l7vs::Logger::putLogError_message << std::endl;
12651 BOOST_CHECK(test_obj.up_thread_exit_call_check);
12653 // unit_test [9] up_thread_all_realserver_disconnect returnd illegal EVENT_TAG error check
12654 std::cout << "[9] up_thread_all_realserver_disconnect returnd illegal EVENT_TAG error check" << std::endl;
12655 ref_rs_it = ref_rs_list.begin();
12656 while(ref_rs_it != ref_rs_list.end()){
12657 rs_map.insert(*ref_rs_it);
12660 test_obj.up_thread_module_event_map_clear();
12661 test_obj.up_thread_exit_call_check = false;
12662 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
12663 l7vs::Logger::putLogError_id = 0;
12664 test_obj.test_up_all_call();
12665 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
12666 BOOST_CHECK_EQUAL(47,l7vs::Logger::putLogError_id);
12667 std::cout << l7vs::Logger::putLogError_message << std::endl;
12668 BOOST_CHECK(test_obj.up_thread_exit_call_check);
12670 BOOST_MESSAGE( "----- up_thread_all_realserver_disconnect test end -----" );
12673 //down_thread_all_realserver_disconnect test
12674 void down_thread_all_realserver_disconnect_test(){
12675 BOOST_MESSAGE( "----- down_thread_all_realserver_disconnect test start -----" );
12677 boost::asio::io_service io;
12678 l7vs::virtualservice_tcp vs;
12679 l7vs::tcp_socket_option_info set_option;
12680 //! TCP_NODELAY (false:not set,true:set option)
12681 set_option.nodelay_opt = false;
12682 //! TCP_NODELAY option value (false:off,true:on)
12683 set_option.nodelay_val = false;
12684 //! TCP_CORK (false:not set,true:set option)
12685 set_option.cork_opt = false;
12686 //! TCP_CORK option value (false:off,true:on)
12687 set_option.cork_val = false;
12688 //! TCP_QUICKACK (false:not set,true:set option)
12689 set_option.quickack_opt = false;
12690 //! TCP_QUICKACK option value (false:off,true:on)
12691 set_option.quickack_val = false;
12693 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
12694 bool set_mode(false);
12695 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
12696 bool set_ssl_cache_flag(false);
12697 int set_ssl_handshake_time_out = 0;
12698 //std::string access_log_file_name = "test";
12699 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
12701 std::string test_protocol_name("test protocol");
12702 l7vs::test_protocol_module proto_test(test_protocol_name);
12703 // realserver_disconnect_test_class test_obj(vs,io);
12704 realserver_disconnect_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
12705 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
12706 boost::thread::id proc_id = boost::this_thread::get_id();
12708 l7vs::tcp_data& discon_data = test_obj.get_down_thread_data_dest_side();
12710 //down_thread_data_dest_side set
12711 boost::asio::ip::tcp::endpoint discon_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP),7001);
12712 discon_data.initialize();
12713 discon_data.set_endpoint(discon_end);
12715 test_obj.set_up_thread_id(boost::thread::id());
12716 test_obj.set_down_thread_id(proc_id);
12718 vs.connection_inactive_list.clear();
12720 // set realserver socket
12721 std::list< std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > >& rs_list = test_obj.get_down_thread_receive_realserver_socket_list();
12722 std::list< std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > >::iterator rs_it;
12723 std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > push_pair;
12724 std::list< std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > > ref_rs_list;
12725 std::list< std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > >::iterator ref_rs_it;
12726 for(int i = 0 ; i < 3 ;i++){
12727 boost::shared_ptr< l7vs::tcp_socket > new_socket(new l7vs::tcp_socket(io));
12728 push_pair.first.address(boost::asio::ip::address::from_string(DUMMI_SERVER_IP));
12729 push_pair.first.port(7000+i);
12730 push_pair.second = new_socket;
12731 new_socket->close_res = true;
12732 new_socket->close_out_ec.clear();
12733 new_socket->close_call_check = false;
12734 rs_list.push_back(push_pair);
12735 ref_rs_list.push_back(push_pair);
12738 l7vs::lockfree_queue<l7vs::tcp_thread_message>& down_thread_message_que = test_obj.get_down_thread_message_que();
12739 l7vs::lockfree_queue<l7vs::tcp_thread_message>& up_thread_message_que = test_obj.get_up_thread_message_que();
12740 while( !down_thread_message_que.empty() ){
12741 l7vs::tcp_thread_message* tmp_ptr = down_thread_message_que.pop();
12744 while( !up_thread_message_que.empty() ){
12745 l7vs::tcp_thread_message* tmp_ptr = up_thread_message_que.pop();
12750 test_obj.set_down_thread_next_function_call_exit();
12751 test_obj.down_thread_client_disconnect_call_check = false;
12753 //protocol module set
12754 proto_test.handle_realserver_disconnect_res_tag = l7vs::protocol_module_base::CLIENT_DISCONNECT;
12755 proto_test.handle_realserver_disconnect_thread_id = boost::thread::id();
12756 proto_test.handle_realserver_disconnect_rs_endpoint_list.clear();
12758 test_obj.test_down_all_call();
12760 // unit_test [1] down_thread_all_realserver_disconnect socket close call check
12761 std::cout << "[1] down_thread_all_realserver_disconnect socket close call check" << std::endl;
12762 ref_rs_it = ref_rs_list.begin();
12763 while(ref_rs_it != ref_rs_list.end()){
12764 BOOST_CHECK(ref_rs_it->second->close_call_check);
12768 // unit_test [2] down_thread_all_realserver_disconnect virtualservice connection_inactive call check
12769 std::cout << "[2] down_thread_all_realserver_disconnect virtualservice connection_inactive call check" << std::endl;
12770 BOOST_CHECK(!vs.connection_inactive_list.empty());
12771 ref_rs_it = ref_rs_list.begin();
12772 while(ref_rs_it != ref_rs_list.end()){
12773 std::list<boost::asio::ip::tcp::endpoint>::iterator end_list_it = vs.connection_inactive_list.begin();
12774 while(end_list_it == vs.connection_inactive_list.end()){
12775 if(ref_rs_it->first == *end_list_it)
12779 BOOST_CHECK(end_list_it != vs.connection_inactive_list.end());
12783 // unit_test [3] down_thread_all_realserver_disconnect handle_realserver_disconnect call check
12784 std::cout << "[3] down_thread_all_realserver_disconnect handle_realserver_disconnect call check" << std::endl;
12785 BOOST_CHECK(proto_test.handle_realserver_disconnect_thread_id == proc_id);
12786 BOOST_CHECK(!proto_test.handle_realserver_disconnect_rs_endpoint_list.empty());
12787 ref_rs_it = ref_rs_list.begin();
12788 while(ref_rs_it != ref_rs_list.end()){
12789 std::list<boost::asio::ip::tcp::endpoint>::iterator end_list_it = proto_test.handle_realserver_disconnect_rs_endpoint_list.begin();
12790 while(end_list_it == vs.connection_inactive_list.end()){
12791 if(ref_rs_it->first == *end_list_it)
12795 BOOST_CHECK(end_list_it != proto_test.handle_realserver_disconnect_rs_endpoint_list.end());
12799 // unit_test [4] down_thread_all_realserver_disconnect update up_thread_next_call_function check
12800 std::cout << "[4] down_thread_all_realserver_disconnect update up_thread_next_call_function check" << std::endl;
12801 test_obj.next_down_function_call();
12802 BOOST_CHECK(test_obj.down_thread_client_disconnect_call_check);
12804 // unit_test [5] down_thread_all_realserver_disconnect realserver not fond check
12805 std::cout << "[5] down_thread_all_realserver_disconnect realserver not fond check" << std::endl;
12806 proto_test.handle_realserver_disconnect_thread_id = boost::thread::id();
12807 proto_test.handle_realserver_disconnect_rs_endpoint_list.clear();
12808 test_obj.down_thread_client_disconnect_call_check = false;
12810 test_obj.test_down_all_call();
12812 BOOST_CHECK(proto_test.handle_realserver_disconnect_thread_id == proc_id);
12813 BOOST_CHECK(!proto_test.handle_realserver_disconnect_rs_endpoint_list.empty());
12814 BOOST_CHECK( *(proto_test.handle_realserver_disconnect_rs_endpoint_list.begin()) == boost::asio::ip::tcp::endpoint() );
12815 test_obj.next_down_function_call();
12816 BOOST_CHECK(test_obj.down_thread_client_disconnect_call_check);
12818 // unit_test [6] down_thread_all_realserver_disconnect handle_realserver_disconnect mutex lock check
12819 std::cout << "[6] down_thread_all_realserver_disconnect handle_realserver_disconnect mutex lock check" << std::endl;
12820 ref_rs_it = ref_rs_list.begin();
12821 while(ref_rs_it != ref_rs_list.end()){
12822 rs_list.push_back(*ref_rs_it);
12825 proto_test.handle_realserver_disconnect_thread_id = boost::thread::id();
12826 test_obj.mutex_lock();
12827 boost::thread test_thread(boost::bind(&realserver_disconnect_test_class::test_down_all_call,&test_obj));
12829 BOOST_CHECK(proto_test.handle_realserver_disconnect_thread_id == boost::thread::id());
12831 // unit_test [7] down_thread_all_realserver_disconnect handle_realserver_disconnect mutex unlock run check
12832 std::cout << "[7] down_thread_all_realserver_disconnect handle_realserver_disconnect mutex unlock run check" << std::endl;
12833 boost::thread::id test_id = test_thread.get_id();
12834 test_obj.set_down_thread_id(test_id);
12835 test_obj.mutex_unlock();
12837 BOOST_CHECK(proto_test.handle_realserver_disconnect_thread_id == test_id);
12838 test_thread.join();
12840 // unit_test [8] down_thread_all_realserver_disconnect not fond function error check
12841 std::cout << "[8] down_thread_all_realserver_disconnect not fond function error check" << std::endl;
12842 ref_rs_it = ref_rs_list.begin();
12843 while(ref_rs_it != ref_rs_list.end()){
12844 rs_list.push_back(*ref_rs_it);
12847 test_obj.down_thread_function_array_clear();
12848 test_obj.down_thread_exit_call_check = false;
12849 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
12850 l7vs::Logger::putLogError_id = 0;
12851 test_obj.test_down_all_call();
12852 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
12853 BOOST_CHECK_EQUAL(77,l7vs::Logger::putLogError_id);
12854 std::cout << l7vs::Logger::putLogError_message << std::endl;
12855 BOOST_CHECK(test_obj.down_thread_exit_call_check);
12857 // unit_test [9] down_thread_all_realserver_disconnect returnd illegal EVENT_TAG error check
12858 std::cout << "[9] down_thread_all_realserver_disconnect returnd illegal EVENT_TAG error check" << std::endl;
12859 ref_rs_it = ref_rs_list.begin();
12860 while(ref_rs_it != ref_rs_list.end()){
12861 rs_list.push_back(*ref_rs_it);
12864 test_obj.down_thread_module_event_map_clear();
12865 test_obj.down_thread_exit_call_check = false;
12866 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
12867 l7vs::Logger::putLogError_id = 0;
12868 test_obj.test_down_all_call();
12869 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
12870 BOOST_CHECK_EQUAL(76,l7vs::Logger::putLogError_id);
12871 std::cout << l7vs::Logger::putLogError_message << std::endl;
12872 BOOST_CHECK(test_obj.down_thread_exit_call_check);
12874 BOOST_MESSAGE( "----- down_thread_all_realserver_disconnect test end -----" );
12882 // ssl_clear_keep_cache test class
12883 class ssl_clear_keep_cache_test_class : public l7vs::tcp_session{
12885 ssl_clear_keep_cache_test_class(
12886 l7vs::virtualservice_tcp& vs,
12887 boost::asio::io_service& session_io,
12888 l7vs::tcp_socket_option_info& set_socket_option,
12889 boost::asio::ip::tcp::endpoint listen_endpoint,
12891 boost::asio::ssl::context& set_ssl_context,
12892 bool set_ssl_cache_flag,
12893 int set_ssl_handshake_time_out,
12894 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
12900 set_ssl_cache_flag,
12901 set_ssl_handshake_time_out,
12902 set_access_logger){};
12905 ~ssl_clear_keep_cache_test_class(){};
12906 bool& get_exit_flag(){
12907 return (bool&)exit_flag;
12910 bool test_call(SSL *clear_ssl){
12911 return ssl_clear_keep_cache(clear_ssl);
12915 //ssl_clear_keep_cache_test test
12916 void ssl_clear_keep_cache_test(){
12917 BOOST_MESSAGE( "----- ssl_clear_keep_cache test start -----" );
12919 boost::asio::io_service io;
12920 boost::system::error_code ec;
12921 authority test_auth;
12924 boost::asio::ssl::context client_ctx(io,boost::asio::ssl::context::sslv23);
12925 client_ctx.set_verify_mode(boost::asio::ssl::context::verify_peer);
12926 client_ctx.load_verify_file(CLIENT_CTX_LOAD_VERIFY_FILE);
12929 boost::asio::ssl::context server_ctx(io,boost::asio::ssl::context::sslv23);
12930 server_ctx.set_options(
12931 boost::asio::ssl::context::default_workarounds
12932 | boost::asio::ssl::context::no_sslv2
12933 | boost::asio::ssl::context::single_dh_use);
12934 server_ctx.set_password_callback(boost::bind(&authority::get_password, &test_auth));
12935 server_ctx.use_certificate_chain_file(SERVER_CTX_CERTIFICATE_CHAIN_FILE);
12936 server_ctx.use_private_key_file(SERVER_CTX_PRIVATE_KEY_FILE, boost::asio::ssl::context::pem);
12937 server_ctx.use_tmp_dh_file(SERVER_CTX_TMP_DH_FILE);
12939 // Set session cache mode on the context.
12940 SSL_CTX_set_session_cache_mode(server_ctx.impl(), (SSL_SESS_CACHE_SERVER | SSL_SESS_CACHE_NO_AUTO_CLEAR));
12941 // Set session cache size on the context.
12942 SSL_CTX_sess_set_cache_size(server_ctx.impl(), 10);
12943 // Set session cache timeout on the context.
12944 SSL_CTX_set_timeout(server_ctx.impl(), 60);
12948 boost::asio::ssl::stream<boost::asio::ip::tcp::socket> test_sock(io,server_ctx);
12951 boost::asio::ip::tcp::endpoint listen_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
12952 boost::asio::ip::tcp::acceptor test_acceptor(io,listen_end,ec);
12955 test_client dummy_cl(io,client_ctx);
12956 dummy_cl.all_lock();
12959 boost::thread cl_thread(boost::bind(&test_client::handshake_test_run,&dummy_cl));
12962 dummy_cl.connect_mutex.unlock();
12963 test_acceptor.accept(test_sock.lowest_layer(),ec);
12965 std::cout << "server side client connect ERROR" << std::endl;
12966 std::cout << ec << std::endl;
12968 std::cout << "server side client connect OK" << std::endl;
12973 dummy_cl.handshake_mutex.unlock();
12974 test_sock.handshake(boost::asio::ssl::stream_base::server,ec);
12976 std::cout << "server side client handshake ERROR" << std::endl;
12977 std::cout << ec << std::endl;
12979 std::cout << "server side handshake OK" << std::endl;
12983 BOOST_CHECK( SSL_CTX_sess_number(server_ctx.impl()) == 1);
12987 dummy_cl.close_mutex.unlock();
12990 test_sock.lowest_layer().close();
12992 BOOST_CHECK(test_sock.impl()->ssl->method != NULL);
12993 BOOST_CHECK(!test_sock.impl()->ssl->new_session);
12994 // BOOST_CHECK(test_sock.impl()->ssl->init_buf != NULL);
12995 BOOST_CHECK(test_sock.impl()->ssl->enc_read_ctx != NULL);
12996 BOOST_CHECK(test_sock.impl()->ssl->enc_write_ctx != NULL);
12997 // BOOST_CHECK(test_sock.impl()->ssl->expand != NULL);
12998 // BOOST_CHECK(test_sock.impl()->ssl->compress != NULL);
13000 test_sock.impl()->ssl->first_packet = 1; //0
13001 test_sock.impl()->ssl->session = (SSL_SESSION*)99; //NULL;
13002 test_sock.impl()->ssl->type = 2; //0;
13003 test_sock.impl()->ssl->error = 3; //0;
13004 test_sock.impl()->ssl->hit = 4; //0;
13005 test_sock.impl()->ssl->shutdown = 5; //0;
13006 test_sock.impl()->ssl->version = 6; // clear_ssl->method->version;
13007 test_sock.impl()->ssl->client_version = 0;//clear_ssl->version;
13008 test_sock.impl()->ssl->rwstate = 0; //SSL_NOTHING;
13009 test_sock.impl()->ssl->rstate = 0; //SSL_ST_READ_HEADER;
13010 test_sock.impl()->ssl->state = 0; //SSL_ST_BEFORE | ( ( clear_ssl->server ) ? SSL_ST_ACCEPT : SSL_ST_CONNECT);
13012 // BOOST_CHECK( test_sock.impl()->ssl->in_handshake || ( test_sock.impl()->ssl->method == test_sock.impl()->ssl->ctx->method ));
13013 // if ( !clear_ssl->in_handshake && ( clear_ssl->method != clear_ssl->ctx->method ))
13015 l7vs::virtualservice_tcp vs;
13016 l7vs::tcp_socket_option_info set_option;
13017 //! TCP_NODELAY (false:not set,true:set option)
13018 set_option.nodelay_opt = true;
13019 //! TCP_NODELAY option value (false:off,true:on)
13020 set_option.nodelay_val = true;
13021 //! TCP_CORK (false:not set,true:set option)
13022 set_option.cork_opt = true;
13023 //! TCP_CORK option value (false:off,true:on)
13024 set_option.cork_val = true;
13025 //! TCP_QUICKACK (false:not set,true:set option)
13026 set_option.quickack_opt = true;
13027 //! TCP_QUICKACK option value (false:off,true:on)
13028 set_option.quickack_val = true;
13030 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
13031 bool set_mode(true);
13032 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
13033 bool set_ssl_cache_flag(true);
13034 int set_ssl_handshake_time_out = 111;
13035 std::string access_log_file_name = "test";
13036 l7vs::logger_implement_access* plogger = new l7vs::logger_implement_access(access_log_file_name);
13038 ssl_clear_keep_cache_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
13041 BOOST_CHECK( SSL_CTX_sess_number(server_ctx.impl()) == 1);
13043 bool bres = test_obj.test_call(test_sock.impl()->ssl);
13045 // unit_test [1] ssl_clear_keep_cache result check
13046 std::cout << "[1] ssl_clear_keep_cache result check" << std::endl;
13047 BOOST_CHECK( bres == true);
13049 // unit_test [2] ssl_clear_keep_cache keep chach check
13050 std::cout << "[2] ssl_clear_keep_cache keep chach check" << std::endl;
13051 BOOST_CHECK( SSL_CTX_sess_number(server_ctx.impl()) == 1);
13054 // unit_test [3] ssl_clear_keep_cache init_buf initialize check
13055 std::cout << "[3] ssl_clear_keep_cache init_buf initialize check" << std::endl;
13056 BOOST_CHECK(test_sock.impl()->ssl->init_buf == NULL);
13057 // unit_test [4] ssl_clear_keep_cache enc_read_ctx initialize check
13058 std::cout << "[4] ssl_clear_keep_cache enc_read_ctx initialize check" << std::endl;
13059 BOOST_CHECK(test_sock.impl()->ssl->enc_read_ctx == NULL);
13060 // unit_test [5] ssl_clear_keep_cache enc_write_ctx initialize check
13061 std::cout << "[5] ssl_clear_keep_cache enc_write_ctx initialize check" << std::endl;
13062 BOOST_CHECK(test_sock.impl()->ssl->enc_write_ctx == NULL);
13063 // unit_test [6] ssl_clear_keep_cache expand initialize check
13064 std::cout << "[6] ssl_clear_keep_cache expand initialize check" << std::endl;
13065 BOOST_CHECK(test_sock.impl()->ssl->expand == NULL);
13066 // unit_test [7] ssl_clear_keep_cache compress initialize check
13067 std::cout << "[7] ssl_clear_keep_cache compress initialize check" << std::endl;
13068 BOOST_CHECK(test_sock.impl()->ssl->compress == NULL);
13070 // unit_test [8] ssl_clear_keep_cache first_packet initialize check
13071 std::cout << "[8] ssl_clear_keep_cache first_packet initialize check" << std::endl;
13072 BOOST_CHECK(test_sock.impl()->ssl->first_packet == 0); //0
13073 // unit_test [9] ssl_clear_keep_cache session initialize check
13074 std::cout << "[9] ssl_clear_keep_cache session initialize check" << std::endl;
13075 BOOST_CHECK(test_sock.impl()->ssl->session == NULL); //NULL;
13076 // unit_test [10] ssl_clear_keep_cache type initialize check
13077 std::cout << "[10] ssl_clear_keep_cache type initialize check" << std::endl;
13078 BOOST_CHECK(test_sock.impl()->ssl->type == 0); //0;
13079 // unit_test [11] ssl_clear_keep_cache error initialize check
13080 std::cout << "[11] ssl_clear_keep_cache error initialize check" << std::endl;
13081 BOOST_CHECK(test_sock.impl()->ssl->error == 0); //0;
13082 // unit_test [12] ssl_clear_keep_cache hit initialize check
13083 std::cout << "[12] ssl_clear_keep_cache hit initialize check" << std::endl;
13084 BOOST_CHECK(test_sock.impl()->ssl->hit == 0); //0;
13085 // unit_test [13] ssl_clear_keep_cache shutdown initialize check
13086 std::cout << "[13] ssl_clear_keep_cache shutdown initialize check" << std::endl;
13087 BOOST_CHECK(test_sock.impl()->ssl->shutdown == 0); //0;
13088 // unit_test [14] ssl_clear_keep_cache version initialize check
13089 std::cout << "[14] ssl_clear_keep_cache version initialize check" << std::endl;
13090 BOOST_CHECK(test_sock.impl()->ssl->version == test_sock.impl()->ssl->method->version); // clear_ssl->method->version;
13091 // unit_test [15] ssl_clear_keep_cache client_version initialize check
13092 std::cout << "[15] ssl_clear_keep_cache client_version initialize check" << std::endl;
13093 BOOST_CHECK(test_sock.impl()->ssl->client_version == test_sock.impl()->ssl->method->version); // clear_ssl->version;
13094 // unit_test [16] ssl_clear_keep_cache rwstate initialize check
13095 std::cout << "[16] ssl_clear_keep_cache rwstate initialize check" << std::endl;
13096 BOOST_CHECK(test_sock.impl()->ssl->rwstate == SSL_NOTHING); // SSL_NOTHING;
13097 // unit_test [17] ssl_clear_keep_cache rstate initialize check
13098 std::cout << "[17] ssl_clear_keep_cache rstate initialize check" << std::endl;
13099 BOOST_CHECK(test_sock.impl()->ssl->rstate == SSL_ST_READ_HEADER); // SSL_ST_READ_HEADER;
13100 // unit_test [18] ssl_clear_keep_cache state initialize check
13101 std::cout << "[18] ssl_clear_keep_cache state initialize check" << std::endl;
13102 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);
13106 test_acceptor.close();
13108 BOOST_MESSAGE( "----- ssl_clear_keep_cache test end -----" );
13111 // initialize_ssl_mode test
13112 // initialize_ssl_mode test class
13113 class initialize_ssl_mode_test_class : public l7vs::tcp_session{
13115 initialize_ssl_mode_test_class(
13116 l7vs::virtualservice_tcp& vs,
13117 boost::asio::io_service& session_io,
13118 l7vs::tcp_socket_option_info& set_socket_option,
13119 boost::asio::ip::tcp::endpoint listen_endpoint,
13121 boost::asio::ssl::context& set_ssl_context,
13122 bool set_ssl_cache_flag,
13123 int set_ssl_handshake_time_out,
13124 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
13130 set_ssl_cache_flag,
13131 set_ssl_handshake_time_out,
13132 set_access_logger){};
13133 ~initialize_ssl_mode_test_class(){};
13135 bool ssl_clear_keep_cache(SSL *clear_ssl){
13136 ssl_clear_keep_cache_call_chk = true;
13137 ssl_clear_keep_cache_set_clear_ssl = clear_ssl;
13138 return ssl_clear_keep_cache_res;
13140 bool ssl_clear_keep_cache_call_chk;
13141 SSL* ssl_clear_keep_cache_set_clear_ssl;
13142 bool ssl_clear_keep_cache_res;
13146 void initialize_ssl_mode_test(){
13147 BOOST_MESSAGE( "----- initialize_ssl_mode test start -----" );
13149 boost::asio::io_service io;
13150 boost::system::error_code ec;
13152 //vs set protocol module
13153 l7vs::virtualservice_tcp vs;
13154 std::string test_protocol_name("test protocol");
13155 l7vs::test_protocol_module proto_test(test_protocol_name);
13156 vs.get_protocol_module_res = &proto_test;
13159 l7vs::tcp_socket_option_info set_option;
13160 //! TCP_NODELAY (false:not set,true:set option)
13161 set_option.nodelay_opt = false;
13162 //! TCP_NODELAY option value (false:off,true:on)
13163 set_option.nodelay_val = false;
13164 //! TCP_CORK (false:not set,true:set option)
13165 set_option.cork_opt = false;
13166 //! TCP_CORK option value (false:off,true:on)
13167 set_option.cork_val = false;
13168 //! TCP_QUICKACK (false:not set,true:set option)
13169 set_option.quickack_opt = false;
13170 //! TCP_QUICKACK option value (false:off,true:on)
13171 set_option.quickack_val = false;
13173 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
13174 bool set_mode(true);
13175 int set_ssl_handshake_time_out = 0;
13176 //std::string access_log_file_name = "test";
13177 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
13179 //tset case 1 ssl_cache_flag on
13180 boost::asio::ssl::context set_context1(io,boost::asio::ssl::context::sslv23);
13181 bool set_ssl_cache_flag1(true);
13182 initialize_ssl_mode_test_class test_obj1(vs,io,set_option,listen_endpoint,set_mode,set_context1,set_ssl_cache_flag1,set_ssl_handshake_time_out,plogger);
13184 // ssl_clear_keep_cache call OK
13185 test_obj1.ssl_clear_keep_cache_call_chk = false;
13186 test_obj1.ssl_clear_keep_cache_set_clear_ssl = NULL;
13187 test_obj1.ssl_clear_keep_cache_res = true;
13190 l7vs::session_result_message msg = test_obj1.initialize();
13192 // unit_test [1] initialize ssl_clear_keep_cache call check
13193 std::cout << "[1] initialize ssl_clear_keep_cache call check" << std::endl;
13194 BOOST_CHECK(test_obj1.ssl_clear_keep_cache_call_chk);
13195 BOOST_CHECK(test_obj1.ssl_clear_keep_cache_set_clear_ssl == test_obj1.get_client_ssl_socket().impl()->ssl);
13196 BOOST_CHECK(msg.flag == false);
13199 // ssl_clear_keep_cache call NG
13200 test_obj1.ssl_clear_keep_cache_call_chk = false;
13201 test_obj1.ssl_clear_keep_cache_set_clear_ssl = NULL;
13202 test_obj1.ssl_clear_keep_cache_res = false;
13205 msg = test_obj1.initialize();
13207 // unit_test [2] initialize ssl_clear_keep_cache call check Error case
13208 std::cout << "[2] initialize ssl_clear_keep_cache call check Error case" << std::endl;
13209 BOOST_CHECK(test_obj1.ssl_clear_keep_cache_call_chk);
13210 BOOST_CHECK(test_obj1.ssl_clear_keep_cache_set_clear_ssl == test_obj1.get_client_ssl_socket().impl()->ssl);
13211 BOOST_CHECK(msg.flag == true);
13214 //tset case 2 ssl_cache_flag off
13215 boost::asio::ssl::context set_context2(io,boost::asio::ssl::context::sslv23);
13216 bool set_ssl_cache_flag2(false);
13217 initialize_ssl_mode_test_class test_obj2(vs,io,set_option,listen_endpoint,set_mode,set_context2,set_ssl_cache_flag2,set_ssl_handshake_time_out,plogger);
13219 SSL_METHOD* pRet = test_obj2.get_client_ssl_socket().impl()->ssl->method;
13220 test_obj2.get_client_ssl_socket().impl()->ssl->method = NULL;
13224 msg = test_obj2.initialize();
13226 // unit_test [3] initialize SSL_clear Error case
13227 std::cout << "[3] initialize SSL_clear Error case" << std::endl;
13228 BOOST_CHECK(msg.flag == true);
13230 test_obj2.get_client_ssl_socket().impl()->ssl->method = pRet;
13233 boost::asio::ssl::context client_ctx(io,boost::asio::ssl::context::sslv23);
13234 client_ctx.set_verify_mode(boost::asio::ssl::context::verify_peer);
13235 client_ctx.load_verify_file(CLIENT_CTX_LOAD_VERIFY_FILE);
13238 authority test_auth;
13239 boost::asio::ssl::context server_ctx(io,boost::asio::ssl::context::sslv23);
13240 server_ctx.set_options(
13241 boost::asio::ssl::context::default_workarounds
13242 | boost::asio::ssl::context::no_sslv2
13243 | boost::asio::ssl::context::single_dh_use);
13244 server_ctx.set_password_callback(boost::bind(&authority::get_password, &test_auth));
13245 server_ctx.use_certificate_chain_file(SERVER_CTX_CERTIFICATE_CHAIN_FILE);
13246 server_ctx.use_private_key_file(SERVER_CTX_PRIVATE_KEY_FILE, boost::asio::ssl::context::pem);
13247 server_ctx.use_tmp_dh_file(SERVER_CTX_TMP_DH_FILE);
13249 // Set session cache mode on the context.
13250 SSL_CTX_set_session_cache_mode(server_ctx.impl(), (SSL_SESS_CACHE_SERVER | SSL_SESS_CACHE_NO_AUTO_CLEAR));
13251 // Set session cache size on the context.
13252 SSL_CTX_sess_set_cache_size(server_ctx.impl(), 10);
13253 // Set session cache timeout on the context.
13254 SSL_CTX_set_timeout(server_ctx.impl(), 60);
13257 bool set_ssl_cache_flag3(false);
13258 initialize_ssl_mode_test_class test_obj3(vs,io,set_option,listen_endpoint,set_mode,server_ctx,set_ssl_cache_flag3,set_ssl_handshake_time_out,plogger);
13262 boost::asio::ip::tcp::endpoint listen_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
13263 boost::asio::ip::tcp::acceptor test_acceptor(io,listen_end,ec);
13266 test_client dummy_cl(io,client_ctx);
13267 dummy_cl.all_lock();
13270 boost::thread cl_thread(boost::bind(&test_client::handshake_test_run,&dummy_cl));
13273 dummy_cl.connect_mutex.unlock();
13274 test_acceptor.accept(test_obj3.get_client_ssl_socket().lowest_layer(),ec);
13276 std::cout << "server side client connect ERROR" << std::endl;
13277 std::cout << ec << std::endl;
13279 std::cout << "server side client connect OK" << std::endl;
13284 dummy_cl.handshake_mutex.unlock();
13285 test_obj3.get_client_ssl_socket().handshake(boost::asio::ssl::stream_base::server,ec);
13287 std::cout << "server side client handshake ERROR" << std::endl;
13288 std::cout << ec << std::endl;
13290 std::cout << "server side handshake OK" << std::endl;
13295 dummy_cl.close_mutex.unlock();
13298 test_obj3.get_client_ssl_socket().lowest_layer().close();
13300 BOOST_CHECK( SSL_CTX_sess_number(server_ctx.impl()) == 1);
13303 msg = test_obj3.initialize();
13305 // unit_test [4] initialize SSL_clear call check
13306 std::cout << "[4] initialize SSL_clear call check" << std::endl;
13308 BOOST_CHECK(msg.flag == false);
13309 BOOST_CHECK( SSL_CTX_sess_number(server_ctx.impl()) == 0);
13311 BOOST_MESSAGE( "----- initialize_ssl_mode test end -----" );
13314 // up_thread_client_accept test
13315 // up_thread_client_accept test class
13316 class up_thread_client_accept_test_class : public l7vs::tcp_session{
13318 up_thread_client_accept_test_class(
13319 l7vs::virtualservice_tcp& vs,
13320 boost::asio::io_service& session_io,
13321 l7vs::tcp_socket_option_info& set_socket_option,
13322 boost::asio::ip::tcp::endpoint listen_endpoint,
13324 boost::asio::ssl::context& set_ssl_context,
13325 bool set_ssl_cache_flag,
13326 int set_ssl_handshake_time_out,
13327 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
13333 set_ssl_cache_flag,
13334 set_ssl_handshake_time_out,
13335 set_access_logger){};
13336 ~up_thread_client_accept_test_class(){};
13339 up_thread_client_accept(LOCAL_PROC);
13342 void handle_ssl_handshake_timer(const boost::system::error_code&){
13343 handle_ssl_handshake_timer_call_chk = true;
13346 bool handle_ssl_handshake_timer_call_chk;
13348 up_thread_function_pair& get_up_thread_next_call_function(){
13349 return up_thread_next_call_function;
13352 bool& get_ssl_flag(){
13356 bool& get_ssl_handshake_timer_flag(){
13357 return ssl_handshake_timer_flag;
13360 int& get_ssl_handshake_time_out(){
13361 return ssl_handshake_time_out;
13364 bool& get_ssl_handshake_time_out_flag(){
13365 return ssl_handshake_time_out_flag;
13368 bool next_func_chk_accept_event(){
13369 return up_thread_next_call_function.first == UP_FUNC_CLIENT_ACCEPT_EVENT;
13371 bool next_func_chk_accept(){
13372 return up_thread_next_call_function.first == UP_FUNC_CLIENT_ACCEPT;
13374 bool next_func_chk_client_disconnect(){
13375 return up_thread_next_call_function.first == UP_FUNC_CLIENT_DISCONNECT;
13378 l7vs::tcp_ssl_socket& get_tcp_client_ssl_socket(){
13379 return client_ssl_socket;
13383 void up_thread_client_accept_test(){
13384 BOOST_MESSAGE( "----- up_thread_client_accept test start -----" );
13386 l7vs::virtualservice_tcp vs;
13387 boost::asio::io_service io;
13388 l7vs::tcp_socket_option_info set_option;
13389 //! TCP_NODELAY (false:not set,true:set option)
13390 set_option.nodelay_opt = false;
13391 //! TCP_NODELAY option value (false:off,true:on)
13392 set_option.nodelay_val = false;
13393 //! TCP_CORK (false:not set,true:set option)
13394 set_option.cork_opt = false;
13395 //! TCP_CORK option value (false:off,true:on)
13396 set_option.cork_val = false;
13397 //! TCP_QUICKACK (false:not set,true:set option)
13398 set_option.quickack_opt = false;
13399 //! TCP_QUICKACK option value (false:off,true:on)
13400 set_option.quickack_val = false;
13402 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
13403 bool set_mode(false);
13404 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
13405 bool set_ssl_cache_flag(false);
13406 int set_ssl_handshake_time_out = 0;
13407 //std::string access_log_file_name = "test";
13408 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
13410 up_thread_client_accept_test_class test_obj(vs,io,set_option,listen_endpoint,set_mode,set_context,set_ssl_cache_flag,set_ssl_handshake_time_out,plogger);
13412 // test case 1 not ssl mode
13413 test_obj.test_call();
13415 // unit_test [1] up_thread_client_accept no ssl mode next func check
13416 std::cout << "[1] up_thread_client_accept no ssl mode next func check" << std::endl;
13417 BOOST_CHECK( test_obj.next_func_chk_accept_event() );
13419 // tset case 2 ssl mode and handshaek time out
13420 test_obj.get_ssl_flag() = true; //SSL mode
13421 test_obj.get_ssl_handshake_time_out_flag() = true; //handshake time out
13423 test_obj.test_call();
13425 // unit_test [2] up_thread_client_accept ssl mode time out case next func check
13426 std::cout << "[2] up_thread_client_accept ssl mode time out case next func check" << std::endl;
13427 BOOST_CHECK( test_obj.next_func_chk_client_disconnect() );
13430 // tset case 3 ssl mode and set timer snd handshake try_again error case check
13431 test_obj.get_ssl_flag() = true; //SSL mode
13432 test_obj.get_ssl_handshake_time_out_flag() = false; //handshake time out
13433 test_obj.get_ssl_handshake_timer_flag() = false; //timer not set
13434 test_obj.get_ssl_handshake_time_out() = 3; //timer set second
13435 test_obj.handle_ssl_handshake_timer_call_chk = false;
13436 test_obj.get_tcp_client_ssl_socket().handshake_call_check = false;
13437 test_obj.get_tcp_client_ssl_socket().handshake_res = false;
13438 test_obj.get_tcp_client_ssl_socket().handshake_set_ec = boost::asio::error::try_again;
13440 test_obj.test_call();
13442 // timer thread start
13443 boost::thread timer_thread(boost::bind(&boost::asio::io_service::run,&io));
13445 // unit_test [3] up_thread_client_accept set timer check
13446 std::cout << "[3] up_thread_client_accept set timer check" << std::endl;
13447 BOOST_CHECK( test_obj.get_ssl_handshake_timer_flag() == true);
13450 std::cout << "1 sec" << std::endl;
13451 BOOST_CHECK( test_obj.handle_ssl_handshake_timer_call_chk == false );
13454 std::cout << "2 sec" << std::endl;
13455 BOOST_CHECK( test_obj.handle_ssl_handshake_timer_call_chk == false );
13458 std::cout << "3 sec" << std::endl;
13459 BOOST_CHECK( test_obj.handle_ssl_handshake_timer_call_chk == true );
13461 timer_thread.join();
13463 // unit_test [4] up_thread_client_accept socket handshake call check
13464 std::cout << "[4] up_thread_client_accept socket handshake call check" << std::endl;
13465 BOOST_CHECK( test_obj.get_tcp_client_ssl_socket().handshake_call_check == true );
13467 // unit_test [5] up_thread_client_accept socket handshake try_again error next func check
13468 std::cout << "[5] up_thread_client_accept socket handshake try_again error next func check" << std::endl;
13469 BOOST_CHECK( test_obj.next_func_chk_accept() );
13472 // tset case 4 ssl mode and handshake ok case check
13473 test_obj.get_ssl_flag() = true; //SSL mode
13474 test_obj.get_ssl_handshake_time_out_flag() = false; //handshake time out
13475 test_obj.get_ssl_handshake_timer_flag() = true; //timer not set
13476 test_obj.get_ssl_handshake_time_out() = 3; //timer set second
13477 test_obj.handle_ssl_handshake_timer_call_chk = false;
13478 test_obj.get_tcp_client_ssl_socket().handshake_call_check = false;
13479 test_obj.get_tcp_client_ssl_socket().handshake_res = true;
13480 test_obj.get_tcp_client_ssl_socket().handshake_set_ec.clear();
13483 test_obj.test_call();
13485 // unit_test [6] up_thread_client_accept socket handshake no error next func check
13486 std::cout << "[6] up_thread_client_accept socket handshake no error next func check" << std::endl;
13487 BOOST_CHECK( test_obj.next_func_chk_accept_event() );
13490 // tset case 5 ssl mode and handshake error case check
13491 test_obj.get_ssl_flag() = true; //SSL mode
13492 test_obj.get_ssl_handshake_time_out_flag() = false; //handshake time out
13493 test_obj.get_ssl_handshake_timer_flag() = true; //timer not set
13494 test_obj.get_ssl_handshake_time_out() = 3; //timer set second
13495 test_obj.handle_ssl_handshake_timer_call_chk = false;
13496 test_obj.get_tcp_client_ssl_socket().handshake_call_check = false;
13497 test_obj.get_tcp_client_ssl_socket().handshake_res = false;
13498 test_obj.get_tcp_client_ssl_socket().handshake_set_ec = boost::asio::error::eof;
13500 test_obj.test_call();
13502 // unit_test [7] up_thread_client_accept socket handshake no error next func check
13503 std::cout << "[7] up_thread_client_accept socket handshake no error next func check" << std::endl;
13504 BOOST_CHECK( test_obj.next_func_chk_client_disconnect() );
13506 BOOST_MESSAGE( "----- up_thread_client_accept test end -----" );
13509 // up_thread_run ssl mode
13510 // up_thread_run ssl mode test class
13511 class up_thread_run_ssl_mode_test_class : public l7vs::tcp_session{
13513 up_thread_run_ssl_mode_test_class(
13514 l7vs::virtualservice_tcp& vs,
13515 boost::asio::io_service& session_io,
13516 l7vs::tcp_socket_option_info& set_socket_option,
13517 boost::asio::ip::tcp::endpoint listen_endpoint,
13519 boost::asio::ssl::context& set_ssl_context,
13520 bool set_ssl_cache_flag,
13521 int set_ssl_handshake_time_out,
13522 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
13528 set_ssl_cache_flag,
13529 set_ssl_handshake_time_out,
13530 set_access_logger){
13534 ~up_thread_run_ssl_mode_test_class(){};
13535 bool& get_exit_flag(){
13536 return (bool&)exit_flag;
13540 bool& get_session_pause_flag(){
13541 return session_pause_flag;
13546 std::bitset<TCP_SESSION_THREAD_STATE_BIT>& get_thread_state(){
13547 return thread_state;
13551 boost::mutex test_thread_wait;
13553 boost::mutex::scoped_lock scope_lock(test_thread_wait);
13555 std::cout << "up_thread_run test call" << std::endl;
13558 while(test_wait){};
13564 void set_protocol_module(l7vs::protocol_module_base* set_proto){
13565 protocol_module = set_proto;
13568 boost::asio::ssl::stream<boost::asio::ip::tcp::socket>& get_client_socket(){
13569 return client_ssl_socket.get_socket();
13573 boost::thread::id& get_up_thread_id(){
13574 return up_thread_id;
13577 boost::thread::id& get_down_thread_id(){
13578 return down_thread_id;
13581 void up_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
13582 up_thread_exit_process_type = process_type;
13583 l7vs::tcp_session::up_thread_exit(process_type);
13584 up_thread_exit_call_check = true;
13586 TCP_PROCESS_TYPE_TAG up_thread_exit_process_type;
13587 bool up_thread_exit_call_check;
13589 void up_thread_all_socket_close(void){
13590 up_thread_all_socket_close_call_check = true;
13592 bool up_thread_all_socket_close_call_check;
13594 void test_message_set(boost::asio::ip::tcp::endpoint set_endpoint){
13595 l7vs::tcp_thread_message* chk_msg = new l7vs::tcp_thread_message;
13596 up_thread_message_que.push(chk_msg);
13597 chk_msg->endpoint_info = set_endpoint;
13598 up_thread_function_pair func = up_thread_function_array[UP_FUNC_EXIT];
13599 chk_msg->message = func.second;
13602 l7vs::tcp_data& get_up_thread_message_data(){
13603 return up_thread_message_data;
13606 void clear_function_array(){
13607 for(int i = 0;i <= UP_FUNC_EXIT;i++){
13608 up_thread_function_array[i].second = NULL;
13611 void clear_event_map(){
13612 up_thread_module_event_map.clear();
13615 void set_up_thread_next_call_function_client_disconnect(){
13616 up_thread_next_call_function = up_thread_function_array[UP_FUNC_CLIENT_DISCONNECT];
13618 void set_up_thread_next_call_function_exit(){
13619 up_thread_next_call_function = up_thread_function_array[UP_FUNC_EXIT];
13623 void up_thread_run_ssl_mode_test(){
13625 BOOST_MESSAGE( "----- up_thread_run ssl mode test start -----" );
13627 boost::asio::io_service io;
13628 l7vs::virtualservice_tcp vs;
13629 l7vs::tcp_socket_option_info set_option;
13630 //! TCP_NODELAY (false:not set,true:set option)
13631 set_option.nodelay_opt = false;
13632 //! TCP_NODELAY option value (false:off,true:on)
13633 set_option.nodelay_val = false;
13634 //! TCP_CORK (false:not set,true:set option)
13635 set_option.cork_opt = false;
13636 //! TCP_CORK option value (false:off,true:on)
13637 set_option.cork_val = false;
13638 //! TCP_QUICKACK (false:not set,true:set option)
13639 set_option.quickack_opt = false;
13640 //! TCP_QUICKACK option value (false:off,true:on)
13641 set_option.quickack_val = false;
13643 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
13644 bool set_mode(true);
13645 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
13646 bool set_ssl_cache_flag(false);
13647 int set_ssl_handshake_time_out = 0;
13648 //std::string access_log_file_name = "test";
13649 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
13651 boost::system::error_code ec;
13653 std::string test_protocol_name("test protocol");
13654 l7vs::test_protocol_module proto_test(test_protocol_name);
13656 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);
13658 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
13659 bool& exit_flag = test_obj.get_exit_flag();
13660 // bool& session_pause_flag = test_obj.get_session_pause_flag();
13661 boost::thread::id& up_thread_id = test_obj.get_up_thread_id();
13662 boost::thread::id& down_thread_id = test_obj.get_down_thread_id();
13665 // std::bitset<TCP_SESSION_THREAD_STATE_BIT>& thread_state = test_obj.get_thread_state();
13666 boost::asio::ssl::stream<boost::asio::ip::tcp::socket>& client_socket = test_obj.get_client_socket();
13668 test_mirror_server test_server;
13670 test_server.breq_acc_flag = true;
13672 test_server.breq_close_wait_flag = true;
13674 test_server.req_recv_cnt = 0;
13675 // test server start
13676 boost::thread server_thread(boost::bind(&test_mirror_server::run,&test_server));
13677 while( !test_server.brun_flag ){
13681 boost::asio::ip::tcp::endpoint connect_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
13682 client_socket.lowest_layer().connect(connect_end,ec);
13684 while(!test_server.bconnect_flag){
13688 test_obj.test_thread_wait.lock();
13690 thread_state[0] = 0; // UP_THREAD_ALIVE
13691 thread_state[1] = 0; // DOWN_THREAD_ALIVE
13692 thread_state[2] = 0; // UP_THREAD_ACTIVE
13693 thread_state[3] = 0; // DOWN_THREAD_ACTIVE
13694 thread_state[4] = 0; // UP_THREAD_LOCK
13695 thread_state[5] = 0; // DOWN_THREAD_LOCK
13697 up_thread_id = boost::thread::id();
13698 boost::thread test_thread(boost::bind(&up_thread_run_ssl_mode_test_class::test_run,&test_obj));
13700 boost::thread::id test_id = test_thread.get_id();
13701 boost::thread::id proc_id = boost::this_thread::get_id();
13704 BOOST_CHECK(!thread_state.test(0)); // UP_THREAD_ALIVE
13705 BOOST_CHECK(!thread_state.test(1)); // DOWN_THREAD_ALIVE
13706 BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
13707 BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
13708 BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
13709 BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
13711 BOOST_CHECK(up_thread_id != test_id);
13712 test_obj.test_thread_wait.unlock();
13715 // unit_test [1] up_thread_run ssl mode test thread id update check
13716 std::cout << "[1] up_thread_run ssl mode test thread id update check" << std::endl;
13717 BOOST_CHECK(up_thread_id == test_id);
13719 // unit_test [2] up_thread_run ssl mode test down thread wait check
13720 std::cout << "[2] up_thread_run ssl mode test down thread wait check" << std::endl;
13722 BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
13723 BOOST_CHECK(!thread_state.test(1)); // DOWN_THREAD_ALIVE
13724 BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
13725 BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
13726 BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
13727 BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
13730 proto_test.handle_session_initialize_res_tag = l7vs::protocol_module_base::FINALIZE;
13731 proto_test.handle_session_initialize_in_up_thread_id = boost::thread::id();
13732 proto_test.handle_session_initialize_in_down_thread_id = boost::thread::id();
13733 proto_test.handle_session_initialize_in_client_endpoint_tcp = boost::asio::ip::tcp::endpoint();
13734 proto_test.handle_session_initialize_in_client_endpoint_udp.address(boost::asio::ip::address::from_string("255.255.255.255"));
13735 proto_test.handle_session_initialize_in_client_endpoint_udp.port(65535);
13736 BOOST_CHECK(proto_test.handle_session_initialize_in_up_thread_id != test_id);
13737 BOOST_CHECK(proto_test.handle_session_initialize_in_down_thread_id != proc_id);
13738 BOOST_CHECK(proto_test.handle_session_initialize_in_client_endpoint_tcp != connect_end);
13739 BOOST_CHECK(proto_test.handle_session_initialize_in_client_endpoint_udp != boost::asio::ip::udp::endpoint());
13740 down_thread_id = proc_id;
13741 // session_pause_flag = true;
13743 // DOWN_THREAD_ALIVE
13744 // thread_state[1] = 1;
13747 // unit_test [3] up_thread_run ssl mode test handle_session_initialize call check
13748 std::cout << "[3] up_thread_run ssl mode test handle_session_initialize call check" << std::endl;
13749 BOOST_CHECK(proto_test.handle_session_initialize_in_up_thread_id == test_id);
13750 BOOST_CHECK(proto_test.handle_session_initialize_in_down_thread_id == proc_id);
13751 BOOST_CHECK(proto_test.handle_session_initialize_in_client_endpoint_tcp == connect_end);
13752 BOOST_CHECK(proto_test.handle_session_initialize_in_client_endpoint_udp == boost::asio::ip::udp::endpoint());
13754 // unit_test [4] up_thread_run ssl mode test state update(UP_THREAD_ACTIVE) check
13755 std::cout << "[4] up_thread_run ssl mode test state update(UP_THREAD_ACTIVE) check" << std::endl;
13756 // BOOST_CHECK(thread_state.test(2)); // UP_THREAD_ACTIVE
13758 // unit_test [5] up_thread_run ssl mode test pause check
13759 std::cout << "[5] up_thread_run ssl mode test pause check" << std::endl;
13760 // BOOST_CHECK(thread_state.test(4)); // UP_THREAD_LOCK
13762 test_obj.up_thread_exit_process_type = l7vs::tcp_session::MESSAGE_PROC;
13763 test_obj.up_thread_exit_call_check = false;
13764 test_obj.up_thread_all_socket_close_call_check = false;
13766 // session_pause_flag = false;
13769 // unit_test [6] up_thread_run ssl mode test restart check
13770 std::cout << "[6] up_thread_run ssl mode test restart check" << std::endl;
13771 // BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
13773 // unit_test [7] up_thread_run ssl mode test up_thread_next_call_function call (up_thread_exit) check
13774 std::cout << "[7] up_thread_run ssl mode test up_thread_next_call_function call (up_thread_exit) check" << std::endl;
13775 BOOST_CHECK(test_obj.up_thread_exit_call_check);
13776 BOOST_CHECK(test_obj.up_thread_exit_process_type == l7vs::tcp_session::LOCAL_PROC);
13778 // unit_test [8] up_thread_run ssl mode test main loop exit check
13779 std::cout << "[8] up_thread_run ssl mode test main loop exit check" << std::endl;
13780 BOOST_CHECK(exit_flag);
13781 // BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
13784 // unit_test [9] up_thread_run ssl mode test up_thread_all_socket_close_call_check call check
13785 std::cout << "[9] up_thread_run ssl mode test up_thread_all_socket_close_call_check call check" << std::endl;
13786 BOOST_CHECK(test_obj.up_thread_all_socket_close_call_check);
13788 // unit_test [10] up_thread_run ssl mode test down thread end wait check
13789 std::cout << "[10] up_thread_run ssl mode test down thread wait check" << std::endl;
13791 BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
13792 BOOST_CHECK(thread_state.test(1)); // DOWN_THREAD_ALIVE
13793 BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
13794 BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
13795 BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
13796 BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
13800 // proto_test.handle_session_finalize_in_up_thread_id = boost::thread::id();
13801 // proto_test.handle_session_finalize_in_down_thread_id = boost::thread::id();
13802 // BOOST_CHECK(proto_test.handle_session_finalize_in_up_thread_id != test_id);
13803 // BOOST_CHECK(proto_test.handle_session_finalize_in_down_thread_id != proc_id);
13804 // vs.release_session_ptr = NULL;
13805 // BOOST_CHECK(vs.release_session_ptr != test_id);
13807 // thread_state[1] = 0;
13810 // unit_test [11] up_thread_run ssl mode test handle_session_finalize call check
13811 std::cout << "[11] up_thread_run ssl mode test handle_session_finalize call check" << std::endl;
13812 BOOST_CHECK(proto_test.handle_session_finalize_in_up_thread_id == test_id);
13813 BOOST_CHECK(proto_test.handle_session_finalize_in_down_thread_id == proc_id);
13815 // unit_test [12] up_thread_run ssl mode test release_session_id call check
13816 std::cout << "[12] up_thread_run ssl mode test release_session_id call check" << std::endl;
13817 // BOOST_CHECK(vs.release_session_id == test_id);
13819 // unit_test [13] up_thread_run ssl mode test state update(UP_THREAD_ACTIVE) check
13820 std::cout << "[13] up_thread_run state update(UP_THREAD_ACTIVE) check" << std::endl;
13821 // BOOST_CHECK(!thread_state.test(0)); // UP_THREAD_ACTIVE
13823 // message call test
13825 // session_pause_flag = false;
13826 l7vs::tcp_data& msg_data = test_obj.get_up_thread_message_data();
13827 test_obj.test_message_set(connect_end);
13829 thread_state[0] = 0; // UP_THREAD_ALIVE
13830 thread_state[1] = 1; // DOWN_THREAD_ALIVE
13831 thread_state[2] = 0; // UP_THREAD_ACTIVE
13832 thread_state[3] = 0; // DOWN_THREAD_ACTIVE
13833 thread_state[4] = 0; // UP_THREAD_LOCK
13834 thread_state[5] = 0; // DOWN_THREAD_LOCK
13836 msg_data.set_endpoint(boost::asio::ip::tcp::endpoint());
13837 test_obj.up_thread_exit_call_check = false;
13838 test_obj.up_thread_exit_process_type = l7vs::tcp_session::LOCAL_PROC;
13839 proto_test.handle_session_initialize_res_tag = l7vs::protocol_module_base::CLIENT_DISCONNECT;
13841 // test thread start
13842 test_obj.test_wait = false;
13845 BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
13846 BOOST_CHECK(thread_state.test(1)); // DOWN_THREAD_ALIVE
13847 BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
13848 BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
13849 BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
13850 BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
13853 // unit_test [14] up_thread_run ssl mode test message call check
13854 std::cout << "[14] up_thread_run ssl mode test message call check" << std::endl;
13855 BOOST_CHECK(test_obj.up_thread_exit_call_check);
13856 BOOST_CHECK(test_obj.up_thread_exit_process_type == l7vs::tcp_session::MESSAGE_PROC);
13858 proto_test.handle_session_initialize_res_tag = l7vs::protocol_module_base::FINALIZE;
13859 // thread_state[1] = 0;
13862 // error test not find function map
13863 test_obj.clear_function_array();
13865 // session_pause_flag = false;
13866 // thread_state[1] = 1;
13868 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
13869 l7vs::Logger::putLogError_id = 0;
13871 test_obj.test_wait = false;
13874 // unit_test [15] up_thread_run ssl mode test not find function map error test
13875 std::cout << "[15] up_thread_run ssl mode test not find function map error test" << std::endl;
13876 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
13877 BOOST_CHECK_EQUAL(15,l7vs::Logger::putLogError_id);
13878 std::cout << l7vs::Logger::putLogError_message << std::endl;
13880 // thread_state[1] = 0;
13883 //error test protocol_module returnd illegal EVENT_TAG
13884 test_obj.clear_event_map();
13886 // session_pause_flag = false;
13887 // thread_state[1] = 1;
13889 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
13890 l7vs::Logger::putLogError_id = 0;
13892 test_obj.test_wait = false;
13895 // unit_test [16] up_thread_run ssl mode test protocol_module returnd illegal EVENT_TAG error test
13896 std::cout << "[16] up_thread_run ssl mode test protocol_module returnd illegal EVENT_TAG error test" << std::endl;
13897 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
13898 BOOST_CHECK_EQUAL(14,l7vs::Logger::putLogError_id);
13899 std::cout << l7vs::Logger::putLogError_message << std::endl;
13901 // thread_state[1] = 0;
13905 // unit_test [17] up_thread_run ssl mode test set non blocking fail check
13906 std::cout << "[17] up_thread_run ssl mode test set non blocking fail check" << std::endl;
13908 // session_pause_flag = false;
13909 // thread_state[1] = 1;
13911 l7vs::tcp_socket::set_non_blocking_mode_res = false;
13912 l7vs::tcp_socket::set_non_blocking_mode_ec = boost::asio::error::bad_descriptor;
13913 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
13914 l7vs::Logger::putLogError_id = 0;
13916 test_obj.test_wait = false;
13919 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
13920 BOOST_CHECK_EQUAL(11,l7vs::Logger::putLogError_id);
13921 std::cout << l7vs::Logger::putLogError_message << std::endl;
13922 l7vs::tcp_socket::set_non_blocking_mode_res = true;
13923 l7vs::tcp_socket::set_non_blocking_mode_ec.clear();
13925 // thread_state[1] = 0;
13928 //error test client endpoint get error
13929 client_socket.lowest_layer().close(ec);
13931 // session_pause_flag = false;
13932 // thread_state[1] = 1;
13934 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
13935 l7vs::Logger::putLogError_id = 0;
13937 test_obj.test_wait = false;
13940 // unit_test [18] up_thread_run ssl mode test client endpoint get error test
13941 std::cout << "[18] up_thread_run ssl mode test client endpoint get error test" << std::endl;
13942 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
13943 BOOST_CHECK_EQUAL(9,l7vs::Logger::putLogError_id);
13944 std::cout << l7vs::Logger::putLogError_message << std::endl;
13946 // thread_state[1] = 0;
13949 //error test protocol module null error
13950 test_obj.set_protocol_module(NULL);
13952 // session_pause_flag = false;
13953 // thread_state[1] = 1;
13955 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
13956 l7vs::Logger::putLogError_id = 0;
13958 test_obj.test_wait = false;
13961 // unit_test [19] up_thread_run ssl mode test protocol module null error test
13962 std::cout << "[19] up_thread_run ssl mode test protocol module null error test" << std::endl;
13963 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
13964 BOOST_CHECK_EQUAL(8,l7vs::Logger::putLogError_id);
13965 std::cout << l7vs::Logger::putLogError_message << std::endl;
13967 // thread_state[1] = 0;
13970 test_obj.test_end = true;
13971 test_obj.test_wait = false;
13972 std::cout << "test_thread.join wait" << std::endl;
13973 test_thread.join();
13974 std::cout << "test_thread.join ok" << std::endl;
13977 test_server.breq_close_wait_flag = false;
13978 test_server.bstop_flag = true;
13979 std::cout << "server_thread.join wait" << std::endl;
13980 server_thread.join();
13981 std::cout << "server_thread.join ok" << std::endl;
13984 BOOST_MESSAGE( "----- up_thread_run ssl mode test end -----" );
13987 // endpoint_to_string test
13988 // endpoint_to_string test class
13989 class endpoint_to_string_test_class : public l7vs::tcp_session{
13991 endpoint_to_string_test_class(
13992 l7vs::virtualservice_tcp& vs,
13993 boost::asio::io_service& session_io,
13994 l7vs::tcp_socket_option_info& set_socket_option,
13995 boost::asio::ip::tcp::endpoint listen_endpoint,
13997 boost::asio::ssl::context& set_ssl_context,
13998 bool set_ssl_cache_flag,
13999 int set_ssl_handshake_time_out,
14000 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
14006 set_ssl_cache_flag,
14007 set_ssl_handshake_time_out,
14008 set_access_logger){};
14009 ~endpoint_to_string_test_class(){};
14011 std::string test_call(boost::asio::ip::tcp::endpoint& test_endpoint){
14012 return endpoint_to_string(test_endpoint);
14016 void endpoint_to_string_test(){
14018 BOOST_MESSAGE( "----- endpoint_to_string test start -----" );
14020 boost::asio::io_service io;
14021 l7vs::virtualservice_tcp vs;
14022 l7vs::tcp_socket_option_info set_option;
14023 //! TCP_NODELAY (false:not set,true:set option)
14024 set_option.nodelay_opt = false;
14025 //! TCP_NODELAY option value (false:off,true:on)
14026 set_option.nodelay_val = false;
14027 //! TCP_CORK (false:not set,true:set option)
14028 set_option.cork_opt = false;
14029 //! TCP_CORK option value (false:off,true:on)
14030 set_option.cork_val = false;
14031 //! TCP_QUICKACK (false:not set,true:set option)
14032 set_option.quickack_opt = false;
14033 //! TCP_QUICKACK option value (false:off,true:on)
14034 set_option.quickack_val = false;
14036 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
14037 bool set_mode(true);
14038 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
14039 bool set_ssl_cache_flag(false);
14040 int set_ssl_handshake_time_out = 0;
14041 //std::string access_log_file_name = "test";
14042 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
14044 boost::system::error_code ec;
14046 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);
14048 // unit_test [1] endpoint_to_string test IPv4 Address case 1(192.168.0.1:8080) test
14049 std::cout << "[1] endpoint_to_string test IPv4 Address case 1(192.168.0.1:8080) test" << std::endl;
14051 boost::asio::ip::tcp::endpoint test_endpoint(boost::asio::ip::address::from_string("192.168.0.1"), 8080);
14052 std::string ref("192.168.0.1:8080");
14053 std::string test_string = test_obj.test_call(test_endpoint);
14054 BOOST_CHECK_EQUAL(ref,test_string);
14056 // unit_test [2] endpoint_to_string test IPv4 Address case 2(0.0.0.0:0) test
14057 std::cout << "[2] endpoint_to_string test IPv4 Address case 2(0.0.0.0:0) test" << std::endl;
14059 boost::asio::ip::tcp::endpoint test_endpoint(boost::asio::ip::address::from_string("0.0.0.0"), 0);
14060 std::string ref("0.0.0.0:0");
14061 std::string test_string = test_obj.test_call(test_endpoint);
14062 BOOST_CHECK_EQUAL(ref,test_string);
14064 // unit_test [3] endpoint_to_string test IPv4 Address case 3(255.255.255.255:65535) test
14065 std::cout << "[3] endpoint_to_string test IPv4 Address case 3(255.255.255.255:65535) test" << std::endl;
14066 { boost::asio::ip::tcp::endpoint test_endpoint(boost::asio::ip::address::from_string("255.255.255.255"), 65535);
14067 std::string ref("255.255.255.255:65535");
14068 std::string test_string = test_obj.test_call(test_endpoint);
14069 BOOST_CHECK_EQUAL(ref,test_string);
14071 // unit_test [4] endpoint_to_string test IPv6 Address case 1([2031:130f:876a::156a]:8080) test
14072 std::cout << "[4] endpoint_to_string test IPv6 Address case 1([2031:130f:876a::156a]:8080) test" << std::endl;
14074 boost::asio::ip::tcp::endpoint test_endpoint(boost::asio::ip::address::from_string("2031:130f:876a::156a"), 8080);
14075 std::string ref("[2031:130f:876a::156a]:8080");
14076 std::string test_string = test_obj.test_call(test_endpoint);
14077 BOOST_CHECK_EQUAL(ref,test_string);
14079 // unit_test [5] endpoint_to_string test IPv6 Address case 2([::]:0) test
14080 std::cout << "[5] endpoint_to_string test IPv6 Address case 2([::]:0) test" << std::endl;
14082 boost::asio::ip::tcp::endpoint test_endpoint(boost::asio::ip::address::from_string("::"), 0);
14083 std::string ref("[::]:0");
14084 std::string test_string = test_obj.test_call(test_endpoint);
14085 BOOST_CHECK_EQUAL(ref,test_string);
14087 // unit_test [6] endpoint_to_string test IPv6 Address case 3([ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]:65535) test
14088 std::cout << "[6] endpoint_to_string test IPv6 Address case 3([ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]:65535) test" << std::endl;
14090 boost::asio::ip::tcp::endpoint test_endpoint(boost::asio::ip::address::from_string("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"), 65535);
14091 std::string ref("[ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]:65535");
14092 std::string test_string = test_obj.test_call(test_endpoint);
14093 BOOST_CHECK_EQUAL(ref,test_string);
14095 // unit_test [7] endpoint_to_string test IPv6 Address case 4([fe80::2%<1st ifname>]:8080) test
14096 std::cout << "[7] endpoint_to_string test IPv6 Address case 4([fe80::2%<1st ifname>]:8080) test" << std::endl;
14098 boost::asio::ip::address_v6 v6addr(boost::asio::ip::address_v6::from_string("fe80::2"));
14099 v6addr.scope_id(1);
14100 boost::asio::ip::tcp::endpoint test_endpoint(v6addr, 8080);
14101 BOOST_CHECK( test_endpoint.address().to_v6().scope_id() == 1);
14102 BOOST_CHECK(test_endpoint.address().to_v6().is_link_local());
14103 char if_name[IF_NAMESIZE];
14104 memset(if_name,0,IF_NAMESIZE);
14105 if_indextoname(1,if_name);
14106 std::string set_if_name(if_name);
14107 std::string ref = "[fe80::2%" + set_if_name + "]:8080";
14108 std::string test_string = test_obj.test_call(test_endpoint);
14109 BOOST_CHECK_EQUAL(ref,test_string);
14111 // unit_test [8] endpoint_to_string test IPv6 Address case 5([::ffff:192.168.0.1]:8080) test
14112 std::cout << "[8] endpoint_to_string test IPv6 Address case 5([::ffff:192.168.0.1]:8080) test" << std::endl;
14114 boost::asio::ip::tcp::endpoint test_endpoint(boost::asio::ip::address::from_string("::ffff:192.168.0.1"), 8080);
14115 std::string ref("[::ffff:192.168.0.1]:8080");
14116 std::string test_string = test_obj.test_call(test_endpoint);
14117 BOOST_CHECK_EQUAL(ref,test_string);
14120 BOOST_MESSAGE( "----- endpoint_to_string test end -----" );
14126 test_suite* init_unit_test_suite( int argc, char* argv[] ){
14128 test_suite* ts = BOOST_TEST_SUITE( "l7vs::tcp_socket class test" );
14130 ts->add( BOOST_TEST_CASE( &constructer_test ) );
14131 ts->add( BOOST_TEST_CASE( &initialize_test ) );
14132 ts->add( BOOST_TEST_CASE( &initialize_ssl_mode_test ) );
14133 ts->add( BOOST_TEST_CASE( &ssl_clear_keep_cache_test ) );
14134 ts->add( BOOST_TEST_CASE( &get_client_socket_test) );
14135 ts->add( BOOST_TEST_CASE( &handle_ssl_handshake_timer_test) );
14136 // ts->add( BOOST_TEST_CASE( &is_thread_wait_test) );
14137 ts->add( BOOST_TEST_CASE( &set_virtual_service_message_test) );
14138 ts->add( BOOST_TEST_CASE( &endpoint_to_string_test ));
14140 ts->add( BOOST_TEST_CASE( &up_thread_run_test) );
14141 ts->add( BOOST_TEST_CASE( &up_thread_run_ssl_mode_test ) );
14142 ts->add( BOOST_TEST_CASE( &down_thread_run_test) );
14143 // ts->add( BOOST_TEST_CASE( &thread_state_update_test) );
14144 ts->add( BOOST_TEST_CASE( &up_thread_client_respond_test) );
14145 ts->add( BOOST_TEST_CASE( &up_thread_realserver_get_detination_event_test) );
14146 ts->add( BOOST_TEST_CASE( &up_thread_sorryserver_get_detination_event_test) );
14148 ts->add( BOOST_TEST_CASE( &up_thread_all_socket_close_test) );
14149 ts->add( BOOST_TEST_CASE( &down_thread_all_socket_close_test) );
14150 ts->add( BOOST_TEST_CASE( &up_thread_client_disconnect_test) );
14151 ts->add( BOOST_TEST_CASE( &down_thread_client_disconnect_test) );
14152 ts->add( BOOST_TEST_CASE( &up_thread_sorryserver_disconnect_test) );
14153 ts->add( BOOST_TEST_CASE( &down_thread_sorryserver_disconnect_test) );
14154 ts->add( BOOST_TEST_CASE( &up_thread_realserver_connect_event_test) );
14155 ts->add( BOOST_TEST_CASE( &up_thread_sorryserver_connect_event_test) );
14156 ts->add( BOOST_TEST_CASE( &down_thread_client_connection_chk_event_test) );
14157 ts->add( BOOST_TEST_CASE( &up_thread_realserver_connection_fail_event_test) );
14158 ts->add( BOOST_TEST_CASE( &up_thread_sorryserver_connection_fail_event_test) );
14160 ts->add( BOOST_TEST_CASE( &up_thread_client_accept_test ) );
14161 ts->add( BOOST_TEST_CASE( &up_thread_client_receive_test) );
14162 ts->add( BOOST_TEST_CASE( &down_thread_realserver_receive_test) );
14163 ts->add( BOOST_TEST_CASE( &down_thread_sorryserver_receive_test) );
14164 ts->add( BOOST_TEST_CASE( &up_thread_realserver_send_test) );
14165 ts->add( BOOST_TEST_CASE( &up_thread_sorryserver_send_test) );
14166 ts->add( BOOST_TEST_CASE( &down_thread_client_send_test) );
14167 ts->add( BOOST_TEST_CASE( &up_thread_realserver_connect_test) );
14168 ts->add( BOOST_TEST_CASE( &up_thread_realserver_connect_access_log_test) );
14169 ts->add( BOOST_TEST_CASE( &up_thread_sorryserver_connect_test) );
14170 ts->add( BOOST_TEST_CASE( &up_thread_realserver_disconnect_test) );
14171 ts->add( BOOST_TEST_CASE( &down_thread_realserver_disconnect_test) );
14172 ts->add( BOOST_TEST_CASE( &up_thread_all_realserver_disconnect_test) );
14173 ts->add( BOOST_TEST_CASE( &down_thread_all_realserver_disconnect_test) );
14175 ts->add( BOOST_TEST_CASE( &up_thread_exit_test ) );
14176 ts->add( BOOST_TEST_CASE( &down_thread_exit_test ) );
14177 ts->add( BOOST_TEST_CASE( &up_thread_client_disconnect_event_test ) );
14178 ts->add( BOOST_TEST_CASE( &down_thread_client_disconnect_event_test ) );
14179 ts->add( BOOST_TEST_CASE( &up_thread_realserver_disconnect_event_test ) );
14180 ts->add( BOOST_TEST_CASE( &down_thread_realserver_disconnect_event_test ) );
14181 ts->add( BOOST_TEST_CASE( &up_thread_sorryserver_disconnect_event_test ) );
14182 ts->add( BOOST_TEST_CASE( &down_thread_sorryserver_disconnect_event_test ) );
14183 ts->add( BOOST_TEST_CASE( &up_thread_sorryserver_mod_disconnect_test ) );
14184 ts->add( BOOST_TEST_CASE( &down_thread_sorryserver_mod_disconnect_test ) );
14186 ts->add( BOOST_TEST_CASE( &up_thread_sorry_enable_event_test ) );
14187 ts->add( BOOST_TEST_CASE( &up_thread_sorry_disable_event_test ) );
14188 ts->add( BOOST_TEST_CASE( &down_thread_sorry_enable_event_test ) );
14189 ts->add( BOOST_TEST_CASE( &down_thread_sorry_disable_event_test ) );
14190 ts->add( BOOST_TEST_CASE( &up_thread_client_accept_event_test ) );
14191 ts->add( BOOST_TEST_CASE( &up_thread_client_respond_event_test ) );
14192 ts->add( BOOST_TEST_CASE( &down_thread_client_respond_event_test ) );
14194 framework::master_test_suite().add( ts );