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);
108 //-------------is_thread_wait test---------------------------------
109 void set_is_thread_wait_test(){
110 pTest_mutex = &thread_state_update_mutex;
111 test_func = boost::bind(&mutex_lock_test::down_thread_exit,this);
114 void is_thread_wait(){
115 befor_thread_id = boost::this_thread::get_id();
116 l7vs::tcp_session::is_thread_wait();
117 after_thread_id = boost::this_thread::get_id();
120 //-------------down_thread_exit test---------------------------------
121 void set_down_thread_exit_test(){
122 pTest_mutex = &exit_flag_update_mutex;
123 test_func = boost::bind(&mutex_lock_test::down_thread_exit,this);
126 void down_thread_exit(){
127 befor_thread_id = boost::this_thread::get_id();
128 l7vs::tcp_session::down_thread_exit(l7vs::tcp_session::LOCAL_PROC);
129 after_thread_id = boost::this_thread::get_id();
132 //-------------up_thread_exit test---------------------------------
133 void set_up_thread_exit_test(){
134 pTest_mutex = &exit_flag_update_mutex;
135 test_func = boost::bind(&mutex_lock_test::up_thread_exit,this);
138 void up_thread_exit(){
139 befor_thread_id = boost::this_thread::get_id();
140 l7vs::tcp_session::up_thread_exit(l7vs::tcp_session::LOCAL_PROC);
141 after_thread_id = boost::this_thread::get_id();
144 //-------------up_thread_client_disconnetc_event test---------------------------------
145 void set_up_thread_client_disconnect_event_test(){
146 pTest_mutex = &module_function_client_disconnect_mutex;
147 test_func = boost::bind(&mutex_lock_test::up_thread_client_disconnect_event,this);
150 void up_thread_client_disconnect_event(){
151 befor_thread_id = boost::this_thread::get_id();
152 l7vs::tcp_session::up_thread_client_disconnect_event(l7vs::tcp_session::LOCAL_PROC);
153 after_thread_id = boost::this_thread::get_id();
156 //-------------down_thread_client_disconnetc_event test---------------------------------
157 void set_down_thread_client_disconnect_event_test(){
158 pTest_mutex = &module_function_client_disconnect_mutex;
159 test_func = boost::bind(&mutex_lock_test::down_thread_client_disconnect_event,this);
162 void down_thread_client_disconnect_event(){
163 befor_thread_id = boost::this_thread::get_id();
164 l7vs::tcp_session::down_thread_client_disconnect_event(l7vs::tcp_session::LOCAL_PROC);
165 after_thread_id = boost::this_thread::get_id();
168 //-------------up_thread_realserver_disconnetc_event test---------------------------------
169 void set_up_thread_realserver_disconnect_event_test(){
170 pTest_mutex = &module_function_realserver_disconnect_mutex;
171 test_func = boost::bind(&mutex_lock_test::up_thread_realserver_disconnect_event,this);
174 void up_thread_realserver_disconnect_event(){
175 befor_thread_id = boost::this_thread::get_id();
176 l7vs::tcp_session::up_thread_realserver_disconnect_event(l7vs::tcp_session::LOCAL_PROC);
177 after_thread_id = boost::this_thread::get_id();
180 //-------------down_thread_realserver_disconnetc_event test---------------------------------
181 void set_down_thread_realserver_disconnect_event_test(){
182 pTest_mutex = &module_function_realserver_disconnect_mutex;
183 test_func = boost::bind(&mutex_lock_test::down_thread_realserver_disconnect_event,this);
186 void down_thread_realserver_disconnect_event(){
187 befor_thread_id = boost::this_thread::get_id();
188 l7vs::tcp_session::down_thread_realserver_disconnect_event(l7vs::tcp_session::LOCAL_PROC);
189 after_thread_id = boost::this_thread::get_id();
192 //-------------up_thread_sorryserver_disconnetc_event test---------------------------------
193 void set_up_thread_sorryserver_disconnect_event_test(){
194 pTest_mutex = &module_function_sorryserver_disconnect_mutex;
195 test_func = boost::bind(&mutex_lock_test::up_thread_sorryserver_disconnect_event,this);
198 void up_thread_sorryserver_disconnect_event(){
199 befor_thread_id = boost::this_thread::get_id();
200 l7vs::tcp_session::up_thread_sorryserver_disconnect_event(l7vs::tcp_session::LOCAL_PROC);
201 after_thread_id = boost::this_thread::get_id();
204 //-------------down_thread_sorryserver_disconnetc_event test---------------------------------
205 void set_down_thread_sorryserver_disconnect_event_test(){
206 pTest_mutex = &module_function_sorryserver_disconnect_mutex;
207 test_func = boost::bind(&mutex_lock_test::down_thread_sorryserver_disconnect_event,this);
210 void down_thread_sorryserver_disconnect_event(){
211 befor_thread_id = boost::this_thread::get_id();
212 l7vs::tcp_session::down_thread_sorryserver_disconnect_event(l7vs::tcp_session::LOCAL_PROC);
213 after_thread_id = boost::this_thread::get_id();
216 //-------------up_thread_sorry_enable_event test---------------------------------
217 void set_up_thread_sorry_enable_event_test(){
218 pTest_mutex = &module_function_sorry_enable_mutex;
219 test_func = boost::bind(&mutex_lock_test::up_thread_sorry_enable_event,this);
222 void up_thread_sorry_enable_event(){
223 befor_thread_id = boost::this_thread::get_id();
224 l7vs::tcp_session::up_thread_sorry_enable_event(l7vs::tcp_session::LOCAL_PROC);
225 after_thread_id = boost::this_thread::get_id();
228 //-------------up_thread_sorry_disable_event test---------------------------------
229 void set_up_thread_sorry_disable_event_test(){
230 pTest_mutex = &module_function_sorry_disable_mutex;
231 test_func = boost::bind(&mutex_lock_test::up_thread_sorry_disable_event,this);
234 void up_thread_sorry_disable_event(){
235 befor_thread_id = boost::this_thread::get_id();
236 l7vs::tcp_session::up_thread_sorry_disable_event(l7vs::tcp_session::LOCAL_PROC);
237 after_thread_id = boost::this_thread::get_id();
239 //-------------down_thread_sorry_enable_event test---------------------------------
240 void set_down_thread_sorry_enable_event_test(){
241 pTest_mutex = &module_function_sorry_enable_mutex;
242 test_func = boost::bind(&mutex_lock_test::down_thread_sorry_enable_event,this);
245 void down_thread_sorry_enable_event(){
246 befor_thread_id = boost::this_thread::get_id();
247 l7vs::tcp_session::down_thread_sorry_enable_event(l7vs::tcp_session::LOCAL_PROC);
248 after_thread_id = boost::this_thread::get_id();
251 //-------------down_thread_sorry_disable_event test---------------------------------
252 void set_down_thread_sorry_disable_event_test(){
253 pTest_mutex = &module_function_sorry_disable_mutex;
254 test_func = boost::bind(&mutex_lock_test::down_thread_sorry_disable_event,this);
257 void down_thread_sorry_disable_event(){
258 befor_thread_id = boost::this_thread::get_id();
259 l7vs::tcp_session::down_thread_sorry_disable_event(l7vs::tcp_session::LOCAL_PROC);
260 after_thread_id = boost::this_thread::get_id();
263 //-------------up_thread_client_respond_event test---------------------------------
264 void set_up_thread_client_respond_event_test(){
265 pTest_mutex = &module_function_response_send_inform_mutex;
266 test_func = boost::bind(&mutex_lock_test::up_thread_client_respond_event,this);
269 void up_thread_client_respond_event(){
270 befor_thread_id = boost::this_thread::get_id();
271 l7vs::tcp_session::up_thread_client_respond_event(l7vs::tcp_session::LOCAL_PROC);
272 after_thread_id = boost::this_thread::get_id();
275 //-------------down_thread_client_respond_event test---------------------------------
276 void set_down_thread_client_respond_event_test(){
277 pTest_mutex = &module_function_response_send_inform_mutex;
278 test_func = boost::bind(&mutex_lock_test::down_thread_client_respond_event,this);
281 void down_thread_client_respond_event(){
282 befor_thread_id = boost::this_thread::get_id();
283 l7vs::tcp_session::down_thread_client_respond_event(l7vs::tcp_session::LOCAL_PROC);
284 after_thread_id = boost::this_thread::get_id();
287 //-------------thread_state_update test---------------------------------
288 void set_thread_state_update_test(){
289 pTest_mutex = &thread_state_update_mutex;
290 test_func = boost::bind(&mutex_lock_test::thread_state_update,this);
293 void thread_state_update(){
294 befor_thread_id = boost::this_thread::get_id();
295 l7vs::tcp_session::thread_state_update(UP_THREAD_ALIVE,true);
296 after_thread_id = boost::this_thread::get_id();
299 //-------------handle_ssl_handshake_timer test---------------------------------
300 void set_handle_ssl_handshake_timer_test(){
301 pTest_mutex = &ssl_handshake_time_out_flag_mutex;
302 test_func = boost::bind(&mutex_lock_test::handle_ssl_handshake_timer,this);
305 void handle_ssl_handshake_timer(){
306 befor_thread_id = boost::this_thread::get_id();
307 boost::system::error_code ec;
308 l7vs::tcp_session::handle_ssl_handshake_timer(ec);
309 after_thread_id = boost::this_thread::get_id();
313 // dummy mirror server
314 #define DUMMI_SERVER_IP "127.0.0.1"
315 #define DUMMI_SERVER_PORT 7000
316 class test_mirror_server{
322 bool breq_close_wait_flag;
324 bool bdisconnect_flag;
325 boost::asio::ip::tcp::endpoint accept_end;
326 boost::asio::ip::tcp::endpoint connect_end;
331 test_mirror_server() :
334 breq_acc_flag(false),
335 breq_close_wait_flag(false),
336 bconnect_flag(false),
337 bdisconnect_flag(false),
338 accept_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT),
339 connect_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT),
345 ~test_mirror_server(){
355 std::cout << "dummy mirror server run start!" << std::endl;
358 bconnect_flag = false;
359 bdisconnect_flag = false;
360 boost::asio::io_service io;
361 boost::asio::ip::tcp::acceptor acc(io,accept_end);
362 boost::system::error_code ec;
364 boost::array<char,MAX_BUFFER_SIZE> buf;
372 boost::asio::ip::tcp::socket con(io);
377 std::cout << "dummy mirror server accept NG!" << std::endl;
380 connect_end = con.remote_endpoint();
381 std::cout << "dummy mirror server accept OK! from " << connect_end << std::endl;
383 breq_acc_flag = false;
386 bconnect_flag = true;
388 for(int i = 0; i < req_recv_cnt ;i++){
389 while(!brecv_triger){
393 brecv_triger = false;
398 receive_size = con.read_some(boost::asio::buffer(buf,MAX_BUFFER_SIZE),ec);
401 if(ec == boost::asio::error::eof || ec == boost::asio::error::connection_reset){
402 std::cout << "dummy mirror server detect client disconnect!" << std::endl;
403 bdisconnect_flag = true;
405 std::cout << "dummy mirror server receive NG!" << std::endl;
408 if(receive_size > 0){
410 con.write_some(boost::asio::buffer(buf,receive_size),ec);
412 std::cout << "dummy mirror server send NG!" << std::endl;
418 std::cout << "dummy mirror server connection close wait start" << std::endl;
419 while(breq_close_wait_flag){
422 std::cout << "dummy mirror server connection close wait end" << std::endl;
432 std::cout << "dummy mirror server run end!" << std::endl;
436 // module event map test base class
437 class module_event_map_test_base_class : public l7vs::tcp_session{
440 std::pair<l7vs::protocol_module_base::EVENT_TAG, UP_THREAD_FUNC_TYPE_TAG> up_module_map_test_data[13];
441 std::pair<UP_THREAD_FUNC_TYPE_TAG , boost::function< void(const l7vs::tcp_session::TCP_PROCESS_TYPE_TAG) > > up_fuc_map_test_data[13];
442 std::pair<l7vs::protocol_module_base::EVENT_TAG, DOWN_THREAD_FUNC_TYPE_TAG> down_module_map_test_data[7];
443 std::pair<DOWN_THREAD_FUNC_TYPE_TAG , boost::function< void(const l7vs::tcp_session::TCP_PROCESS_TYPE_TAG) > > down_fuc_map_test_data[7];
445 // module_event_map_test_base_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){
446 module_event_map_test_base_class(
447 l7vs::virtualservice_tcp& vs,
448 boost::asio::io_service& session_io,
449 l7vs::tcp_socket_option_info& set_socket_option,
450 boost::asio::ip::tcp::endpoint listen_endpoint,
452 boost::asio::ssl::context& set_ssl_context,
453 bool set_ssl_cache_flag,
454 int set_ssl_handshake_time_out,
455 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
462 set_ssl_handshake_time_out,
466 boost::function< void(const l7vs::tcp_session::TCP_PROCESS_TYPE_TAG) > func;
469 up_thread_module_event_map.clear();
470 // up_thread_function_map.clear();
473 up_module_map_test_data[index].first = l7vs::protocol_module_base::ACCEPT;
474 up_module_map_test_data[index].second = l7vs::tcp_session::UP_FUNC_CLIENT_ACCEPT;
475 up_fuc_map_test_data[index].first = up_module_map_test_data[index].second;
476 up_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_UP_FUNC_CLIENT_ACCEPT,this,_1);
477 up_thread_function_array[up_fuc_map_test_data[index].first] = up_fuc_map_test_data[index];
480 up_module_map_test_data[index].first = l7vs::protocol_module_base::CLIENT_DISCONNECT;
481 up_module_map_test_data[index].second = l7vs::tcp_session::UP_FUNC_CLIENT_DISCONNECT;
482 up_fuc_map_test_data[index].first = up_module_map_test_data[index].second;
483 up_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_UP_FUNC_CLIENT_DISCONNECT,this,_1);
484 up_thread_function_array[up_fuc_map_test_data[index].first] = up_fuc_map_test_data[index];
487 up_module_map_test_data[index].first = l7vs::protocol_module_base::CLIENT_RECV;
488 up_module_map_test_data[index].second = l7vs::tcp_session::UP_FUNC_CLIENT_RECEIVE;
489 up_fuc_map_test_data[index].first = up_module_map_test_data[index].second;
490 up_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_UP_FUNC_CLIENT_RECEIVE,this,_1);
491 up_thread_function_array[up_fuc_map_test_data[index].first] = up_fuc_map_test_data[index];
494 up_module_map_test_data[index].first = l7vs::protocol_module_base::CLIENT_RESPONSE_SEND;
495 up_module_map_test_data[index].second = l7vs::tcp_session::UP_FUNC_CLIENT_RESPOND_SEND;
496 up_fuc_map_test_data[index].first = up_module_map_test_data[index].second;
497 up_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_UP_FUNC_CLIENT_RESPOND_SEND,this,_1);
498 up_thread_function_array[up_fuc_map_test_data[index].first] = up_fuc_map_test_data[index];
501 up_module_map_test_data[index].first = l7vs::protocol_module_base::REALSERVER_SELECT;
502 up_module_map_test_data[index].second = l7vs::tcp_session::UP_FUNC_REALSERVER_GET_DEST_EVENT;
503 up_fuc_map_test_data[index].first = up_module_map_test_data[index].second;
504 up_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_UP_FUNC_REALSERVER_GET_DEST_EVENT,this,_1);
505 up_thread_function_array[up_fuc_map_test_data[index].first] = up_fuc_map_test_data[index];
508 up_module_map_test_data[index].first = l7vs::protocol_module_base::REALSERVER_CONNECT;
509 up_module_map_test_data[index].second = l7vs::tcp_session::UP_FUNC_REALSERVER_CONNECT;
510 up_fuc_map_test_data[index].first = up_module_map_test_data[index].second;
511 up_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_UP_FUNC_REALSERVER_CONNECT,this,_1);
512 up_thread_function_array[up_fuc_map_test_data[index].first] = up_fuc_map_test_data[index];
515 up_module_map_test_data[index].first = l7vs::protocol_module_base::REALSERVER_SEND;
516 up_module_map_test_data[index].second = l7vs::tcp_session::UP_FUNC_REALSERVER_SEND;
517 up_fuc_map_test_data[index].first = up_module_map_test_data[index].second;
518 up_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_UP_FUNC_REALSERVER_SEND,this,_1);
519 up_thread_function_array[up_fuc_map_test_data[index].first] = up_fuc_map_test_data[index];
522 up_module_map_test_data[index].first = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
523 up_module_map_test_data[index].second = l7vs::tcp_session::UP_FUNC_REALSERVER_ALL_DISCONNECT;
524 up_fuc_map_test_data[index].first = up_module_map_test_data[index].second;
525 up_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_UP_FUNC_REALSERVER_ALL_DISCONNECT,this,_1);
526 up_thread_function_array[up_fuc_map_test_data[index].first] = up_fuc_map_test_data[index];
529 up_module_map_test_data[index].first = l7vs::protocol_module_base::SORRYSERVER_SELECT;
530 up_module_map_test_data[index].second = l7vs::tcp_session::UP_FUNC_SORRYSERVER_GET_DEST;
531 up_fuc_map_test_data[index].first = up_module_map_test_data[index].second;
532 up_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_UP_FUNC_SORRYSERVER_GET_DEST,this,_1);
533 up_thread_function_array[up_fuc_map_test_data[index].first] = up_fuc_map_test_data[index];
536 up_module_map_test_data[index].first = l7vs::protocol_module_base::SORRYSERVER_CONNECT;
537 up_module_map_test_data[index].second = l7vs::tcp_session::UP_FUNC_SORRYSERVER_CONNECT;
538 up_fuc_map_test_data[index].first = up_module_map_test_data[index].second;
539 up_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_UP_FUNC_SORRYSERVER_CONNECT,this,_1);
540 up_thread_function_array[up_fuc_map_test_data[index].first] = up_fuc_map_test_data[index];
543 up_module_map_test_data[index].first = l7vs::protocol_module_base::SORRYSERVER_SEND;
544 up_module_map_test_data[index].second = l7vs::tcp_session::UP_FUNC_SORRYSERVER_SEND;
545 up_fuc_map_test_data[index].first = up_module_map_test_data[index].second;
546 up_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_UP_FUNC_SORRYSERVER_SEND,this,_1);
547 up_thread_function_array[up_fuc_map_test_data[index].first] = up_fuc_map_test_data[index];
550 up_module_map_test_data[index].first = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
551 up_module_map_test_data[index].second = l7vs::tcp_session::UP_FUNC_SORRYSERVER_DISCONNECT;
552 up_fuc_map_test_data[index].first = up_module_map_test_data[index].second;
553 up_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_UP_FUNC_SORRYSERVER_DISCONNECT,this,_1);
554 up_thread_function_array[up_fuc_map_test_data[index].first] = up_fuc_map_test_data[index];
557 up_module_map_test_data[index].first = l7vs::protocol_module_base::FINALIZE;
558 up_module_map_test_data[index].second = l7vs::tcp_session::UP_FUNC_EXIT;
559 up_fuc_map_test_data[index].first = up_module_map_test_data[index].second;
560 up_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_UP_FUNC_EXIT,this,_1);
561 up_thread_function_array[up_fuc_map_test_data[index].first] = up_fuc_map_test_data[index];
563 for(int i = 0 ; i < 13;i++){
564 up_thread_module_event_map.insert(up_module_map_test_data[i]);
567 down_thread_module_event_map.clear();
568 // down_thread_function_map.clear();
571 down_module_map_test_data[index].first = l7vs::protocol_module_base::CLIENT_DISCONNECT;
572 down_module_map_test_data[index].second = l7vs::tcp_session::DOWN_FUNC_CLIENT_DISCONNECT;
573 down_fuc_map_test_data[index].first = down_module_map_test_data[index].second;
574 down_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_DOWN_FUNC_CLIENT_DISCONNECT,this,_1);
575 down_thread_function_array[down_fuc_map_test_data[index].first] = down_fuc_map_test_data[index];
578 down_module_map_test_data[index].first = l7vs::protocol_module_base::CLIENT_CONNECTION_CHECK;
579 down_module_map_test_data[index].second = l7vs::tcp_session::DOWN_FUNC_CLIENT_CONNECTION_CHK;
580 down_fuc_map_test_data[index].first = down_module_map_test_data[index].second;
581 down_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_DOWN_FUNC_CLIENT_CONNECTION_CHK,this,_1);
582 down_thread_function_array[down_fuc_map_test_data[index].first] = down_fuc_map_test_data[index];
585 down_module_map_test_data[index].first = l7vs::protocol_module_base::REALSERVER_RECV;
586 down_module_map_test_data[index].second = l7vs::tcp_session::DOWN_FUNC_REALSERVER_RECEIVE;
587 down_fuc_map_test_data[index].first = down_module_map_test_data[index].second;
588 down_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_DOWN_FUNC_REALSERVER_RECEIVE,this,_1);
589 down_thread_function_array[down_fuc_map_test_data[index].first] = down_fuc_map_test_data[index];
592 down_module_map_test_data[index].first = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
593 down_module_map_test_data[index].second = l7vs::tcp_session::DOWN_FUNC_REALSERVER_ALL_DISCONNECT;
594 down_fuc_map_test_data[index].first = down_module_map_test_data[index].second;
595 down_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_DOWN_FUNC_REALSERVER_ALL_DISCONNECT,this,_1);
596 down_thread_function_array[down_fuc_map_test_data[index].first] = down_fuc_map_test_data[index];
599 down_module_map_test_data[index].first = l7vs::protocol_module_base::SORRYSERVER_RECV;
600 down_module_map_test_data[index].second = l7vs::tcp_session::DOWN_FUNC_SORRYSERVER_RECEIVE;
601 down_fuc_map_test_data[index].first = down_module_map_test_data[index].second;
602 down_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_DOWN_FUNC_SORRYSERVER_RECEIVE,this,_1);
603 down_thread_function_array[down_fuc_map_test_data[index].first] = down_fuc_map_test_data[index];
606 down_module_map_test_data[index].first = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
607 down_module_map_test_data[index].second = l7vs::tcp_session::DOWN_FUNC_SORRYSERVER_DISCONNECT;
608 down_fuc_map_test_data[index].first = down_module_map_test_data[index].second;
609 down_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_DOWN_FUNC_SORRYSERVER_DISCONNECT,this,_1);
610 down_thread_function_array[down_fuc_map_test_data[index].first] = down_fuc_map_test_data[index];
613 down_module_map_test_data[index].first = l7vs::protocol_module_base::FINALIZE;
614 down_module_map_test_data[index].second = l7vs::tcp_session::DOWN_FUNC_EXIT;
615 down_fuc_map_test_data[index].first = down_module_map_test_data[index].second;
616 down_fuc_map_test_data[index].second = boost::bind(&module_event_map_test_base_class::test_DOWN_FUNC_EXIT,this,_1);
617 down_thread_function_array[down_fuc_map_test_data[index].first] = down_fuc_map_test_data[index];
619 for(int i = 0 ; i < 7;i++){
620 down_thread_module_event_map.insert(down_module_map_test_data[i]);
626 ~module_event_map_test_base_class(){
627 up_thread_module_event_map_clear();
628 up_thread_function_array_clear();
629 down_thread_module_event_map_clear();
630 down_thread_function_array_clear();
633 void set_protocol_module(l7vs::protocol_module_base* test_protocol_module){
634 protocol_module = test_protocol_module;
637 bool chk_up_thread_next_call_function(l7vs::protocol_module_base::EVENT_TAG chk_event){
638 l7vs::tcp_session::UP_THREAD_FUNC_TYPE_TAG fnc_tag = l7vs::tcp_session::UP_FUNC_EXIT;
639 up_call_func_type = fnc_tag;
640 for(int i = 0; i < 13;i++){
641 if( up_module_map_test_data[i].first == chk_event){
642 fnc_tag = up_module_map_test_data[i].second;
644 up_call_func_type = up_module_map_test_data[i+1].second;
646 up_call_func_type = up_module_map_test_data[0].second;
651 if(fnc_tag == up_call_func_type){
655 up_thread_next_call_function.second(LOCAL_PROC);
657 return fnc_tag == up_call_func_type;
660 bool chk_down_thread_next_call_function(l7vs::protocol_module_base::EVENT_TAG chk_event){
661 l7vs::tcp_session::DOWN_THREAD_FUNC_TYPE_TAG fnc_tag = l7vs::tcp_session::DOWN_FUNC_EXIT;
662 down_call_func_type = fnc_tag;
663 for(int i = 0; i < 7;i++){
664 if( down_module_map_test_data[i].first == chk_event){
665 fnc_tag = down_module_map_test_data[i].second;
667 down_call_func_type = down_module_map_test_data[i+1].second;
669 down_call_func_type = down_module_map_test_data[0].second;
674 if(fnc_tag == down_call_func_type){
678 down_thread_next_call_function.second(LOCAL_PROC);
680 return fnc_tag == down_call_func_type;
684 void up_thread_module_event_map_clear(){
685 up_thread_module_event_map.clear();
688 void up_thread_function_array_clear(){
689 for(int i = 0; i <= l7vs::tcp_session::UP_FUNC_EXIT;i++){
690 up_thread_function_array[i].second = (tcp_session_func)NULL;
694 void down_thread_module_event_map_clear(){
695 down_thread_module_event_map.clear();
698 void down_thread_function_array_clear(){
699 for(int i = 0; i <= l7vs::tcp_session::DOWN_FUNC_EXIT;i++){
700 down_thread_function_array[i].second = (tcp_session_func)NULL;
704 void set_up_thread_id(boost::thread::id set_thread_id){
705 up_thread_id = set_thread_id;
707 void set_down_thread_id(boost::thread::id set_thread_id){
708 down_thread_id = set_thread_id;
711 void set_up_thread_data_client_side(l7vs::tcp_data& set_data){
712 up_thread_data_client_side.set_size(set_data.get_size());
713 up_thread_data_client_side.set_send_size(set_data.get_send_size());
714 up_thread_data_client_side.set_data(set_data.get_data());
715 up_thread_data_client_side.set_endpoint(set_data.get_endpoint());
717 l7vs::tcp_data& get_up_thread_data_client_side(){
718 return up_thread_data_client_side;
720 void set_up_thread_data_dest_side(l7vs::tcp_data& set_data){
721 up_thread_data_dest_side.set_size(set_data.get_size());
722 up_thread_data_dest_side.set_send_size(set_data.get_send_size());
723 up_thread_data_dest_side.set_data(set_data.get_data());
724 up_thread_data_dest_side.set_endpoint(set_data.get_endpoint());
726 l7vs::tcp_data& get_up_thread_data_dest_side(){
727 return up_thread_data_dest_side;
729 void set_up_thread_message_data(l7vs::tcp_data& set_data){
730 up_thread_message_data.set_size(set_data.get_size());
731 up_thread_message_data.set_send_size(set_data.get_send_size());
732 up_thread_message_data.set_data(set_data.get_data());
733 up_thread_message_data.set_endpoint(set_data.get_endpoint());
735 l7vs::tcp_data& get_up_thread_message_data(){
736 return up_thread_message_data;
738 void set_down_thread_data_client_side(l7vs::tcp_data& set_data){
739 down_thread_data_client_side.set_size(set_data.get_size());
740 down_thread_data_client_side.set_send_size(set_data.get_send_size());
741 down_thread_data_client_side.set_data(set_data.get_data());
742 down_thread_data_client_side.set_endpoint(set_data.get_endpoint());
744 l7vs::tcp_data& get_down_thread_data_client_side(){
745 return down_thread_data_client_side;
747 void set_down_thread_data_dest_side(l7vs::tcp_data& set_data){
748 down_thread_data_dest_side.set_size(set_data.get_size());
749 down_thread_data_dest_side.set_send_size(set_data.get_send_size());
750 down_thread_data_dest_side.set_data(set_data.get_data());
751 down_thread_data_client_side.set_endpoint(set_data.get_endpoint());
753 l7vs::tcp_data& get_down_thread_data_dest_side(){
754 return down_thread_data_dest_side;
756 void set_down_thread_message_data(l7vs::tcp_data& set_data){
757 down_thread_message_data.set_size(set_data.get_size());
758 down_thread_message_data.set_send_size(set_data.get_send_size());
759 down_thread_message_data.set_data(set_data.get_data());
760 down_thread_message_data.set_endpoint(set_data.get_endpoint());
762 l7vs::tcp_data& get_down_thread_message_data(){
763 return down_thread_message_data;
765 void test_UP_FUNC_CLIENT_ACCEPT(const l7vs::tcp_session::TCP_PROCESS_TYPE_TAG process_type){
766 up_call_func_type = l7vs::tcp_session::UP_FUNC_CLIENT_ACCEPT;
769 void test_UP_FUNC_CLIENT_DISCONNECT(const l7vs::tcp_session::TCP_PROCESS_TYPE_TAG process_type){
770 up_call_func_type = l7vs::tcp_session::UP_FUNC_CLIENT_DISCONNECT;
773 void test_DOWN_FUNC_CLIENT_DISCONNECT(const l7vs::tcp_session::TCP_PROCESS_TYPE_TAG process_type){
774 down_call_func_type = l7vs::tcp_session::DOWN_FUNC_CLIENT_DISCONNECT;
777 void test_DOWN_FUNC_CLIENT_CONNECTION_CHK(const l7vs::tcp_session::TCP_PROCESS_TYPE_TAG process_type){
778 down_call_func_type = l7vs::tcp_session::DOWN_FUNC_CLIENT_CONNECTION_CHK;
782 // void test_UP_FUNC_CLIENT_DISCONNECT_EVENT(const l7vs::tcp_session::TCP_PROCESS_TYPE_TAG process_type){
783 // up_call_func_type = l7vs::tcp_session::UP_FUNC_CLIENT_DISCONNECT_EVENT;
786 void test_UP_FUNC_CLIENT_RECEIVE(const l7vs::tcp_session::TCP_PROCESS_TYPE_TAG process_type){
787 up_call_func_type = l7vs::tcp_session::UP_FUNC_CLIENT_RECEIVE;
790 void test_UP_FUNC_CLIENT_RESPOND_SEND(const l7vs::tcp_session::TCP_PROCESS_TYPE_TAG process_type){
791 up_call_func_type = l7vs::tcp_session::UP_FUNC_CLIENT_RESPOND_SEND;
794 // void test_UP_FUNC_CLIENT_RESPOND_SEND_EVENT(const TCP_PROCESS_TYPE_TAG process_type){
795 // up_call_func_type = l7vs::tcp_session::UP_FUNC_CLIENT_RESPOND_SEND_EVENT;
798 void test_DOWN_FUNC_REALSERVER_RECEIVE(const l7vs::tcp_session::TCP_PROCESS_TYPE_TAG process_type){
799 down_call_func_type = l7vs::tcp_session::DOWN_FUNC_REALSERVER_RECEIVE;
803 void test_UP_FUNC_REALSERVER_GET_DEST_EVENT(const TCP_PROCESS_TYPE_TAG process_type){
804 up_call_func_type = l7vs::tcp_session::UP_FUNC_REALSERVER_GET_DEST_EVENT;
807 void test_UP_FUNC_REALSERVER_CONNECT(const TCP_PROCESS_TYPE_TAG process_type){
808 up_call_func_type = l7vs::tcp_session::UP_FUNC_REALSERVER_CONNECT;
811 // void test_UP_FUNC_REALSERVER_CONNECT_EVENT(const TCP_PROCESS_TYPE_TAG process_type){
812 // up_call_func_type = l7vs::tcp_session::UP_FUNC_REALSERVER_CONNECT_EVENT;
815 // void test_UP_FUNC_REALSERVER_CONNECT_FAIL_EVENT(const TCP_PROCESS_TYPE_TAG process_type){
816 // up_call_func_type = l7vs::tcp_session::UP_FUNC_REALSERVER_CONNECT_FAIL_EVENT;
819 void test_UP_FUNC_REALSERVER_SEND(const TCP_PROCESS_TYPE_TAG process_type){
820 up_call_func_type = l7vs::tcp_session::UP_FUNC_REALSERVER_SEND;
823 // void test_UP_FUNC_REALSERVER_DISCONNECT(const TCP_PROCESS_TYPE_TAG process_type){
824 // up_call_func_type = l7vs::tcp_session::UP_FUNC_REALSERVER_DISCONNECT;
827 // void test_UP_FUNC_REALSERVER_DISCONNECT_EVENT(const TCP_PROCESS_TYPE_TAG process_type){
828 // up_call_func_type = l7vs::tcp_session::UP_FUNC_REALSERVER_DISCONNECT_EVENT;
831 void test_UP_FUNC_REALSERVER_ALL_DISCONNECT(const TCP_PROCESS_TYPE_TAG process_type){
832 up_call_func_type = l7vs::tcp_session::UP_FUNC_REALSERVER_ALL_DISCONNECT;
835 void test_DOWN_FUNC_REALSERVER_ALL_DISCONNECT(const TCP_PROCESS_TYPE_TAG process_type){
836 down_call_func_type = l7vs::tcp_session::DOWN_FUNC_REALSERVER_ALL_DISCONNECT;
839 void test_DOWN_FUNC_SORRYSERVER_RECEIVE(const l7vs::tcp_session::TCP_PROCESS_TYPE_TAG process_type){
840 down_call_func_type = l7vs::tcp_session::DOWN_FUNC_SORRYSERVER_RECEIVE;
843 void test_UP_FUNC_SORRYSERVER_GET_DEST(const TCP_PROCESS_TYPE_TAG process_type){
844 up_call_func_type = l7vs::tcp_session::UP_FUNC_SORRYSERVER_GET_DEST;
847 void test_UP_FUNC_SORRYSERVER_CONNECT(const TCP_PROCESS_TYPE_TAG process_type){
848 up_call_func_type = l7vs::tcp_session::UP_FUNC_SORRYSERVER_CONNECT;
851 // void test_UP_FUNC_SORRYSERVER_CONNECT_EVENT(const TCP_PROCESS_TYPE_TAG process_type){
852 // up_call_func_type = l7vs::tcp_session::UP_FUNC_SORRYSERVER_CONNECT_EVENT;
855 // void test_UP_FUNC_SORRYSERVER_CONNECT_FAIL_EVENT(const TCP_PROCESS_TYPE_TAG process_type){
856 // up_call_func_type = l7vs::tcp_session::UP_FUNC_SORRYSERVER_CONNECT_FAIL_EVENT;
859 void test_UP_FUNC_SORRYSERVER_SEND(const TCP_PROCESS_TYPE_TAG process_type){
860 up_call_func_type = l7vs::tcp_session::UP_FUNC_SORRYSERVER_SEND;
863 void test_UP_FUNC_SORRYSERVER_DISCONNECT(const TCP_PROCESS_TYPE_TAG process_type){
864 up_call_func_type = l7vs::tcp_session::UP_FUNC_SORRYSERVER_DISCONNECT;
867 void test_DOWN_FUNC_SORRYSERVER_DISCONNECT(const TCP_PROCESS_TYPE_TAG process_type){
868 down_call_func_type = l7vs::tcp_session::DOWN_FUNC_SORRYSERVER_DISCONNECT;
871 // void test_UP_FUNC_SORRYSERVER_DISCONNECT_EVENT(const TCP_PROCESS_TYPE_TAG process_type){
872 // up_call_func_type = l7vs::tcp_session::UP_FUNC_SORRYSERVER_DISCONNECT_EVENT;
875 // void test_UP_FUNC_SORRY_ENABLE_EVENT(const TCP_PROCESS_TYPE_TAG process_type){
876 // up_call_func_type = l7vs::tcp_session::UP_FUNC_SORRY_ENABLE_EVENT;
879 // void test_UP_FUNC_SORRY_DISABLE_EVENT(const TCP_PROCESS_TYPE_TAG process_type){
880 // up_call_func_type = l7vs::tcp_session::UP_FUNC_SORRY_DISABLE_EVENT;
883 void test_UP_FUNC_EXIT(const TCP_PROCESS_TYPE_TAG process_type){
884 up_call_func_type = l7vs::tcp_session::UP_FUNC_EXIT;
887 void test_DOWN_FUNC_EXIT(const TCP_PROCESS_TYPE_TAG process_type){
888 down_call_func_type = l7vs::tcp_session::DOWN_FUNC_EXIT;
891 l7vs::tcp_session::UP_THREAD_FUNC_TYPE_TAG up_call_func_type;
892 l7vs::tcp_session::DOWN_THREAD_FUNC_TYPE_TAG down_call_func_type;
899 // constructer test class
900 class constructer_test_class : public l7vs::tcp_session{
902 // constructer_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io,const l7vs::tcp_socket::tcp_socket_option_info set_option) : l7vs::tcp_session(vs,session_io,set_option){};
903 constructer_test_class(
904 l7vs::virtualservice_tcp& vs,
905 boost::asio::io_service& session_io,
906 l7vs::tcp_socket_option_info& set_socket_option,
907 boost::asio::ip::tcp::endpoint listen_endpoint,
909 boost::asio::ssl::context& set_ssl_context,
910 bool set_ssl_cache_flag,
911 int set_ssl_handshake_time_out,
912 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
919 set_ssl_handshake_time_out,
920 set_access_logger){};
921 ~constructer_test_class(){};
922 boost::asio::io_service& get_io(){
925 l7vs::virtualservice_tcp& get_parent_service(){
926 return parent_service;
928 bool get_exit_flag(){
931 std::bitset<TCP_SESSION_THREAD_STATE_BIT> get_thread_state(){
935 l7vs::protocol_module_base* get_protocol_module(){
936 return protocol_module;
938 bool get_session_pause_flag(){
939 return session_pause_flag;
941 l7vs::tcp_socket& get_client_socket(){
942 return client_socket;
944 boost::shared_ptr< l7vs::tcp_socket > get_sorry_socket(){
945 return sorryserver_socket.second;
948 l7vs::tcp_ssl_socket& get_client_ssl_socket(){
949 return client_ssl_socket;
952 l7vs::tcp_socket_option_info* get_socket_opt_info(){
953 return &socket_opt_info;
955 //! virtualservice accept endpoint
956 boost::asio::ip::tcp::endpoint& get_virtualservice_endpoint(){
957 return virtualservice_endpoint;
959 //! access log out put flag
960 bool get_accesslog_flag(){
961 return access_log_flag;
964 l7vs::logger_implement_access* get_access_logger(){
965 return access_logger;
972 boost::asio::ssl::context& get_ssl_context(){
975 //! ssl session cache flag
976 bool get_ssl_cache_flag(){
977 return ssl_cache_flag;
979 //! handshake timer flag
980 bool get_ssl_handshake_timer_flag(){
981 return ssl_handshake_timer_flag;
983 //! handshake timeout
984 int get_ssl_handshake_time_out(){
985 return ssl_handshake_time_out;
987 //! handshake timeout flag
988 bool get_ssl_handshake_timeout_flag(){
989 return ssl_handshake_time_out_flag;
992 //! up thread raise module event of handle_accept
993 //! @param[in] process_type is prosecess type
994 void up_thread_client_accept(const TCP_PROCESS_TYPE_TAG process_type){
995 up_thread_client_accept_call_check = true;
997 bool up_thread_client_accept_call_check;
999 //! up thread raise module event of handle_accept
1000 //! @param[in] process_type is prosecess type
1001 void up_thread_client_accept_event(const TCP_PROCESS_TYPE_TAG process_type){
1002 up_thread_client_accept_event_call_check = true;
1004 bool up_thread_client_accept_event_call_check;
1005 //! up thread receive client side and raise module event of handle_client_recv
1006 //! @param[in] process_type is prosecess type
1007 void up_thread_client_receive(const TCP_PROCESS_TYPE_TAG process_type){
1008 up_thread_client_receive_call_check = true;
1010 bool up_thread_client_receive_call_check;
1011 //! up thread raise client respond send event message for up and down thread
1012 //! @param[in] process_type is prosecess type
1013 void up_thread_client_respond(const TCP_PROCESS_TYPE_TAG process_type){
1014 up_thread_client_respond_call_check = true;
1016 bool up_thread_client_respond_call_check;
1017 //! up thread raise module event of handle_response_send_inform
1018 //! @param[in] process_type is prosecess type
1019 void up_thread_client_respond_event(const TCP_PROCESS_TYPE_TAG process_type){
1020 up_thread_client_respond_event_call_check = true;
1022 bool up_thread_client_respond_event_call_check;
1023 //! up thread close client socket and raise client disconnect event message for up and down thread
1024 //! @param[in] process_type is prosecess type
1025 void up_thread_client_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
1026 up_thread_client_disconnect_call_check = true;
1028 bool up_thread_client_disconnect_call_check;
1029 //! up thread raise module event of handle_client_disconnect
1030 //! @param[in] process_type is prosecess type
1031 void up_thread_client_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){
1032 up_thread_client_disconnect_event_call_check = true;
1034 bool up_thread_client_disconnect_event_call_check;
1035 //! up thread send realserver and raise module event of handle_client_recv
1036 //! @param[in] process_type is prosecess type
1037 void up_thread_realserver_send(const TCP_PROCESS_TYPE_TAG process_type){
1038 up_thread_realserver_send_call_check = true;
1040 bool up_thread_realserver_send_call_check;
1041 //! up thread raise module event of handle_realserver_select
1042 //! @param[in] process_type is prosecess type
1043 void up_thread_realserver_get_destination_event(const TCP_PROCESS_TYPE_TAG process_type){
1044 up_thread_realserver_get_destination_event_call_check = true;
1046 bool up_thread_realserver_get_destination_event_call_check;
1047 //! up thread connect realserver
1048 //! @param[in] process_type is prosecess type
1049 void up_thread_realserver_connect(const TCP_PROCESS_TYPE_TAG process_type){
1050 up_thread_realserver_connect_call_check = true;
1052 bool up_thread_realserver_connect_call_check;
1053 //! up thread raise module event of handle_realserver_connect
1054 //! @param[in] process_type is prosecess type
1055 void up_thread_realserver_connect_event(const TCP_PROCESS_TYPE_TAG process_type){
1056 up_thread_realserver_connect_event_call_check = true;
1058 bool up_thread_realserver_connect_event_call_check;
1059 //! up thread raise module event of handle_realserver_connection_fail
1060 //! @param[in] process_type is prosecess type
1061 void up_thread_realserver_connection_fail_event(const TCP_PROCESS_TYPE_TAG process_type){
1062 up_thread_realserver_connection_fail_event_call_check = true;
1064 bool up_thread_realserver_connection_fail_event_call_check;
1065 //! up thread close realserver socket and raise realserver disconnect event message for up and down thread
1066 //! @param[in] process_type is prosecess type
1067 void up_thread_realserver_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
1068 up_thread_realserver_disconnect_call_check = true;
1070 bool up_thread_realserver_disconnect_call_check;
1071 //! up thread raise module event of handle_realserver_disconnect
1072 //! @param[in] process_type is prosecess type
1073 void up_thread_realserver_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){
1074 up_thread_realserver_disconnect_event_call_check = true;
1076 bool up_thread_realserver_disconnect_event_call_check;
1077 //! up thread close all realserver socket and raise module event of handle_realserver_disconnect
1078 //! @param[in] process_type is prosecess type
1079 void up_thread_all_realserver_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
1080 up_thread_all_realserver_disconnect_call_check = true;
1082 bool up_thread_all_realserver_disconnect_call_check;
1083 //! up thread send sorryserver and raise module event of handle_sorryserver_send
1084 //! @param[in] process_type is prosecess type
1085 void up_thread_sorryserver_send(const TCP_PROCESS_TYPE_TAG process_type){
1086 up_thread_sorryserver_send_call_check = true;
1088 bool up_thread_sorryserver_send_call_check;
1089 //! up thread raise module event of handle_sorryserver_select
1090 //! @param[in] process_type is prosecess type
1091 void up_thread_sorryserver_get_destination_event(const TCP_PROCESS_TYPE_TAG process_type){
1092 up_thread_sorryserver_get_destination_event_call_check = true;
1094 bool up_thread_sorryserver_get_destination_event_call_check;
1095 //! up thread connect sorryserver
1096 //! @param[in] process_type is prosecess type
1097 void up_thread_sorryserver_connect(const TCP_PROCESS_TYPE_TAG process_type){
1098 up_thread_sorryserver_connect_call_check = true;
1100 bool up_thread_sorryserver_connect_call_check;
1101 //! up thread raise module event of handle_sorryserver_connect
1102 //! @param[in] process_type is prosecess type
1103 void up_thread_sorryserver_connect_event(const TCP_PROCESS_TYPE_TAG process_type){
1104 up_thread_sorryserver_connect_event_call_check = true;
1106 bool up_thread_sorryserver_connect_event_call_check;
1107 //! up thread raise module event of handle_sorryserver_connection_fail
1108 //! @param[in] process_type is prosecess type
1109 void up_thread_sorryserver_connection_fail_event(const TCP_PROCESS_TYPE_TAG process_type){
1110 up_thread_sorryserver_connection_fail_event_call_check = true;
1112 bool up_thread_sorryserver_connection_fail_event_call_check;
1113 //! up thread close sorryserver socket and raise sorryserver disconnect event message for up and down thread
1114 //! @param[in] process_type is prosecess type
1115 void up_thread_sorryserver_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
1116 up_thread_sorryserver_disconnect_call_check = true;
1118 bool up_thread_sorryserver_disconnect_call_check;
1120 void up_thread_sorryserver_mod_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
1121 up_thread_sorryserver_mod_disconnect_call_check = true;
1123 bool up_thread_sorryserver_mod_disconnect_call_check;
1125 //! up thread raise module event of handle_sorryserver_disconnect
1126 //! @param[in] process_type is prosecess type
1127 void up_thread_sorryserver_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){
1128 up_thread_sorryserver_disconnect_event_call_check = true;
1130 bool up_thread_sorryserver_disconnect_event_call_check;
1131 //! up thread raise module event of handle_sorry_enable
1132 //! @param[in] process_type is prosecess type
1133 void up_thread_sorry_enable_event(const TCP_PROCESS_TYPE_TAG process_type){
1134 up_thread_sorry_enable_event_call_check = true;
1136 bool up_thread_sorry_enable_event_call_check;
1137 //! up thread raise module event of handle_sorry_disable
1138 //! @param[in] process_type is prosecess type
1139 void up_thread_sorry_disable_event(const TCP_PROCESS_TYPE_TAG process_type){
1140 up_thread_sorry_disable_event_call_check = true;
1142 bool up_thread_sorry_disable_event_call_check;
1143 //! up thread exit main loop
1144 //! @param[in] process_type is prosecess type
1145 void up_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
1146 up_thread_exit_call_check = true;
1148 bool up_thread_exit_call_check;
1149 //! down thread receive from realserver and raise module event of handle_realserver_recv
1150 //! @param[in] process_type is prosecess type
1151 void down_thread_realserver_receive(const TCP_PROCESS_TYPE_TAG process_type){
1152 down_thread_realserver_receive_call_check = true;
1154 bool down_thread_realserver_receive_call_check;
1155 //! down thread close realserver socket and raise realserver disconnect event message for up and down thread
1156 //! @param[in] process_type is prosecess type
1157 void down_thread_realserver_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
1158 down_thread_realserver_disconnect_call_check = true;
1160 bool down_thread_realserver_disconnect_call_check;
1161 //! down thread raise module event of handle_realserver_disconnect
1162 //! @param[in] process_type is prosecess type
1163 void down_thread_realserver_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){
1164 down_thread_realserver_disconnect_event_call_check = true;
1166 bool down_thread_realserver_disconnect_event_call_check;
1167 //! down thread close all realserver socket and raise module event of handle_realserver_disconnect
1168 //! @param[in] process_type is prosecess type
1169 void down_thread_all_realserver_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
1170 down_thread_all_realserver_disconnect_call_check = true;
1172 bool down_thread_all_realserver_disconnect_call_check;
1173 //! down thread raise module event of handle_client_connection_check
1174 //! @param[in] process_type is prosecess type
1175 void down_thread_client_connection_chk_event(const TCP_PROCESS_TYPE_TAG process_type){
1176 down_thread_client_connection_chk_event_call_check = true;
1178 bool down_thread_client_connection_chk_event_call_check;
1179 //! down thread raise module event of handle_response_send_inform
1180 //! @param[in] process_type is prosecess type
1181 void down_thread_client_respond_event(const TCP_PROCESS_TYPE_TAG process_type){
1182 down_thread_client_respond_event_call_check = true;
1184 bool down_thread_client_respond_event_call_check;
1185 //! down thread send for client and raise module event of handle_client_send
1186 //! @param[in] process_type is prosecess type
1187 void down_thread_client_send(const TCP_PROCESS_TYPE_TAG process_type){
1188 down_thread_client_send_call_check = true;
1190 bool down_thread_client_send_call_check;
1191 //! down thread close client socket and raise client disconnect event message for up and down thread
1192 //! @param[in] process_type is prosecess type
1193 void down_thread_client_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
1194 down_thread_client_disconnect_call_check = true;
1196 bool down_thread_client_disconnect_call_check;
1197 //! down thread raise module event of handle_client_disconnect
1198 //! @param[in] process_type is prosecess type
1199 void down_thread_client_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){
1200 down_thread_client_disconnect_event_call_check = true;
1202 bool down_thread_client_disconnect_event_call_check;
1203 //! down thread receive from sorryserver and raise module event of handle_sorryserver_recv
1204 //! @param[in] process_type is prosecess type
1205 void down_thread_sorryserver_receive(const TCP_PROCESS_TYPE_TAG process_type){
1206 down_thread_sorryserver_receive_call_check = true;
1208 bool down_thread_sorryserver_receive_call_check;
1209 //! down thread close sorryserver socket and raise sorryserver disconnect event message for up and down thread
1210 //! @param[in] process_type is prosecess type
1211 void down_thread_sorryserver_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
1212 down_thread_sorryserver_disconnect_call_check = true;
1214 bool down_thread_sorryserver_disconnect_call_check;
1216 void down_thread_sorryserver_mod_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
1217 down_thread_sorryserver_mod_disconnect_call_check = true;
1219 bool down_thread_sorryserver_mod_disconnect_call_check;
1220 //! down thread raise module event of handle_sorryserver_disconnect
1221 //! @param[in] process_type is prosecess type
1222 void down_thread_sorryserver_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){
1223 down_thread_sorryserver_disconnect_event_call_check = true;
1225 bool down_thread_sorryserver_disconnect_event_call_check;
1226 //! down thread raise module event of handle_sorry_enable
1227 //! @param[in] process_type is prosecess type
1228 void down_thread_sorry_enable_event(const TCP_PROCESS_TYPE_TAG process_type){
1229 down_thread_sorry_enable_event_call_check = true;
1231 bool down_thread_sorry_enable_event_call_check;
1232 //! down thread raise module event of handle_sorry_disable
1233 //! @param[in] process_type is prosecess type
1234 void down_thread_sorry_disable_event(const TCP_PROCESS_TYPE_TAG process_type){
1235 down_thread_sorry_disable_event_call_check = true;
1237 bool down_thread_sorry_disable_event_call_check;
1238 //! down thread exit main loop
1239 //! @param[in] process_type is prosecess type
1240 void down_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
1241 down_thread_exit_call_check = true;
1243 bool down_thread_exit_call_check;
1247 void check_up_thread_module_event_map(){
1248 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::INITIALIZE) == up_thread_module_event_map.end());
1249 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::ACCEPT)->second == l7vs::tcp_session::UP_FUNC_CLIENT_ACCEPT);
1250 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::CLIENT_RECV)->second == l7vs::tcp_session::UP_FUNC_CLIENT_RECEIVE);
1251 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::REALSERVER_SELECT)->second == l7vs::tcp_session::UP_FUNC_REALSERVER_GET_DEST_EVENT);
1252 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::REALSERVER_CONNECT)->second == l7vs::tcp_session::UP_FUNC_REALSERVER_CONNECT);
1253 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::REALSERVER_SEND)->second == l7vs::tcp_session::UP_FUNC_REALSERVER_SEND);
1254 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::SORRYSERVER_SELECT)->second == l7vs::tcp_session::UP_FUNC_SORRYSERVER_GET_DEST);
1255 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::SORRYSERVER_CONNECT)->second == l7vs::tcp_session::UP_FUNC_SORRYSERVER_CONNECT);
1256 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::SORRYSERVER_SEND)->second == l7vs::tcp_session::UP_FUNC_SORRYSERVER_SEND);
1257 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::REALSERVER_RECV) == up_thread_module_event_map.end());
1258 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::SORRYSERVER_RECV) == up_thread_module_event_map.end());
1259 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::CLIENT_SELECT) == up_thread_module_event_map.end());
1260 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::CLIENT_CONNECTION_CHECK) == up_thread_module_event_map.end());
1261 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::CLIENT_SEND) == up_thread_module_event_map.end());
1262 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::CLIENT_RESPONSE_SEND)->second == l7vs::tcp_session::UP_FUNC_CLIENT_RESPOND_SEND);
1263 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::REALSERVER_DISCONNECT)->second == l7vs::tcp_session::UP_FUNC_REALSERVER_ALL_DISCONNECT);
1264 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::SORRYSERVER_DISCONNECT)->second == l7vs::tcp_session::UP_FUNC_SORRYSERVER_MOD_DISCONNECT);
1265 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::CLIENT_DISCONNECT)->second == l7vs::tcp_session::UP_FUNC_CLIENT_DISCONNECT);
1266 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::REALSERVER_CLOSE) == up_thread_module_event_map.end());
1267 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::FINALIZE)->second == l7vs::tcp_session::UP_FUNC_EXIT);
1268 BOOST_CHECK(up_thread_module_event_map.find(l7vs::protocol_module_base::STOP) == up_thread_module_event_map.end());
1270 void check_down_thread_module_event_map(){
1271 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::INITIALIZE) == down_thread_module_event_map.end());
1272 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::ACCEPT) == down_thread_module_event_map.end());
1273 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::CLIENT_RECV) == down_thread_module_event_map.end());
1274 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::REALSERVER_SELECT) == down_thread_module_event_map.end());
1275 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::REALSERVER_CONNECT) == down_thread_module_event_map.end());
1276 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::REALSERVER_SEND) == down_thread_module_event_map.end());
1277 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::SORRYSERVER_SELECT) == down_thread_module_event_map.end());
1278 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::SORRYSERVER_CONNECT) == down_thread_module_event_map.end());
1279 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::SORRYSERVER_SEND) == down_thread_module_event_map.end());
1280 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::REALSERVER_RECV)->second == l7vs::tcp_session::DOWN_FUNC_REALSERVER_RECEIVE);
1281 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::SORRYSERVER_RECV)->second == l7vs::tcp_session::DOWN_FUNC_SORRYSERVER_RECEIVE);
1282 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::CLIENT_SELECT) == down_thread_module_event_map.end());
1283 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::CLIENT_CONNECTION_CHECK)->second == l7vs::tcp_session::DOWN_FUNC_CLIENT_CONNECTION_CHK);
1284 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::CLIENT_SEND)->second == l7vs::tcp_session::DOWN_FUNC_CLIENT_SEND);
1285 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::CLIENT_RESPONSE_SEND) == down_thread_module_event_map.end());
1286 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::REALSERVER_DISCONNECT)->second == l7vs::tcp_session::DOWN_FUNC_REALSERVER_ALL_DISCONNECT);
1287 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::SORRYSERVER_DISCONNECT)->second == l7vs::tcp_session::DOWN_FUNC_SORRYSERVER_MOD_DISCONNECT);
1288 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::CLIENT_DISCONNECT)->second == l7vs::tcp_session::DOWN_FUNC_CLIENT_DISCONNECT);
1289 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::REALSERVER_CLOSE) == down_thread_module_event_map.end());
1290 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::FINALIZE)->second == l7vs::tcp_session::DOWN_FUNC_EXIT);
1291 BOOST_CHECK(down_thread_module_event_map.find(l7vs::protocol_module_base::STOP) == down_thread_module_event_map.end());
1294 void check_up_thread_function_map(){
1295 up_thread_function_pair check_it;
1297 // UP_FUNC_CLIENT_ACCEPT up_thread_client_accept function
1298 check_it = up_thread_function_array[UP_FUNC_CLIENT_ACCEPT];
1299 BOOST_CHECK(check_it.second != NULL);
1300 up_thread_client_accept_call_check = false;
1301 check_it.second(LOCAL_PROC);
1302 BOOST_CHECK(up_thread_client_accept_call_check);
1305 // UP_FUNC_CLIENT_ACCEPT_EVENT up_thread_client_accept_event function
1306 check_it = up_thread_function_array[UP_FUNC_CLIENT_ACCEPT_EVENT];
1307 BOOST_CHECK(check_it.second != NULL);
1308 up_thread_client_accept_event_call_check = false;
1309 check_it.second(LOCAL_PROC);
1310 BOOST_CHECK(up_thread_client_accept_event_call_check);
1312 // UP_FUNC_CLIENT_DISCONNECT up_thread_client_disconnect function
1313 check_it = up_thread_function_array[UP_FUNC_CLIENT_DISCONNECT];
1314 BOOST_CHECK(check_it.second != NULL);
1315 up_thread_client_disconnect_call_check = false;
1316 check_it.second(LOCAL_PROC);
1317 BOOST_CHECK(up_thread_client_disconnect_call_check);
1319 // UP_FUNC_CLIENT_DISCONNECT_EVENT up_thread_client_disconnect_event function
1320 check_it = up_thread_function_array[UP_FUNC_CLIENT_DISCONNECT_EVENT];
1321 BOOST_CHECK(check_it.second != NULL);
1322 up_thread_client_disconnect_event_call_check = false;
1323 check_it.second(LOCAL_PROC);
1324 BOOST_CHECK(up_thread_client_disconnect_event_call_check);
1326 // UP_FUNC_CLIENT_RECEIVE up_thread_client_receive function
1327 check_it = up_thread_function_array[UP_FUNC_CLIENT_RECEIVE];
1328 BOOST_CHECK(check_it.second != NULL);
1329 up_thread_client_receive_call_check = false;
1330 check_it.second(LOCAL_PROC);
1331 BOOST_CHECK(up_thread_client_receive_call_check);
1333 // UP_FUNC_CLIENT_RESPOND_SEND up_thread_client_respond function
1334 check_it = up_thread_function_array[UP_FUNC_CLIENT_RESPOND_SEND];
1335 BOOST_CHECK(check_it.second != NULL);
1336 up_thread_client_respond_call_check = false;
1337 check_it.second(LOCAL_PROC);
1338 BOOST_CHECK(up_thread_client_respond_call_check);
1340 // UP_FUNC_CLIENT_RESPOND_SEND_EVENT up_thread_client_respond_event function
1341 check_it = up_thread_function_array[UP_FUNC_CLIENT_RESPOND_SEND_EVENT];
1342 BOOST_CHECK(check_it.second != NULL);
1343 up_thread_client_respond_event_call_check = false;
1344 check_it.second(LOCAL_PROC);
1345 BOOST_CHECK(up_thread_client_respond_event_call_check);
1347 // UP_FUNC_REALSERVER_GET_DEST_EVENT up_thread_realserver_get_destination_event function
1348 check_it = up_thread_function_array[UP_FUNC_REALSERVER_GET_DEST_EVENT];
1349 BOOST_CHECK(check_it.second != NULL);
1350 up_thread_realserver_get_destination_event_call_check = false;
1351 check_it.second(LOCAL_PROC);
1352 BOOST_CHECK(up_thread_realserver_get_destination_event_call_check);
1354 // UP_FUNC_REALSERVER_CONNECT up_thread_realserver_connect function
1355 check_it = up_thread_function_array[UP_FUNC_REALSERVER_CONNECT];
1356 BOOST_CHECK(check_it.second != NULL);
1357 up_thread_realserver_connect_call_check = false;
1358 check_it.second(LOCAL_PROC);
1359 BOOST_CHECK(up_thread_realserver_connect_call_check);
1361 // UP_FUNC_REALSERVER_CONNECT_EVENT up_thread_realserver_connect_event function
1362 check_it = up_thread_function_array[UP_FUNC_REALSERVER_CONNECT_EVENT];
1363 BOOST_CHECK(check_it.second != NULL);
1364 up_thread_realserver_connect_event_call_check = false;
1365 check_it.second(LOCAL_PROC);
1366 BOOST_CHECK(up_thread_realserver_connect_event_call_check);
1368 // UP_FUNC_REALSERVER_CONNECT_FAIL_EVENT up_thread_realserver_connection_fail_event function
1369 check_it = up_thread_function_array[UP_FUNC_REALSERVER_CONNECT_FAIL_EVENT];
1370 BOOST_CHECK(check_it.second != NULL);
1371 up_thread_realserver_connection_fail_event_call_check = false;
1372 check_it.second(LOCAL_PROC);
1373 BOOST_CHECK(up_thread_realserver_connection_fail_event_call_check);
1375 // UP_FUNC_REALSERVER_SEND up_thread_realserver_send function
1376 check_it = up_thread_function_array[UP_FUNC_REALSERVER_SEND];
1377 BOOST_CHECK(check_it.second != NULL);
1378 up_thread_realserver_send_call_check = false;
1379 check_it.second(LOCAL_PROC);
1380 BOOST_CHECK(up_thread_realserver_send_call_check);
1382 // UP_FUNC_REALSERVER_DISCONNECT up_thread_realserver_disconnect function
1383 check_it = up_thread_function_array[UP_FUNC_REALSERVER_DISCONNECT];
1384 BOOST_CHECK(check_it.second != NULL);
1385 up_thread_realserver_disconnect_call_check = false;
1386 check_it.second(LOCAL_PROC);
1387 BOOST_CHECK(up_thread_realserver_disconnect_call_check);
1389 // UP_FUNC_REALSERVER_DISCONNECT_EVENT up_thread_realserver_disconnect_event function
1390 check_it = up_thread_function_array[UP_FUNC_REALSERVER_DISCONNECT_EVENT];
1391 BOOST_CHECK(check_it.second != NULL);
1392 up_thread_realserver_disconnect_event_call_check = false;
1393 check_it.second(LOCAL_PROC);
1394 BOOST_CHECK(up_thread_realserver_disconnect_event_call_check);
1396 // UP_FUNC_REALSERVER_ALL_DISCONNECT up_thread_all_realserver_disconnect function
1397 check_it = up_thread_function_array[UP_FUNC_REALSERVER_ALL_DISCONNECT];
1398 BOOST_CHECK(check_it.second != NULL);
1399 up_thread_all_realserver_disconnect_call_check = false;
1400 check_it.second(LOCAL_PROC);
1401 BOOST_CHECK(up_thread_all_realserver_disconnect_call_check);
1403 // UP_FUNC_SORRYSERVER_GET_DEST up_thread_sorryserver_get_destination_event function
1404 check_it = up_thread_function_array[UP_FUNC_SORRYSERVER_GET_DEST];
1405 BOOST_CHECK(check_it.second != NULL);
1406 up_thread_sorryserver_get_destination_event_call_check = false;
1407 check_it.second(LOCAL_PROC);
1408 BOOST_CHECK(up_thread_sorryserver_get_destination_event_call_check);
1410 // UP_FUNC_SORRYSERVER_CONNECT up_thread_sorryserver_connect function
1411 check_it = up_thread_function_array[UP_FUNC_SORRYSERVER_CONNECT];
1412 BOOST_CHECK(check_it.second != NULL);
1413 up_thread_sorryserver_connect_call_check = false;
1414 check_it.second(LOCAL_PROC);
1415 BOOST_CHECK(up_thread_sorryserver_connect_call_check);
1417 // UP_FUNC_SORRYSERVER_CONNECT_EVENT up_thread_sorryserver_connect_event function
1418 check_it = up_thread_function_array[UP_FUNC_SORRYSERVER_CONNECT_EVENT];
1419 BOOST_CHECK(check_it.second != NULL);
1420 up_thread_sorryserver_connect_event_call_check = false;
1421 check_it.second(LOCAL_PROC);
1422 BOOST_CHECK(up_thread_sorryserver_connect_event_call_check);
1424 // UP_FUNC_SORRYSERVER_CONNECT_FAIL_EVENT up_thread_sorryserver_connection_fail_event function
1425 check_it = up_thread_function_array[UP_FUNC_SORRYSERVER_CONNECT_FAIL_EVENT];
1426 BOOST_CHECK(check_it.second != NULL);
1427 up_thread_sorryserver_connection_fail_event_call_check = false;
1428 check_it.second(LOCAL_PROC);
1429 BOOST_CHECK(up_thread_sorryserver_connection_fail_event_call_check);
1431 // UP_FUNC_SORRYSERVER_SEND up_thread_sorryserver_send function
1432 check_it = up_thread_function_array[UP_FUNC_SORRYSERVER_SEND];
1433 BOOST_CHECK(check_it.second != NULL);
1434 up_thread_sorryserver_send_call_check = false;
1435 check_it.second(LOCAL_PROC);
1436 BOOST_CHECK(up_thread_sorryserver_send_call_check);
1438 // UP_FUNC_SORRYSERVER_DISCONNECT up_thread_sorryserver_disconnect function
1439 check_it = up_thread_function_array[UP_FUNC_SORRYSERVER_DISCONNECT];
1440 BOOST_CHECK(check_it.second != NULL);
1441 up_thread_sorryserver_disconnect_call_check = false;
1442 check_it.second(LOCAL_PROC);
1443 BOOST_CHECK(up_thread_sorryserver_disconnect_call_check);
1445 // UP_FUNC_SORRYSERVER_MOD_DISCONNECT up_thread_sorryserver_mod_disconnect function
1446 check_it = up_thread_function_array[UP_FUNC_SORRYSERVER_MOD_DISCONNECT];
1447 BOOST_CHECK(check_it.second != NULL);
1448 up_thread_sorryserver_mod_disconnect_call_check = false;
1449 check_it.second(LOCAL_PROC);
1450 BOOST_CHECK(up_thread_sorryserver_mod_disconnect_call_check);
1452 // UP_FUNC_SORRYSERVER_DISCONNECT_EVENT up_thread_sorryserver_disconnect_event function
1453 check_it = up_thread_function_array[UP_FUNC_SORRYSERVER_DISCONNECT_EVENT];
1454 BOOST_CHECK(check_it.second != NULL);
1455 up_thread_sorryserver_disconnect_event_call_check = false;
1456 check_it.second(LOCAL_PROC);
1457 BOOST_CHECK(up_thread_sorryserver_disconnect_event_call_check);
1459 // UP_FUNC_SORRY_ENABLE_EVENT up_thread_sorry_enable_event function
1460 check_it = up_thread_function_array[UP_FUNC_SORRY_ENABLE_EVENT];
1461 BOOST_CHECK(check_it.second == NULL);
1463 // UP_FUNC_SORRY_DISABLE_EVENT up_thread_sorry_disable_event function
1464 check_it = up_thread_function_array[UP_FUNC_SORRY_DISABLE_EVENT];
1465 BOOST_CHECK(check_it.second == NULL);
1467 // UP_FUNC_EXIT up_thread_exit function
1468 check_it = up_thread_function_array[UP_FUNC_EXIT];
1469 BOOST_CHECK(check_it.second != NULL);
1470 up_thread_exit_call_check = false;
1471 check_it.second(LOCAL_PROC);
1472 BOOST_CHECK(up_thread_exit_call_check);
1476 void check_down_thread_function_map(){
1477 down_thread_function_pair check_it;
1479 // DOWN_FUNC_CLIENT_DISCONNECT down_thread_client_disconnect function
1480 check_it = down_thread_function_array[DOWN_FUNC_CLIENT_DISCONNECT];
1481 BOOST_CHECK(check_it.second != NULL);
1482 down_thread_client_disconnect_call_check = false;
1483 check_it.second(LOCAL_PROC);
1484 BOOST_CHECK(down_thread_client_disconnect_call_check);
1486 // DOWN_FUNC_CLIENT_DISCONNECT_EVENT down_thread_client_disconnect_event function
1487 check_it = down_thread_function_array[DOWN_FUNC_CLIENT_DISCONNECT_EVENT];
1488 BOOST_CHECK(check_it.second != NULL);
1489 down_thread_client_disconnect_event_call_check = false;
1490 check_it.second(LOCAL_PROC);
1491 BOOST_CHECK(down_thread_client_disconnect_event_call_check);
1493 // DOWN_FUNC_CLIENT_CONNECTION_CHK down_thread_client_connection_chk_event function
1494 check_it = down_thread_function_array[DOWN_FUNC_CLIENT_CONNECTION_CHK];
1495 BOOST_CHECK(check_it.second != NULL);
1496 down_thread_client_connection_chk_event_call_check = false;
1497 check_it.second(LOCAL_PROC);
1498 BOOST_CHECK(down_thread_client_connection_chk_event_call_check);
1500 // DOWN_FUNC_CLIENT_SEND down_thread_client_send function
1501 check_it = down_thread_function_array[DOWN_FUNC_CLIENT_SEND];
1502 BOOST_CHECK(check_it.second != NULL);
1503 down_thread_client_send_call_check = false;
1504 check_it.second(LOCAL_PROC);
1505 BOOST_CHECK(down_thread_client_send_call_check);
1507 // DOWN_FUNC_CLIENT_RESPOND_SEND_EVENT down_thread_client_respond_event function
1508 check_it = down_thread_function_array[DOWN_FUNC_CLIENT_RESPOND_SEND_EVENT];
1509 BOOST_CHECK(check_it.second == NULL);
1511 // DOWN_FUNC_REALSERVER_RECEIVE down_thread_realserver_receive function
1512 check_it = down_thread_function_array[DOWN_FUNC_REALSERVER_RECEIVE];
1513 BOOST_CHECK(check_it.second != NULL);
1514 down_thread_realserver_receive_call_check = false;
1515 check_it.second(LOCAL_PROC);
1516 BOOST_CHECK(down_thread_realserver_receive_call_check);
1518 // DOWN_FUNC_REALSERVER_DISCONNECT down_thread_realserver_disconnect function
1519 check_it = down_thread_function_array[DOWN_FUNC_REALSERVER_DISCONNECT];
1520 BOOST_CHECK(check_it.second != NULL);
1521 down_thread_realserver_disconnect_call_check = false;
1522 check_it.second(LOCAL_PROC);
1523 BOOST_CHECK(down_thread_realserver_disconnect_call_check);
1525 // DOWN_FUNC_REALSERVER_DISCONNECT_EVENT down_thread_realserver_disconnect_event function
1526 check_it = down_thread_function_array[DOWN_FUNC_REALSERVER_DISCONNECT_EVENT];
1527 BOOST_CHECK(check_it.second != NULL);
1528 down_thread_realserver_disconnect_event_call_check = false;
1529 check_it.second(LOCAL_PROC);
1530 BOOST_CHECK(down_thread_realserver_disconnect_event_call_check);
1532 // DOWN_FUNC_REALSERVER_ALL_DISCONNECT down_thread_all_realserver_disconnect function
1533 check_it = down_thread_function_array[DOWN_FUNC_REALSERVER_ALL_DISCONNECT];
1534 BOOST_CHECK(check_it.second != NULL);
1535 down_thread_all_realserver_disconnect_call_check = false;
1536 check_it.second(LOCAL_PROC);
1537 BOOST_CHECK(down_thread_all_realserver_disconnect_call_check);
1539 // DOWN_FUNC_SORRYSERVER_RECEIVE down_thread_sorryserver_receive function
1540 check_it = down_thread_function_array[DOWN_FUNC_SORRYSERVER_RECEIVE];
1541 BOOST_CHECK(check_it.second != NULL);
1542 down_thread_sorryserver_receive_call_check = false;
1543 check_it.second(LOCAL_PROC);
1544 BOOST_CHECK(down_thread_sorryserver_receive_call_check);
1546 // DOWN_FUNC_SORRYSERVER_DISCONNECT down_thread_sorryserver_disconnect function
1547 check_it = down_thread_function_array[DOWN_FUNC_SORRYSERVER_DISCONNECT];
1548 BOOST_CHECK(check_it.second != NULL);
1549 down_thread_sorryserver_disconnect_call_check = false;
1550 check_it.second(LOCAL_PROC);
1551 BOOST_CHECK(down_thread_sorryserver_disconnect_call_check);
1553 // DOWN_FUNC_SORRYSERVER_MOD_DISCONNECT down_thread_sorryserver_mod_disconnect function
1554 check_it = down_thread_function_array[DOWN_FUNC_SORRYSERVER_MOD_DISCONNECT];
1555 BOOST_CHECK(check_it.second != NULL);
1556 down_thread_sorryserver_mod_disconnect_call_check = false;
1557 check_it.second(LOCAL_PROC);
1558 BOOST_CHECK(down_thread_sorryserver_mod_disconnect_call_check);
1560 // DOWN_FUNC_SORRYSERVER_DISCONNECT_EVENT down_thread_sorryserver_disconnect_event function
1561 check_it = down_thread_function_array[DOWN_FUNC_SORRYSERVER_DISCONNECT_EVENT];
1562 BOOST_CHECK(check_it.second != NULL);
1563 down_thread_sorryserver_disconnect_event_call_check = false;
1564 check_it.second(LOCAL_PROC);
1565 BOOST_CHECK(down_thread_sorryserver_disconnect_event_call_check);
1567 // DOWN_FUNC_SORRY_ENABLE_EVENT down_thread_sorry_enable_event function
1568 check_it = down_thread_function_array[DOWN_FUNC_SORRY_ENABLE_EVENT];
1569 BOOST_CHECK(check_it.second == NULL);
1571 // DOWN_FUNC_SORRY_DISABLE_EVENT down_thread_sorry_disable_event function
1572 check_it = down_thread_function_array[DOWN_FUNC_SORRY_DISABLE_EVENT];
1573 BOOST_CHECK(check_it.second == NULL);
1575 // DOWN_FUNC_EXIT down_thread_exit function
1576 check_it = down_thread_function_array[DOWN_FUNC_EXIT];
1577 BOOST_CHECK(check_it.second != NULL);
1578 down_thread_exit_call_check = false;
1579 check_it.second(LOCAL_PROC);
1580 BOOST_CHECK(down_thread_exit_call_check);
1584 void check_up_thread_message_down_thread_function_map(){
1585 std::map< DOWN_THREAD_FUNC_TYPE_TAG, tcp_session_func >::iterator check_it;
1587 // DOWN_FUNC_CLIENT_DISCONNECT down_thread_client_disconnect function
1588 check_it = up_thread_message_down_thread_function_map.find(DOWN_FUNC_CLIENT_DISCONNECT);
1589 BOOST_CHECK(check_it == up_thread_message_down_thread_function_map.end());
1591 // DOWN_FUNC_CLIENT_DISCONNECT_EVENT down_thread_client_disconnect_event function
1592 check_it = up_thread_message_down_thread_function_map.find(DOWN_FUNC_CLIENT_DISCONNECT_EVENT);
1593 BOOST_CHECK(check_it != up_thread_message_down_thread_function_map.end());
1594 down_thread_client_disconnect_event_call_check = false;
1595 check_it->second(LOCAL_PROC);
1596 BOOST_CHECK(down_thread_client_disconnect_event_call_check);
1598 // DOWN_FUNC_CLIENT_CONNECTION_CHK down_thread_client_connection_chk_event function
1599 check_it = up_thread_message_down_thread_function_map.find(DOWN_FUNC_CLIENT_CONNECTION_CHK);
1600 BOOST_CHECK(check_it == up_thread_message_down_thread_function_map.end());
1602 // DOWN_FUNC_CLIENT_SEND down_thread_client_send function
1603 check_it = up_thread_message_down_thread_function_map.find(DOWN_FUNC_CLIENT_SEND);
1604 BOOST_CHECK(check_it == up_thread_message_down_thread_function_map.end());
1606 // DOWN_FUNC_CLIENT_RESPOND_SEND_EVENT down_thread_client_respond_event function
1607 check_it = up_thread_message_down_thread_function_map.find(DOWN_FUNC_CLIENT_RESPOND_SEND_EVENT);
1608 BOOST_CHECK(check_it != up_thread_message_down_thread_function_map.end());
1609 down_thread_client_respond_event_call_check = false;
1610 check_it->second(LOCAL_PROC);
1611 BOOST_CHECK(down_thread_client_respond_event_call_check);
1613 // DOWN_FUNC_REALSERVER_RECEIVE down_thread_realserver_receive function
1614 check_it = up_thread_message_down_thread_function_map.find(DOWN_FUNC_REALSERVER_RECEIVE);
1615 BOOST_CHECK(check_it == up_thread_message_down_thread_function_map.end());
1617 // DOWN_FUNC_REALSERVER_DISCONNECT down_thread_realserver_disconnect function
1618 check_it = up_thread_message_down_thread_function_map.find(DOWN_FUNC_REALSERVER_DISCONNECT);
1619 BOOST_CHECK(check_it == up_thread_message_down_thread_function_map.end());
1621 // DOWN_FUNC_REALSERVER_DISCONNECT_EVENT down_thread_realserver_disconnect_event function
1622 check_it = up_thread_message_down_thread_function_map.find(DOWN_FUNC_REALSERVER_DISCONNECT_EVENT);
1623 BOOST_CHECK(check_it != up_thread_message_down_thread_function_map.end());
1624 down_thread_realserver_disconnect_event_call_check = false;
1625 check_it->second(LOCAL_PROC);
1626 BOOST_CHECK(down_thread_realserver_disconnect_event_call_check);
1628 // DOWN_FUNC_REALSERVER_ALL_DISCONNECT down_thread_all_realserver_disconnect function
1629 check_it = up_thread_message_down_thread_function_map.find(DOWN_FUNC_REALSERVER_ALL_DISCONNECT);
1630 BOOST_CHECK(check_it == up_thread_message_down_thread_function_map.end());
1632 // DOWN_FUNC_SORRYSERVER_RECEIVE down_thread_sorryserver_receive function
1633 check_it = up_thread_message_down_thread_function_map.find(DOWN_FUNC_SORRYSERVER_RECEIVE);
1634 BOOST_CHECK(check_it == up_thread_message_down_thread_function_map.end());
1636 // DOWN_FUNC_SORRYSERVER_DISCONNECT down_thread_sorryserver_disconnect function
1637 check_it = up_thread_message_down_thread_function_map.find(DOWN_FUNC_SORRYSERVER_DISCONNECT);
1638 BOOST_CHECK(check_it == up_thread_message_down_thread_function_map.end());
1640 // DOWN_FUNC_SORRYSERVER_DISCONNECT_EVENT down_thread_sorryserver_disconnect_event function
1641 check_it = up_thread_message_down_thread_function_map.find(DOWN_FUNC_SORRYSERVER_DISCONNECT_EVENT);
1642 BOOST_CHECK(check_it != up_thread_message_down_thread_function_map.end());
1643 down_thread_sorryserver_disconnect_event_call_check = false;
1644 check_it->second(LOCAL_PROC);
1645 BOOST_CHECK(down_thread_sorryserver_disconnect_event_call_check);
1647 // DOWN_FUNC_SORRY_ENABLE_EVENT down_thread_sorry_enable_event function
1648 check_it = up_thread_message_down_thread_function_map.find(DOWN_FUNC_SORRY_ENABLE_EVENT);
1649 BOOST_CHECK(check_it == up_thread_message_down_thread_function_map.end());
1651 // DOWN_FUNC_SORRY_DISABLE_EVENT down_thread_sorry_disable_event function
1652 check_it = up_thread_message_down_thread_function_map.find(DOWN_FUNC_SORRY_DISABLE_EVENT);
1653 BOOST_CHECK(check_it == up_thread_message_down_thread_function_map.end());
1655 // DOWN_FUNC_EXIT down_thread_exit function
1656 check_it = up_thread_message_down_thread_function_map.find(DOWN_FUNC_EXIT);
1657 BOOST_CHECK(check_it == up_thread_message_down_thread_function_map.end());
1660 void check_down_thread_message_up_thread_function_map(){
1661 std::map< UP_THREAD_FUNC_TYPE_TAG, tcp_session_func >::iterator check_it;
1663 // UP_FUNC_CLIENT_ACCEPT up_thread_client_accept_event function
1664 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_CLIENT_ACCEPT);
1665 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1667 // UP_FUNC_CLIENT_DISCONNECT up_thread_client_disconnect function
1668 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_CLIENT_DISCONNECT);
1669 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1671 // UP_FUNC_CLIENT_DISCONNECT_EVENT up_thread_client_disconnect_event function
1672 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_CLIENT_DISCONNECT_EVENT);
1673 BOOST_CHECK(check_it != down_thread_message_up_thread_function_map.end());
1674 up_thread_client_disconnect_event_call_check = false;
1675 check_it->second(LOCAL_PROC);
1676 BOOST_CHECK(up_thread_client_disconnect_event_call_check);
1678 // UP_FUNC_CLIENT_RECEIVE up_thread_client_receive function
1679 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_CLIENT_RECEIVE);
1680 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1682 // UP_FUNC_CLIENT_RESPOND_SEND up_thread_client_respond function
1683 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_CLIENT_RESPOND_SEND);
1684 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1686 // UP_FUNC_CLIENT_RESPOND_SEND_EVENT up_thread_client_respond_event function
1687 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_CLIENT_RESPOND_SEND_EVENT);
1688 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1690 // UP_FUNC_REALSERVER_GET_DEST_EVENT up_thread_realserver_get_distination_event function
1691 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_REALSERVER_GET_DEST_EVENT);
1692 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1694 // UP_FUNC_REALSERVER_CONNECT up_thread_realserver_connect function
1695 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_REALSERVER_CONNECT);
1696 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1698 // UP_FUNC_REALSERVER_CONNECT_EVENT _event function
1699 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_REALSERVER_CONNECT_EVENT);
1700 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1702 // UP_FUNC_REALSERVER_CONNECT_FAIL_EVENT up_thread_realserver_connection_fail_event function
1703 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_REALSERVER_CONNECT_FAIL_EVENT);
1704 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1706 // UP_FUNC_REALSERVER_SEND up_thread_realserver_send function
1707 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_REALSERVER_SEND);
1708 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1710 // UP_FUNC_REALSERVER_DISCONNECT up_thread_realserver_disconnect function
1711 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_REALSERVER_DISCONNECT);
1712 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1714 // UP_FUNC_REALSERVER_DISCONNECT_EVENT up_thread_realserver_disconnect_event function
1715 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_REALSERVER_DISCONNECT_EVENT);
1716 BOOST_CHECK(check_it != down_thread_message_up_thread_function_map.end());
1717 up_thread_realserver_disconnect_event_call_check = false;
1718 check_it->second(LOCAL_PROC);
1719 BOOST_CHECK(up_thread_realserver_disconnect_event_call_check);
1721 // UP_FUNC_REALSERVER_ALL_DISCONNECT up_thread_all_realserver_disconnect function
1722 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_REALSERVER_ALL_DISCONNECT);
1723 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1725 // UP_FUNC_SORRYSERVER_GET_DEST up_thread_sorryserver_get_destination_event function
1726 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_SORRYSERVER_GET_DEST);
1727 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1729 // UP_FUNC_SORRYSERVER_CONNECT up_thread_sorryserver_connect function
1730 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_SORRYSERVER_CONNECT);
1731 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1733 // UP_FUNC_SORRYSERVER_CONNECT_EVENT up_thread_sorryserver_connect_event function
1734 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_SORRYSERVER_CONNECT_EVENT);
1735 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1737 // UP_FUNC_SORRYSERVER_CONNECT_FAIL_EVENT up_thread_sorryserver_connection_fail_event function
1738 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_SORRYSERVER_CONNECT_FAIL_EVENT);
1739 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1741 // UP_FUNC_SORRYSERVER_SEND up_thread_sorryserver_send function
1742 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_SORRYSERVER_SEND);
1743 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1745 // UP_FUNC_SORRYSERVER_DISCONNECT up_thread_sorryserver_disconnect function
1746 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_SORRYSERVER_DISCONNECT);
1747 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1749 // UP_FUNC_SORRYSERVER_DISCONNECT_EVENT up_thread_sorryserver_disconnect_event function
1750 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_SORRYSERVER_DISCONNECT_EVENT);
1751 BOOST_CHECK(check_it != down_thread_message_up_thread_function_map.end());
1752 up_thread_sorryserver_disconnect_event_call_check = false;
1753 check_it->second(LOCAL_PROC);
1754 BOOST_CHECK(up_thread_sorryserver_disconnect_event_call_check);
1756 // UP_FUNC_SORRY_ENABLE_EVENT up_thread_sorry_enable_event function
1757 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_SORRY_ENABLE_EVENT);
1758 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1760 // UP_FUNC_SORRY_DISABLE_EVENT up_thread_sorry_disable_event function
1761 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_SORRY_DISABLE_EVENT);
1762 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1764 // UP_FUNC_EXIT up_thread_exit function
1765 check_it = down_thread_message_up_thread_function_map.find(UP_FUNC_EXIT);
1766 BOOST_CHECK(check_it == down_thread_message_up_thread_function_map.end());
1769 void check_virtual_service_message_up_thread_function_map(){
1770 std::map< TCP_VIRTUAL_SERVICE_MESSAGE_TAG, tcp_session_func >::iterator check_it;
1771 // SORRY_STATE_ENABLE up_thread_sorry_enable_event function
1772 check_it = virtual_service_message_up_thread_function_map.find(SORRY_STATE_ENABLE);
1773 BOOST_CHECK(check_it != virtual_service_message_up_thread_function_map.end());
1774 up_thread_sorry_enable_event_call_check = false;
1775 check_it->second(LOCAL_PROC);
1776 BOOST_CHECK(up_thread_sorry_enable_event_call_check);
1778 // SORRY_STATE_DISABLE up_thread_sorry_disable_event function
1779 check_it = virtual_service_message_up_thread_function_map.find(SORRY_STATE_DISABLE);
1780 BOOST_CHECK(check_it != virtual_service_message_up_thread_function_map.end());
1781 up_thread_sorry_disable_event_call_check = false;
1782 check_it->second(LOCAL_PROC);
1783 BOOST_CHECK(up_thread_sorry_disable_event_call_check);
1785 // SESSION_END up_thread_exit function
1786 check_it = virtual_service_message_up_thread_function_map.find(SESSION_END);
1787 BOOST_CHECK(check_it != virtual_service_message_up_thread_function_map.end());
1788 up_thread_exit_call_check = false;
1789 check_it->second(LOCAL_PROC);
1790 BOOST_CHECK(up_thread_exit_call_check);
1792 // SESSION_PAUSE_ON non function
1793 check_it = virtual_service_message_up_thread_function_map.find(SESSION_PAUSE_ON);
1794 BOOST_CHECK(check_it == virtual_service_message_up_thread_function_map.end());
1796 // SESSION_PAUSE_OFF non function
1797 check_it = virtual_service_message_up_thread_function_map.find(SESSION_PAUSE_OFF);
1798 BOOST_CHECK(check_it == virtual_service_message_up_thread_function_map.end());
1801 void check_virtual_service_message_down_thread_function_map(){
1802 std::map< TCP_VIRTUAL_SERVICE_MESSAGE_TAG, tcp_session_func >::iterator check_it;
1803 // SORRY_STATE_ENABLE down_thread_sorry_enable_event function
1804 check_it = virtual_service_message_down_thread_function_map.find(SORRY_STATE_ENABLE);
1805 BOOST_CHECK(check_it != virtual_service_message_down_thread_function_map.end());
1806 down_thread_sorry_enable_event_call_check = false;
1807 check_it->second(LOCAL_PROC);
1808 BOOST_CHECK(down_thread_sorry_enable_event_call_check);
1810 // SORRY_STATE_DISABLE down_thread_sorry_disable_event function
1811 check_it = virtual_service_message_down_thread_function_map.find(SORRY_STATE_DISABLE);
1812 BOOST_CHECK(check_it != virtual_service_message_down_thread_function_map.end());
1813 down_thread_sorry_disable_event_call_check = false;
1814 check_it->second(LOCAL_PROC);
1815 BOOST_CHECK(down_thread_sorry_disable_event_call_check);
1817 // SESSION_END down_thread_exit function
1818 check_it = virtual_service_message_down_thread_function_map.find(SESSION_END);
1819 BOOST_CHECK(check_it != virtual_service_message_down_thread_function_map.end());
1820 down_thread_exit_call_check = false;
1821 check_it->second(LOCAL_PROC);
1822 BOOST_CHECK(down_thread_exit_call_check);
1824 // SESSION_PAUSE_ON non function
1825 check_it = virtual_service_message_down_thread_function_map.find(SESSION_PAUSE_ON);
1826 BOOST_CHECK(check_it == virtual_service_message_down_thread_function_map.end());
1828 // SESSION_PAUSE_OFF non function
1829 check_it = virtual_service_message_down_thread_function_map.find(SESSION_PAUSE_OFF);
1830 BOOST_CHECK(check_it == virtual_service_message_down_thread_function_map.end());
1833 void constructer_test(){
1834 BOOST_MESSAGE( "----- constructer test start -----" );
1837 // constructer_test_class(
1838 // l7vs::virtualservice_tcp& vs,
1839 // boost::asio::io_service& session_io,
1840 // l7vs::tcp_socket_option_info& set_socket_option,
1841 // boost::asio::ip::tcp::endpoint listen_endpoint,
1843 // boost::asio::ssl::context& set_ssl_context,
1844 // bool set_ssl_cache_flag,
1845 // int set_ssl_handshake_time_out,
1846 // logger_implement_access* set_access_logger)
1848 l7vs::virtualservice_tcp vs;
1849 boost::asio::io_service io;
1850 l7vs::tcp_socket_option_info set_option;
1851 //! TCP_NODELAY (false:not set,true:set option)
1852 set_option.nodelay_opt = true;
1853 //! TCP_NODELAY option value (false:off,true:on)
1854 set_option.nodelay_val = true;
1855 //! TCP_CORK (false:not set,true:set option)
1856 set_option.cork_opt = true;
1857 //! TCP_CORK option value (false:off,true:on)
1858 set_option.cork_val = true;
1859 //! TCP_QUICKACK (false:not set,true:set option)
1860 set_option.quickack_opt = true;
1861 //! TCP_QUICKACK option value (false:off,true:on)
1862 set_option.quickack_val = true;
1864 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
1865 bool set_mode(true);
1866 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
1867 bool set_ssl_cache_flag(true);
1868 int set_ssl_handshake_time_out = 111;
1869 std::string access_log_file_name = "test";
1870 l7vs::logger_implement_access* plogger = new l7vs::logger_implement_access(access_log_file_name);
1872 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);
1874 // unit_test [1] constructer initialize member check
1875 std::cout << "[1] constructer initialize member check" << std::endl;
1876 BOOST_CHECK_EQUAL(&io , &test_obj.get_io());
1877 BOOST_CHECK_EQUAL(&vs,&test_obj.get_parent_service());
1878 BOOST_CHECK(!test_obj.get_exit_flag());
1879 std::bitset<TCP_SESSION_THREAD_STATE_BIT> ref;
1881 BOOST_CHECK_EQUAL(ref,test_obj.get_thread_state());
1882 BOOST_CHECK_EQUAL((void*)NULL,test_obj.get_protocol_module());
1883 BOOST_CHECK(!test_obj.get_session_pause_flag());
1884 BOOST_CHECK_EQUAL(&io , &(test_obj.get_client_socket().get_socket().get_io_service()));
1885 BOOST_CHECK_EQUAL(&io , &(test_obj.get_sorry_socket()->get_socket().get_io_service()));
1886 // unit_test [2] constructer set up_thread_module_event_map check
1887 std::cout << "[2] constructer set up_thread_module_event_map check" << std::endl;
1888 test_obj.check_up_thread_module_event_map();
1889 // unit_test [3] constructer set down_thread_module_event_map check
1890 std::cout << "[3] constructer set down_thread_module_event_map check" << std::endl;
1891 test_obj.check_down_thread_module_event_map();
1892 // unit_test [4] constructer set up_thread_function_map check
1893 std::cout << "[4] constructer set up_thread_function_map check" << std::endl;
1894 test_obj.check_up_thread_function_map();
1895 // unit_test [5] constructer set down_thread_function_map check
1896 std::cout << "[5] constructer set down_thread_function_map check" << std::endl;
1897 test_obj.check_down_thread_function_map();
1898 // unit_test [6] constructer set up_thread_message_down_thread_function_map check
1899 std::cout << "[6] constructer set up_thread_message_down_thread_function_map check" << std::endl;
1900 test_obj.check_up_thread_message_down_thread_function_map();
1901 // unit_test [7] constructer set down_thread_message_up_thread_function_map check
1902 std::cout << "[7] constructer set down_thread_message_up_thread_function_map check" << std::endl;
1903 test_obj.check_down_thread_message_up_thread_function_map();
1904 // unit_test [8] constructer set virtual_service_message_up_thread_function_map check
1905 std::cout << "[8] constructer set virtual_service_message_up_thread_function_map check" << std::endl;
1906 test_obj.check_virtual_service_message_up_thread_function_map();
1907 // unit_test [9] constructer set virtual_service_message_down_thread_function_map check
1908 std::cout << "[9] constructer set virtual_service_message_down_thread_function_map check" << std::endl;
1909 test_obj.check_virtual_service_message_down_thread_function_map();
1911 // unit_test [10] constructer set socket option check
1912 std::cout << "[10] constructer set socket option check" << std::endl;
1914 BOOST_CHECK_EQUAL(test_obj.get_socket_opt_info()->nodelay_opt , set_option.nodelay_opt);
1915 BOOST_CHECK_EQUAL(test_obj.get_socket_opt_info()->nodelay_val , set_option.nodelay_val);
1916 // unit_test [11] constructer set socket option check
1917 std::cout << "[11] constructer set socket option check" << std::endl;
1919 BOOST_CHECK_EQUAL(test_obj.get_socket_opt_info()->cork_opt , set_option.cork_opt);
1920 BOOST_CHECK_EQUAL(test_obj.get_socket_opt_info()->cork_val , set_option.cork_val);
1921 // unit_test [12] constructer set socket option check
1922 std::cout << "[12] constructer set socket option check" << std::endl;
1924 BOOST_CHECK_EQUAL(test_obj.get_socket_opt_info()->quickack_opt , set_option.quickack_opt);
1925 BOOST_CHECK_EQUAL(test_obj.get_socket_opt_info()->quickack_val , set_option.quickack_val);
1927 // unit_test [13] constructer client socket set socket option check
1928 std::cout << "[13] constructer client socket set socket option check" << std::endl;
1930 BOOST_CHECK_EQUAL(test_obj.get_client_socket().opt_info.nodelay_opt , set_option.nodelay_opt);
1931 BOOST_CHECK_EQUAL(test_obj.get_client_socket().opt_info.nodelay_val , set_option.nodelay_val);
1933 BOOST_CHECK_EQUAL(test_obj.get_client_socket().opt_info.cork_opt , set_option.cork_opt);
1934 BOOST_CHECK_EQUAL(test_obj.get_client_socket().opt_info.cork_val , set_option.cork_val);
1936 BOOST_CHECK_EQUAL(test_obj.get_client_socket().opt_info.quickack_opt , set_option.quickack_opt);
1937 BOOST_CHECK_EQUAL(test_obj.get_client_socket().opt_info.quickack_val , set_option.quickack_val);
1939 // unit_test [14] constructer sorry socket set socket option check
1940 std::cout << "[14] constructer sorry socket set socket option check" << std::endl;
1942 BOOST_CHECK_EQUAL(test_obj.get_sorry_socket()->opt_info.nodelay_opt , set_option.nodelay_opt);
1943 BOOST_CHECK_EQUAL(test_obj.get_sorry_socket()->opt_info.nodelay_val , set_option.nodelay_val);
1945 BOOST_CHECK_EQUAL(test_obj.get_sorry_socket()->opt_info.cork_opt , set_option.cork_opt);
1946 BOOST_CHECK_EQUAL(test_obj.get_sorry_socket()->opt_info.cork_val , set_option.cork_val);
1948 BOOST_CHECK_EQUAL(test_obj.get_sorry_socket()->opt_info.quickack_opt , set_option.quickack_opt);
1949 BOOST_CHECK_EQUAL(test_obj.get_sorry_socket()->opt_info.quickack_val , set_option.quickack_val);
1951 // unit_test [15] constructer client ssl socket set socket option check
1952 std::cout << "[15] constructer client ssl socket set socket option check" << std::endl;
1954 BOOST_CHECK_EQUAL(test_obj.get_client_ssl_socket().opt_info.nodelay_opt , set_option.nodelay_opt);
1955 BOOST_CHECK_EQUAL(test_obj.get_client_ssl_socket().opt_info.nodelay_val , set_option.nodelay_val);
1957 BOOST_CHECK_EQUAL(test_obj.get_client_ssl_socket().opt_info.cork_opt , set_option.cork_opt);
1958 BOOST_CHECK_EQUAL(test_obj.get_client_ssl_socket().opt_info.cork_val , set_option.cork_val);
1960 BOOST_CHECK_EQUAL(test_obj.get_client_ssl_socket().opt_info.quickack_opt , set_option.quickack_opt);
1961 BOOST_CHECK_EQUAL(test_obj.get_client_ssl_socket().opt_info.quickack_val , set_option.quickack_val);
1963 // unit_test [16] virtualservice_endpoint initialize check
1964 std::cout << "[16] virtualservice_endpoint initialize check" << std::endl;
1965 BOOST_CHECK_EQUAL(test_obj.get_virtualservice_endpoint() , listen_endpoint);
1967 // unit_test [17] accesslog_flag initialize check
1968 std::cout << "[17] accesslog_flag initialize check" << std::endl;
1969 BOOST_CHECK_EQUAL(test_obj.get_accesslog_flag() , false);
1971 // unit_test [18] access_loger initialize check
1972 std::cout << "[18] access_loger initialize check" << std::endl;
1973 BOOST_CHECK_EQUAL(test_obj.get_access_logger() , plogger);
1975 // unit_test [19] ssl_flag initialize check
1976 std::cout << "[18] ssl_flag initialize check" << std::endl;
1977 BOOST_CHECK_EQUAL(test_obj.get_ssl_flag() , set_mode);
1979 // unit_test [20] ssl_context initialize check
1980 std::cout << "[20] ssl_context initialize check" << std::endl;
1981 BOOST_CHECK_EQUAL(&(test_obj.get_ssl_context()) , &set_context);
1983 // unit_test [21] ssl_cache_flag initialize check
1984 std::cout << "[21] ssl_cache_flag initialize check" << std::endl;
1985 BOOST_CHECK_EQUAL(test_obj.get_ssl_cache_flag() , set_ssl_cache_flag);
1987 // unit_test [22] ssl_handshake_timer_flag initialize check
1988 std::cout << "[21] ssl_handshake_timer_flag initialize check" << std::endl;
1989 BOOST_CHECK_EQUAL(test_obj.get_ssl_handshake_timer_flag() , false);
1991 // unit_test [23] ssl_handshake_time_out initialize check
1992 std::cout << "[23] ssl_handshake_time_out initialize check" << std::endl;
1993 BOOST_CHECK_EQUAL(test_obj.get_ssl_handshake_time_out() , set_ssl_handshake_time_out);
1995 // unit_test [23] ssl_handshake_timeout_flag initialize check
1996 std::cout << "[23] ssl_handshake_timeout_flag initialize check" << std::endl;
1997 BOOST_CHECK_EQUAL(test_obj.get_ssl_handshake_timeout_flag() , false);
2002 BOOST_MESSAGE( "----- constructer test end -----" );
2006 // initialize test class
2007 class initialize_test_class : public l7vs::tcp_session{
2009 // initialize_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){};
2010 initialize_test_class(
2011 l7vs::virtualservice_tcp& vs,
2012 boost::asio::io_service& session_io,
2013 l7vs::tcp_socket_option_info& set_socket_option,
2014 boost::asio::ip::tcp::endpoint listen_endpoint,
2016 boost::asio::ssl::context& set_ssl_context,
2017 bool set_ssl_cache_flag,
2018 int set_ssl_handshake_time_out,
2019 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
2026 set_ssl_handshake_time_out,
2027 set_access_logger){};
2030 ~initialize_test_class(){};
2031 bool& get_exit_flag(){
2034 boost::thread::id& get_up_thread_id(){
2035 return up_thread_id;
2037 boost::thread::id& get_down_thread_id(){
2038 return down_thread_id;
2040 std::bitset<TCP_SESSION_THREAD_STATE_BIT>& get_thread_state(){
2041 return thread_state;
2044 l7vs::protocol_module_base* get_protocol_module(){
2045 return protocol_module;
2047 bool& get_session_pause_flag(){
2048 return session_pause_flag;
2050 l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_up_thread_message_que(){
2051 return up_thread_message_que;
2053 l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_down_thread_message_que(){
2054 return down_thread_message_que;
2057 int get_upstream_buffer_size(){
2058 return upstream_buffer_size;
2061 int get_downstream_buffer_size(){
2062 return downstream_buffer_size;
2066 void initialize_test(){
2067 BOOST_MESSAGE( "----- initialize test start -----" );
2069 // boost::asio::io_service io;
2070 // l7vs::virtualservice_tcp vs;
2071 // initialize_test_class test_obj(vs,io);
2072 l7vs::virtualservice_tcp vs;
2073 boost::asio::io_service io;
2074 l7vs::tcp_socket_option_info set_option;
2075 //! TCP_NODELAY (false:not set,true:set option)
2076 set_option.nodelay_opt = false;
2077 //! TCP_NODELAY option value (false:off,true:on)
2078 set_option.nodelay_val = false;
2079 //! TCP_CORK (false:not set,true:set option)
2080 set_option.cork_opt = false;
2081 //! TCP_CORK option value (false:off,true:on)
2082 set_option.cork_val = false;
2083 //! TCP_QUICKACK (false:not set,true:set option)
2084 set_option.quickack_opt = false;
2085 //! TCP_QUICKACK option value (false:off,true:on)
2086 set_option.quickack_val = false;
2088 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
2089 bool set_mode(false);
2090 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
2091 bool set_ssl_cache_flag(false);
2092 int set_ssl_handshake_time_out = 0;
2093 //std::string access_log_file_name = "test";
2094 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
2096 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);
2099 std::string test_protocol_name("test protocol");
2100 l7vs::test_protocol_module proto_test(test_protocol_name);
2101 vs.get_protocol_module_res = &proto_test;
2103 test_obj.get_exit_flag() = true;
2104 test_obj.get_up_thread_id() = boost::this_thread::get_id();
2105 test_obj.get_down_thread_id() = boost::this_thread::get_id();
2106 test_obj.get_thread_state().set();
2107 BOOST_CHECK(test_obj.get_protocol_module() != &proto_test);
2108 test_obj.get_session_pause_flag() = true;
2109 l7vs::tcp_thread_message* test_msg_up = new l7vs::tcp_thread_message;
2110 l7vs::tcp_thread_message* test_msg_dw = new l7vs::tcp_thread_message;
2111 test_obj.get_up_thread_message_que().push(test_msg_up);
2112 BOOST_CHECK(!test_obj.get_up_thread_message_que().empty());
2113 test_obj.get_down_thread_message_que().push(test_msg_dw);
2114 BOOST_CHECK(!test_obj.get_down_thread_message_que().empty());
2116 l7vs::session_result_message res_msg = test_obj.initialize();
2118 // unit_test [1] initialize exit flag check
2119 std::cout << "[1] initialize exit flag check" << std::endl;
2120 BOOST_CHECK(!test_obj.get_exit_flag());
2122 // unit_test [2] initialize up thread id check
2123 std::cout << "[2] initialize up thread id check" << std::endl;
2124 BOOST_CHECK(test_obj.get_up_thread_id() == boost::thread::id());
2126 // unit_test [3] initialize down thread id check
2127 std::cout << "[3] initialize down thread id check" << std::endl;
2128 BOOST_CHECK(test_obj.get_down_thread_id() == boost::thread::id());
2130 // unit_test [4] initialize thread state check
2131 std::cout << "[4] initialize thread state check" << std::endl;
2132 BOOST_CHECK(test_obj.get_thread_state().none());
2134 // unit_test [5] initialize session pause flag check
2135 std::cout << "[5] initialize session pause flag check" << std::endl;
2136 BOOST_CHECK(!test_obj.get_session_pause_flag());
2138 // unit_test [6] initialize up thread message que check
2139 std::cout << "[6] initialize up thread message que check" << std::endl;
2140 BOOST_CHECK(test_obj.get_up_thread_message_que().empty());
2143 // unit_test [7] initialize down thread message que check
2144 std::cout << "[7] initialize down thread message que check" << std::endl;
2145 BOOST_CHECK(test_obj.get_down_thread_message_que().empty());
2148 // unit_test [8] initialize get protocol module pointer check
2149 std::cout << "[8] initialize get protocol module pointer check" << std::endl;
2150 BOOST_CHECK(test_obj.get_protocol_module() == &proto_test);
2152 // unit_test [9] initialize session_result_message flag check
2153 std::cout << "[9] initialize session_result_message flag check" << std::endl;
2154 BOOST_CHECK(!res_msg.flag);
2156 // unit_test [10] initialize upstream_buffer_size load cf check
2157 std::cout << "[10] initialize upstream_buffer_size load cf check" << std::endl;
2158 BOOST_CHECK_EQUAL(test_obj.get_upstream_buffer_size() , 7777);
2160 // unit_test [11] initialize downstream_buffer_size load cf check
2161 std::cout << "[11] initialize downstream_buffer_size load cf check" << std::endl;
2162 BOOST_CHECK_EQUAL(test_obj.get_downstream_buffer_size() , 8888);
2164 // unit_test [12] initialize protocol_module NULL error check
2165 std::cout << "[12] initialize protocol_module NULL error check" << std::endl;
2166 vs.get_protocol_module_res = NULL;
2167 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
2168 l7vs::Logger::putLogError_id = 0;
2169 res_msg = test_obj.initialize();
2170 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
2171 BOOST_CHECK_EQUAL(5,l7vs::Logger::putLogError_id);
2172 std::cout << l7vs::Logger::putLogError_message << std::endl;
2173 BOOST_CHECK(res_msg.flag);
2174 std::cout << res_msg.message << std::endl;
2176 BOOST_MESSAGE( "----- initialize test end -----" );
2180 // get_client_socket test
2181 // get_client_socket test class
2182 class get_client_socket_test_class : public l7vs::tcp_session{
2184 // get_client_socket_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){};
2185 get_client_socket_test_class(
2186 l7vs::virtualservice_tcp& vs,
2187 boost::asio::io_service& session_io,
2188 l7vs::tcp_socket_option_info& set_socket_option,
2189 boost::asio::ip::tcp::endpoint listen_endpoint,
2191 boost::asio::ssl::context& set_ssl_context,
2192 bool set_ssl_cache_flag,
2193 int set_ssl_handshake_time_out,
2194 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
2201 set_ssl_handshake_time_out,
2202 set_access_logger){};
2206 ~get_client_socket_test_class(){};
2207 l7vs::tcp_socket& get_client_tcp_socket(){
2208 return client_socket;
2210 l7vs::tcp_ssl_socket& get_client_ssl_tcp_socket(){
2211 return client_ssl_socket;
2216 void get_client_socket_test(){
2217 BOOST_MESSAGE( "----- get_client_socket test start -----" );
2221 // boost::asio::io_service io;
2222 // l7vs::virtualservice_tcp vs;
2223 // get_client_socket_test_class test_obj(vs,io);
2224 l7vs::virtualservice_tcp vs;
2225 boost::asio::io_service io;
2226 l7vs::tcp_socket_option_info set_option;
2227 //! TCP_NODELAY (false:not set,true:set option)
2228 set_option.nodelay_opt = false;
2229 //! TCP_NODELAY option value (false:off,true:on)
2230 set_option.nodelay_val = false;
2231 //! TCP_CORK (false:not set,true:set option)
2232 set_option.cork_opt = false;
2233 //! TCP_CORK option value (false:off,true:on)
2234 set_option.cork_val = false;
2235 //! TCP_QUICKACK (false:not set,true:set option)
2236 set_option.quickack_opt = false;
2237 //! TCP_QUICKACK option value (false:off,true:on)
2238 set_option.quickack_val = false;
2240 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
2241 bool set_mode(false);
2242 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
2243 bool set_ssl_cache_flag(false);
2244 int set_ssl_handshake_time_out = 0;
2245 //std::string access_log_file_name = "test";
2246 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
2248 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);
2251 l7vs::tcp_socket& ref_tcp_socket = test_obj.get_client_tcp_socket();
2252 boost::asio::ip::tcp::socket& ref_socket = ref_tcp_socket.my_socket;
2253 boost::asio::ip::tcp::socket& chk_socket = test_obj.get_client_socket();
2255 // unit_test [1] get_client_socket check
2256 std::cout << "[1] get_client_socket check" << std::endl;
2257 BOOST_CHECK_EQUAL(&ref_socket,&chk_socket);
2260 l7vs::tcp_ssl_socket& ref_tcp_ssl_socket = test_obj.get_client_ssl_tcp_socket();
2261 ssl_socket& ref_ssl_socket = ref_tcp_ssl_socket.get_socket();
2262 ssl_socket& chk_ssl_socket = test_obj.get_client_ssl_socket();
2264 // unit_test [2] get_client_ssl_socket check
2265 std::cout << "[2] get_client_ssl_socket check" << std::endl;
2266 BOOST_CHECK_EQUAL(&ref_ssl_socket,&chk_ssl_socket);
2268 BOOST_MESSAGE( "----- get_client_socket test end -----" );
2272 // handle_ssl_handshake_timer test
2273 // handle_ssl_handshake_timer test class
2274 class handle_ssl_handshake_timer_test_class : public l7vs::tcp_session{
2276 // handle_ssl_handshake_timer_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){};
2277 handle_ssl_handshake_timer_test_class(
2278 l7vs::virtualservice_tcp& vs,
2279 boost::asio::io_service& session_io,
2280 l7vs::tcp_socket_option_info& set_socket_option,
2281 boost::asio::ip::tcp::endpoint listen_endpoint,
2283 boost::asio::ssl::context& set_ssl_context,
2284 bool set_ssl_cache_flag,
2285 int set_ssl_handshake_time_out,
2286 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
2293 set_ssl_handshake_time_out,
2294 set_access_logger){};
2296 ~handle_ssl_handshake_timer_test_class(){};
2297 bool& get_ssl_handshake_time_out_flag(){
2298 return ssl_handshake_time_out_flag;
2300 void test_call(const boost::system::error_code& error){
2301 l7vs::tcp_session::handle_ssl_handshake_timer(error);
2304 void handle_ssl_handshake_timer_test(){
2306 BOOST_MESSAGE( "----- handle_ssl_handshake_timer test start -----" );
2308 // boost::asio::io_service io;
2309 // l7vs::virtualservice_tcp vs;
2310 // up_thread_exit_test_class test_obj(vs,io);
2312 l7vs::virtualservice_tcp vs;
2313 boost::asio::io_service io;
2314 l7vs::tcp_socket_option_info set_option;
2315 //! TCP_NODELAY (false:not set,true:set option)
2316 set_option.nodelay_opt = false;
2317 //! TCP_NODELAY option value (false:off,true:on)
2318 set_option.nodelay_val = false;
2319 //! TCP_CORK (false:not set,true:set option)
2320 set_option.cork_opt = false;
2321 //! TCP_CORK option value (false:off,true:on)
2322 set_option.cork_val = false;
2323 //! TCP_QUICKACK (false:not set,true:set option)
2324 set_option.quickack_opt = false;
2325 //! TCP_QUICKACK option value (false:off,true:on)
2326 set_option.quickack_val = false;
2328 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
2329 bool set_mode(false);
2330 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
2331 bool set_ssl_cache_flag(false);
2332 int set_ssl_handshake_time_out = 0;
2333 //std::string access_log_file_name = "test";
2334 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
2336 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);
2338 // unit_test [1] ssl_handshake_time_out_flag update check
2339 std::cout << "[1] ssl_handshake_time_out_flag update check" << std::endl;
2341 bool& ref_flag = test_obj.get_ssl_handshake_time_out_flag();
2345 boost::system::error_code test_call_ec;
2346 test_obj.test_call(test_call_ec);
2348 BOOST_CHECK(ref_flag);
2350 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);
2352 test_lock_obj.set_handle_ssl_handshake_timer_test();
2354 test_lock_obj.test_thread_wait.lock();
2355 boost::thread::id proc_id = boost::this_thread::get_id();
2356 test_lock_obj.befor_thread_id = proc_id;
2357 test_lock_obj.after_thread_id = proc_id;
2358 test_lock_obj.mutex_lock();
2360 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
2362 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
2363 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
2365 boost::thread::id test_id = test_thread.get_id();
2367 BOOST_CHECK(test_id != proc_id);
2370 test_lock_obj.test_thread_wait.unlock();
2373 // unit_test [2] set_handle_ssl_handshake_timer_test thread block test (mutex lock)
2374 std::cout << "[2] set_handle_ssl_handshake_timer_test thread block test (mutex lock)" << std::endl;
2375 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
2376 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
2378 test_lock_obj.mutex_unlock();
2381 // unit_test [3] set_handle_ssl_handshake_timer_test thread run test (mutex unlock)
2382 std::cout << "[3] set_handle_ssl_handshake_timer_test thread run test (mutex unlock)" << std::endl;
2383 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
2384 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
2386 BOOST_MESSAGE( "----- handle_ssl_handshake_timer test end -----" );
2390 // is_thread_wait test
2391 // is_thread_wait test class
2392 class is_thread_wait_test_class : public l7vs::tcp_session{
2394 // is_thread_wait_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){};
2395 is_thread_wait_test_class(
2396 l7vs::virtualservice_tcp& vs,
2397 boost::asio::io_service& session_io,
2398 l7vs::tcp_socket_option_info& set_socket_option,
2399 boost::asio::ip::tcp::endpoint listen_endpoint,
2401 boost::asio::ssl::context& set_ssl_context,
2402 bool set_ssl_cache_flag,
2403 int set_ssl_handshake_time_out,
2404 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
2411 set_ssl_handshake_time_out,
2412 set_access_logger){};
2417 ~is_thread_wait_test_class(){};
2419 std::bitset<TCP_SESSION_THREAD_STATE_BIT>& get_thread_state(){
2420 return thread_state;
2423 void is_thread_wait_test(){
2424 BOOST_MESSAGE( "----- is_thread_wait test start -----" );
2426 // boost::asio::io_service io;
2427 // l7vs::virtualservice_tcp vs;
2428 // is_thread_wait_test_class test_obj(vs,io);
2429 l7vs::virtualservice_tcp vs;
2430 boost::asio::io_service io;
2431 l7vs::tcp_socket_option_info set_option;
2432 //! TCP_NODELAY (false:not set,true:set option)
2433 set_option.nodelay_opt = false;
2434 //! TCP_NODELAY option value (false:off,true:on)
2435 set_option.nodelay_val = false;
2436 //! TCP_CORK (false:not set,true:set option)
2437 set_option.cork_opt = false;
2438 //! TCP_CORK option value (false:off,true:on)
2439 set_option.cork_val = false;
2440 //! TCP_QUICKACK (false:not set,true:set option)
2441 set_option.quickack_opt = false;
2442 //! TCP_QUICKACK option value (false:off,true:on)
2443 set_option.quickack_val = false;
2445 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
2446 bool set_mode(false);
2447 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
2448 bool set_ssl_cache_flag(false);
2449 int set_ssl_handshake_time_out = 0;
2450 //std::string access_log_file_name = "test";
2451 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
2453 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);
2455 std::bitset<TCP_SESSION_THREAD_STATE_BIT>& test_bitset = test_obj.get_thread_state();
2457 test_bitset.reset();
2458 BOOST_CHECK(test_bitset.none());
2459 BOOST_CHECK(!test_obj.is_thread_wait());
2461 // unit_test [1] is_thread_wait return check
2462 std::cout << "[1] is_thread_wait return check" << std::endl;
2465 test_bitset.reset();
2466 BOOST_CHECK(test_bitset.none());
2467 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0001);
2468 BOOST_CHECK(!test_obj.is_thread_wait());
2470 // DOWN_THREAD_ALIVE
2471 test_bitset.reset();
2472 BOOST_CHECK(test_bitset.none());
2473 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0002);
2474 BOOST_CHECK(!test_obj.is_thread_wait());
2477 test_bitset.reset();
2478 BOOST_CHECK(test_bitset.none());
2479 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0004);
2480 BOOST_CHECK(!test_obj.is_thread_wait());
2482 // DOWN_THREAD_ACTIVE
2483 test_bitset.reset();
2484 BOOST_CHECK(test_bitset.none());
2485 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0008);
2486 BOOST_CHECK(!test_obj.is_thread_wait());
2489 test_bitset.reset();
2490 BOOST_CHECK(test_bitset.none());
2491 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0010);
2492 BOOST_CHECK(!test_obj.is_thread_wait());
2495 test_bitset.reset();
2496 BOOST_CHECK(test_bitset.none());
2497 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0020);
2498 BOOST_CHECK(!test_obj.is_thread_wait());
2500 // UP_THREAD_LOCK & DOWN_THREAD_LOCK
2501 test_bitset.reset();
2502 BOOST_CHECK(test_bitset.none());
2503 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0010);
2504 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0020);
2505 BOOST_CHECK(test_obj.is_thread_wait());
2507 // UP_THREAD_ALIVE DOWN_THREAD_ALIVE UP_THREAD_ACTIVE DOWN_THREAD_ACTIVE
2508 test_bitset.reset();
2509 BOOST_CHECK(test_bitset.none());
2510 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0001);
2511 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0002);
2512 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0004);
2513 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0008);
2514 BOOST_CHECK(!test_obj.is_thread_wait());
2516 // UP_THREAD_ALIVE DOWN_THREAD_ALIVE UP_THREAD_ACTIVE DOWN_THREAD_ACTIVE UP_THREAD_LOCK
2517 test_bitset.reset();
2518 BOOST_CHECK(test_bitset.none());
2519 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0001);
2520 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0002);
2521 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0004);
2522 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0008);
2523 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0010);
2524 BOOST_CHECK(!test_obj.is_thread_wait());
2526 // UP_THREAD_ALIVE DOWN_THREAD_ALIVE UP_THREAD_ACTIVE DOWN_THREAD_ACTIVE DOWN_THREAD_LOCK
2527 test_bitset.reset();
2528 BOOST_CHECK(test_bitset.none());
2529 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0001);
2530 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0002);
2531 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0004);
2532 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0008);
2533 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0020);
2534 BOOST_CHECK(!test_obj.is_thread_wait());
2536 // UP_THREAD_ALIVE DOWN_THREAD_ALIVE UP_THREAD_ACTIVE DOWN_THREAD_ACTIVE UP_THREAD_LOCK DOWN_THREAD_LOCK
2537 test_bitset.reset();
2538 BOOST_CHECK(test_bitset.none());
2539 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0001);
2540 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0002);
2541 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0004);
2542 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0008);
2543 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0010);
2544 test_bitset |= std::bitset<TCP_SESSION_THREAD_STATE_BIT>(0x0020);
2545 BOOST_CHECK(test_obj.is_thread_wait());
2547 //mutex_lock_test test_lock_obj(vs,io);
2548 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);
2551 test_lock_obj.set_up_thread_exit_test();
2553 test_lock_obj.test_thread_wait.lock();
2554 boost::thread::id proc_id = boost::this_thread::get_id();
2555 test_lock_obj.befor_thread_id = proc_id;
2556 test_lock_obj.after_thread_id = proc_id;
2557 test_lock_obj.mutex_lock();
2559 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
2561 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
2562 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
2564 boost::thread::id test_id = test_thread.get_id();
2566 BOOST_CHECK(test_id != proc_id);
2569 test_lock_obj.test_thread_wait.unlock();
2572 // unit_test [2] is_thread_wait thread block test (mutex lock)
2573 std::cout << "[2] is_thread_wait thread block test (mutex lock)" << std::endl;
2574 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
2575 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
2577 test_lock_obj.mutex_unlock();
2580 // unit_test [3] is_thread_wait thread run test (mutex unlock)
2581 std::cout << "[3] is_thread_wait thread run test (mutex unlock)" << std::endl;
2582 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
2583 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
2585 BOOST_MESSAGE( "----- is_thread_wait test end -----" );
2588 // set_virtual_service_message test
2589 // set_virtual_service_message test class
2590 class set_virtual_service_message_test_class : public l7vs::tcp_session{
2592 // set_virtual_service_message_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){};
2593 set_virtual_service_message_test_class(
2594 l7vs::virtualservice_tcp& vs,
2595 boost::asio::io_service& session_io,
2596 l7vs::tcp_socket_option_info& set_socket_option,
2597 boost::asio::ip::tcp::endpoint listen_endpoint,
2599 boost::asio::ssl::context& set_ssl_context,
2600 bool set_ssl_cache_flag,
2601 int set_ssl_handshake_time_out,
2602 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
2609 set_ssl_handshake_time_out,
2610 set_access_logger){};
2615 ~set_virtual_service_message_test_class(){};
2617 bool& get_session_pause_flag(){
2618 return session_pause_flag;
2621 bool& get_access_log_flag(){
2622 return access_log_flag;
2625 l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_up_thread_message_que(){
2626 return up_thread_message_que;
2629 l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_down_thread_message_que(){
2630 return down_thread_message_que;
2633 std::map< TCP_VIRTUAL_SERVICE_MESSAGE_TAG, tcp_session_func>& get_virtual_service_message_up_thread_function_map(){
2634 return virtual_service_message_up_thread_function_map;
2637 std::map< TCP_VIRTUAL_SERVICE_MESSAGE_TAG, tcp_session_func>& get_virtual_service_message_down_thread_function_map(){
2638 return virtual_service_message_down_thread_function_map;
2641 void up_thread_sorry_enable_event(const TCP_PROCESS_TYPE_TAG process_type){
2642 up_thread_sorry_enable_event_call_check = true;
2644 bool up_thread_sorry_enable_event_call_check;
2646 void up_thread_sorry_disable_event(const TCP_PROCESS_TYPE_TAG process_type){
2647 up_thread_sorry_disable_event_call_check = true;
2649 bool up_thread_sorry_disable_event_call_check;
2651 void up_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
2652 up_thread_exit_call_check = true;
2654 bool up_thread_exit_call_check;
2656 void down_thread_sorry_enable_event(const TCP_PROCESS_TYPE_TAG process_type){
2657 down_thread_sorry_enable_event_call_check = true;
2659 bool down_thread_sorry_enable_event_call_check;
2661 void down_thread_sorry_disable_event(const TCP_PROCESS_TYPE_TAG process_type){
2662 down_thread_sorry_disable_event_call_check = true;
2664 bool down_thread_sorry_disable_event_call_check;
2666 void down_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
2667 down_thread_exit_call_check = true;
2669 bool down_thread_exit_call_check;
2671 void set_virtual_service_message_test(){
2672 BOOST_MESSAGE( "----- set_virtual_service_message test start -----" );
2674 // boost::asio::io_service io;
2675 // l7vs::virtualservice_tcp vs;
2676 // set_virtual_service_message_test_class test_obj(vs,io);
2677 l7vs::virtualservice_tcp vs;
2678 boost::asio::io_service io;
2679 l7vs::tcp_socket_option_info set_option;
2680 //! TCP_NODELAY (false:not set,true:set option)
2681 set_option.nodelay_opt = false;
2682 //! TCP_NODELAY option value (false:off,true:on)
2683 set_option.nodelay_val = false;
2684 //! TCP_CORK (false:not set,true:set option)
2685 set_option.cork_opt = false;
2686 //! TCP_CORK option value (false:off,true:on)
2687 set_option.cork_val = false;
2688 //! TCP_QUICKACK (false:not set,true:set option)
2689 set_option.quickack_opt = false;
2690 //! TCP_QUICKACK option value (false:off,true:on)
2691 set_option.quickack_val = false;
2693 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
2694 bool set_mode(false);
2695 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
2696 bool set_ssl_cache_flag(false);
2697 int set_ssl_handshake_time_out = 0;
2698 //std::string access_log_file_name = "test";
2699 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
2701 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);
2704 bool& ref_pause_flag = test_obj.get_session_pause_flag();
2705 bool& ref_access_log_flag = test_obj.get_access_log_flag();
2706 l7vs::lockfree_queue<l7vs::tcp_thread_message>& ref_up_msg_que = test_obj.get_up_thread_message_que();
2707 l7vs::lockfree_queue<l7vs::tcp_thread_message>& ref_dw_msg_que = test_obj.get_down_thread_message_que();
2708 l7vs::tcp_thread_message* up_msg;
2709 l7vs::tcp_thread_message* dw_msg;
2710 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();
2711 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();
2713 // unit_test [1] set_virtual_service_message SORRY_STATE_ENABLE
2714 std::cout << "[1] set_virtual_service_message SORRY_STATE_ENABLE" << std::endl;
2716 while( !ref_up_msg_que.empty() ){
2717 up_msg = ref_up_msg_que.pop();
2720 BOOST_CHECK(ref_up_msg_que.empty());
2721 while( !ref_dw_msg_que.empty() ){
2722 dw_msg =ref_dw_msg_que.pop();
2725 BOOST_CHECK(ref_dw_msg_que.empty());
2727 test_obj.set_virtual_service_message(l7vs::tcp_session::SORRY_STATE_ENABLE);
2729 BOOST_CHECK(!ref_up_msg_que.empty());
2730 up_msg = ref_up_msg_que.pop();
2731 BOOST_CHECK(ref_up_msg_que.empty());
2732 test_obj.up_thread_sorry_enable_event_call_check = false;
2733 up_msg->message(l7vs::tcp_session::LOCAL_PROC);
2734 BOOST_CHECK(test_obj.up_thread_sorry_enable_event_call_check);
2737 BOOST_CHECK(!ref_dw_msg_que.empty());
2738 dw_msg = ref_dw_msg_que.pop();
2739 BOOST_CHECK(ref_dw_msg_que.empty());
2740 test_obj.down_thread_sorry_enable_event_call_check = false;
2741 dw_msg->message(l7vs::tcp_session::LOCAL_PROC);
2742 BOOST_CHECK(test_obj.down_thread_sorry_enable_event_call_check);
2745 // unit_test [2] set_virtual_service_message SORRY_STATE_DISABLE
2746 std::cout << "[2] set_virtual_service_message SORRY_STATE_DISABLE" << std::endl;
2748 while( !ref_up_msg_que.empty() ){
2749 up_msg = ref_up_msg_que.pop();
2752 BOOST_CHECK(ref_up_msg_que.empty());
2753 while( !ref_dw_msg_que.empty() ){
2754 dw_msg =ref_dw_msg_que.pop();
2757 BOOST_CHECK(ref_dw_msg_que.empty());
2759 test_obj.set_virtual_service_message(l7vs::tcp_session::SORRY_STATE_DISABLE);
2761 BOOST_CHECK(!ref_up_msg_que.empty());
2762 up_msg = ref_up_msg_que.pop();
2763 BOOST_CHECK(ref_up_msg_que.empty());
2764 test_obj.up_thread_sorry_disable_event_call_check = false;
2765 up_msg->message(l7vs::tcp_session::LOCAL_PROC);
2766 BOOST_CHECK(test_obj.up_thread_sorry_disable_event_call_check);
2769 BOOST_CHECK(!ref_dw_msg_que.empty());
2770 dw_msg = ref_dw_msg_que.pop();
2771 BOOST_CHECK(ref_dw_msg_que.empty());
2772 test_obj.down_thread_sorry_disable_event_call_check = false;
2773 dw_msg->message(l7vs::tcp_session::LOCAL_PROC);
2774 BOOST_CHECK(test_obj.down_thread_sorry_disable_event_call_check);
2777 // unit_test [3] set_virtual_service_message SESSION_END
2778 std::cout << "[3] set_virtual_service_message SESSION_END" << std::endl;
2780 while( !ref_up_msg_que.empty() ){
2781 up_msg = ref_up_msg_que.pop();
2784 BOOST_CHECK(ref_up_msg_que.empty());
2785 while( !ref_dw_msg_que.empty() ){
2786 dw_msg =ref_dw_msg_que.pop();
2789 BOOST_CHECK(ref_dw_msg_que.empty());
2791 test_obj.set_virtual_service_message(l7vs::tcp_session::SESSION_END);
2793 BOOST_CHECK(!ref_up_msg_que.empty());
2794 up_msg = ref_up_msg_que.pop();
2795 BOOST_CHECK(ref_up_msg_que.empty());
2796 test_obj.up_thread_exit_call_check = false;
2797 up_msg->message(l7vs::tcp_session::LOCAL_PROC);
2798 BOOST_CHECK(test_obj.up_thread_exit_call_check);
2801 BOOST_CHECK(!ref_dw_msg_que.empty());
2802 dw_msg = ref_dw_msg_que.pop();
2803 BOOST_CHECK(ref_dw_msg_que.empty());
2804 test_obj.down_thread_exit_call_check = false;
2805 dw_msg->message(l7vs::tcp_session::LOCAL_PROC);
2806 BOOST_CHECK(test_obj.down_thread_exit_call_check);
2809 // unit_test [4] set_virtual_service_message SESSION_PAUSE_ON
2810 std::cout << "[4] set_virtual_service_message SESSION_PAUSE_ON" << std::endl;
2811 ref_pause_flag = false;
2812 test_obj.set_virtual_service_message(l7vs::tcp_session::SESSION_PAUSE_ON);
2813 BOOST_CHECK(ref_pause_flag);
2815 // unit_test [5] set_virtual_service_message SESSION_PAUSE_OFF
2816 std::cout << "[5] set_virtual_service_message SESSION_PAUSE_OFF" << std::endl;
2817 ref_pause_flag = true;
2818 test_obj.set_virtual_service_message(l7vs::tcp_session::SESSION_PAUSE_OFF);
2819 BOOST_CHECK(!ref_pause_flag);
2821 // unit_test [6] set_virtual_service_message ACCESS_LOG_ON
2822 std::cout << "[6] set_virtual_service_message ACCESS_LOG__ON" << std::endl;
2823 ref_access_log_flag = false;
2824 test_obj.set_virtual_service_message(l7vs::tcp_session::ACCESS_LOG_ON);
2825 BOOST_CHECK(ref_access_log_flag);
2827 // unit_test [7] set_virtual_service_message ACCESS_LOG_OFF
2828 std::cout << "[7] set_virtual_service_message ACCESS_LOG_OFF" << std::endl;
2829 ref_access_log_flag = true;
2830 test_obj.set_virtual_service_message(l7vs::tcp_session::ACCESS_LOG_OFF);
2831 BOOST_CHECK(!ref_access_log_flag);
2833 // unit_test [8] set_virtual_service_message up thread map find not message error
2834 std::cout << "[8] set_virtual_service_message up thread map find not message error" << std::endl;
2835 ref_vs_up_msg_map.clear();
2836 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
2837 l7vs::Logger::putLogError_id = 0;
2838 while( !ref_up_msg_que.empty() ){
2839 up_msg = ref_up_msg_que.pop();
2842 BOOST_CHECK(ref_up_msg_que.empty());
2843 while( !ref_dw_msg_que.empty() ){
2844 dw_msg =ref_dw_msg_que.pop();
2847 BOOST_CHECK(ref_dw_msg_que.empty());
2849 test_obj.set_virtual_service_message(l7vs::tcp_session::SORRY_STATE_ENABLE);
2851 BOOST_CHECK(ref_up_msg_que.empty());
2852 BOOST_CHECK(!ref_dw_msg_que.empty());
2854 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
2855 BOOST_CHECK_EQUAL(6,l7vs::Logger::putLogError_id);
2856 std::cout << l7vs::Logger::putLogError_message << std::endl;
2858 // unit_test [9] set_virtual_service_message up thread map find not message error
2859 std::cout << "[9] set_virtual_service_message up thread map find not message error" << std::endl;
2860 ref_vs_dw_msg_map.clear();
2861 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
2862 l7vs::Logger::putLogError_id = 0;
2863 ref_vs_dw_msg_map.clear();
2864 BOOST_CHECK(ref_up_msg_que.empty());
2865 while( !ref_dw_msg_que.empty() ){
2866 dw_msg =ref_dw_msg_que.pop();
2869 BOOST_CHECK(ref_dw_msg_que.empty());
2871 test_obj.set_virtual_service_message(l7vs::tcp_session::SORRY_STATE_ENABLE);
2873 BOOST_CHECK(ref_up_msg_que.empty());
2874 BOOST_CHECK(ref_dw_msg_que.empty());
2876 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
2877 BOOST_CHECK_EQUAL(7,l7vs::Logger::putLogError_id);
2878 std::cout << l7vs::Logger::putLogError_message << std::endl;
2880 BOOST_MESSAGE( "----- set_virtual_service_message test end -----" );
2884 // up_thread_run test class
2885 class up_thread_run_test_class : public l7vs::tcp_session{
2887 // up_thread_run_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){
2888 up_thread_run_test_class(
2889 l7vs::virtualservice_tcp& vs,
2890 boost::asio::io_service& session_io,
2891 l7vs::tcp_socket_option_info& set_socket_option,
2892 boost::asio::ip::tcp::endpoint listen_endpoint,
2894 boost::asio::ssl::context& set_ssl_context,
2895 bool set_ssl_cache_flag,
2896 int set_ssl_handshake_time_out,
2897 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
2904 set_ssl_handshake_time_out,
2909 ~up_thread_run_test_class(){};
2910 bool& get_exit_flag(){
2914 bool& get_session_pause_flag(){
2915 return session_pause_flag;
2918 std::bitset<TCP_SESSION_THREAD_STATE_BIT>& get_thread_state(){
2919 return thread_state;
2922 boost::mutex test_thread_wait;
2924 boost::mutex::scoped_lock scope_lock(test_thread_wait);
2926 std::cout << "up_thread_run test call" << std::endl;
2935 void set_protocol_module(l7vs::protocol_module_base* set_proto){
2936 protocol_module = set_proto;
2939 l7vs::tcp_socket& get_client_socket(){
2940 return client_socket;
2943 boost::thread::id& get_up_thread_id(){
2944 return up_thread_id;
2947 boost::thread::id& get_down_thread_id(){
2948 return down_thread_id;
2951 void up_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
2952 up_thread_exit_process_type = process_type;
2953 l7vs::tcp_session::up_thread_exit(process_type);
2954 up_thread_exit_call_check = true;
2956 TCP_PROCESS_TYPE_TAG up_thread_exit_process_type;
2957 bool up_thread_exit_call_check;
2959 void up_thread_all_socket_close(void){
2960 up_thread_all_socket_close_call_check = true;
2962 bool up_thread_all_socket_close_call_check;
2964 void test_message_set(boost::asio::ip::tcp::endpoint set_endpoint){
2965 l7vs::tcp_thread_message* chk_msg = new l7vs::tcp_thread_message;
2966 up_thread_message_que.push(chk_msg);
2967 chk_msg->endpoint_info = set_endpoint;
2968 up_thread_function_pair func = up_thread_function_array[UP_FUNC_EXIT];
2969 chk_msg->message = func.second;
2972 l7vs::tcp_data& get_up_thread_message_data(){
2973 return up_thread_message_data;
2976 void clear_function_array(){
2977 for(int i = 0;i <= UP_FUNC_EXIT;i++){
2978 up_thread_function_array[i].second = NULL;
2981 void clear_event_map(){
2982 up_thread_module_event_map.clear();
2985 void set_up_thread_next_call_function_client_disconnect(){
2986 up_thread_next_call_function = up_thread_function_array[UP_FUNC_CLIENT_DISCONNECT];
2988 void set_up_thread_next_call_function_exit(){
2989 up_thread_next_call_function = up_thread_function_array[UP_FUNC_EXIT];
2993 void up_thread_run_test(){
2995 BOOST_MESSAGE( "----- up_thread_run test start -----" );
2997 boost::asio::io_service io;
2998 l7vs::virtualservice_tcp vs;
2999 l7vs::tcp_socket_option_info set_option;
3000 //! TCP_NODELAY (false:not set,true:set option)
3001 set_option.nodelay_opt = false;
3002 //! TCP_NODELAY option value (false:off,true:on)
3003 set_option.nodelay_val = false;
3004 //! TCP_CORK (false:not set,true:set option)
3005 set_option.cork_opt = false;
3006 //! TCP_CORK option value (false:off,true:on)
3007 set_option.cork_val = false;
3008 //! TCP_QUICKACK (false:not set,true:set option)
3009 set_option.quickack_opt = false;
3010 //! TCP_QUICKACK option value (false:off,true:on)
3011 set_option.quickack_val = false;
3013 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
3014 bool set_mode(false);
3015 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
3016 bool set_ssl_cache_flag(false);
3017 int set_ssl_handshake_time_out = 0;
3018 //std::string access_log_file_name = "test";
3019 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
3021 boost::system::error_code ec;
3023 std::string test_protocol_name("test protocol");
3024 l7vs::test_protocol_module proto_test(test_protocol_name);
3026 // up_thread_run_test_class test_obj(vs,io);
3027 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);
3029 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
3030 bool& exit_flag = test_obj.get_exit_flag();
3031 bool& session_pause_flag = test_obj.get_session_pause_flag();
3032 boost::thread::id& up_thread_id = test_obj.get_up_thread_id();
3033 boost::thread::id& down_thread_id = test_obj.get_down_thread_id();
3036 std::bitset<TCP_SESSION_THREAD_STATE_BIT>& thread_state = test_obj.get_thread_state();
3037 l7vs::tcp_socket& client_socket = test_obj.get_client_socket();
3039 test_mirror_server test_server;
3041 test_server.breq_acc_flag = true;
3043 test_server.breq_close_wait_flag = true;
3045 test_server.req_recv_cnt = 0;
3046 // test server start
3047 boost::thread server_thread(boost::bind(&test_mirror_server::run,&test_server));
3048 while( !test_server.brun_flag ){
3052 boost::asio::ip::tcp::endpoint connect_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
3053 client_socket.get_socket().connect(connect_end,ec);
3055 while(!test_server.bconnect_flag){
3059 test_obj.test_thread_wait.lock();
3060 thread_state[0] = 0; // UP_THREAD_ALIVE
3061 thread_state[1] = 0; // DOWN_THREAD_ALIVE
3062 thread_state[2] = 0; // UP_THREAD_ACTIVE
3063 thread_state[3] = 0; // DOWN_THREAD_ACTIVE
3064 thread_state[4] = 0; // UP_THREAD_LOCK
3065 thread_state[5] = 0; // DOWN_THREAD_LOCK
3066 up_thread_id = boost::thread::id();
3067 boost::thread test_thread(boost::bind(&up_thread_run_test_class::test_run,&test_obj));
3069 boost::thread::id test_id = test_thread.get_id();
3070 boost::thread::id proc_id = boost::this_thread::get_id();
3072 BOOST_CHECK(!thread_state.test(0)); // UP_THREAD_ALIVE
3073 BOOST_CHECK(!thread_state.test(1)); // DOWN_THREAD_ALIVE
3074 BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
3075 BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
3076 BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
3077 BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
3078 BOOST_CHECK(up_thread_id != test_id);
3079 test_obj.test_thread_wait.unlock();
3082 // unit_test [1] up_thread_run thread id update check
3083 std::cout << "[1] up_thread_run thread id update check" << std::endl;
3084 BOOST_CHECK(up_thread_id == test_id);
3086 // unit_test [2] up_thread_run down thread wait check
3087 std::cout << "[2] up_thread_run down thread wait check" << std::endl;
3088 BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
3089 BOOST_CHECK(!thread_state.test(1)); // DOWN_THREAD_ALIVE
3090 BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
3091 BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
3092 BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
3093 BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
3095 proto_test.handle_session_initialize_res_tag = l7vs::protocol_module_base::FINALIZE;
3096 proto_test.handle_session_initialize_in_up_thread_id = boost::thread::id();
3097 proto_test.handle_session_initialize_in_down_thread_id = boost::thread::id();
3098 proto_test.handle_session_initialize_in_client_endpoint_tcp = boost::asio::ip::tcp::endpoint();
3099 proto_test.handle_session_initialize_in_client_endpoint_udp.address(boost::asio::ip::address::from_string("255.255.255.255"));
3100 proto_test.handle_session_initialize_in_client_endpoint_udp.port(65535);
3101 BOOST_CHECK(proto_test.handle_session_initialize_in_up_thread_id != test_id);
3102 BOOST_CHECK(proto_test.handle_session_initialize_in_down_thread_id != proc_id);
3103 BOOST_CHECK(proto_test.handle_session_initialize_in_client_endpoint_tcp != connect_end);
3104 BOOST_CHECK(proto_test.handle_session_initialize_in_client_endpoint_udp != boost::asio::ip::udp::endpoint());
3105 down_thread_id = proc_id;
3106 session_pause_flag = true;
3108 // DOWN_THREAD_ALIVE
3109 thread_state[1] = 1;
3112 // unit_test [3] up_thread_run handle_session_initialize call check
3113 std::cout << "[3] up_thread_run handle_session_initialize call check" << std::endl;
3114 BOOST_CHECK(proto_test.handle_session_initialize_in_up_thread_id == test_id);
3115 BOOST_CHECK(proto_test.handle_session_initialize_in_down_thread_id == proc_id);
3116 BOOST_CHECK(proto_test.handle_session_initialize_in_client_endpoint_tcp == connect_end);
3117 BOOST_CHECK(proto_test.handle_session_initialize_in_client_endpoint_udp == boost::asio::ip::udp::endpoint());
3119 // unit_test [4] up_thread_run state update(UP_THREAD_ACTIVE) check
3120 std::cout << "[4] up_thread_run state update(UP_THREAD_ACTIVE) check" << std::endl;
3121 BOOST_CHECK(thread_state.test(2)); // UP_THREAD_ACTIVE
3123 // unit_test [5] up_thread_run pause check
3124 std::cout << "[5] up_thread_run pause check" << std::endl;
3125 BOOST_CHECK(thread_state.test(4)); // UP_THREAD_LOCK
3127 test_obj.up_thread_exit_process_type = l7vs::tcp_session::MESSAGE_PROC;
3128 test_obj.up_thread_exit_call_check = false;
3129 test_obj.up_thread_all_socket_close_call_check = false;
3131 session_pause_flag = false;
3134 // unit_test [6] up_thread_run restart check
3135 std::cout << "[6] up_thread_run restart check" << std::endl;
3136 BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
3138 // unit_test [7] up_thread_run up_thread_next_call_function call (up_thread_exit) check
3139 std::cout << "[7] up_thread_run up_thread_next_call_function call (up_thread_exit) check" << std::endl;
3140 BOOST_CHECK(test_obj.up_thread_exit_call_check);
3141 BOOST_CHECK(test_obj.up_thread_exit_process_type == l7vs::tcp_session::LOCAL_PROC);
3143 // unit_test [8] up_thread_run main loop exit check
3144 std::cout << "[8] up_thread_run main loop exit check" << std::endl;
3145 BOOST_CHECK(exit_flag);
3146 BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
3149 // unit_test [9] up_thread_run up_thread_all_socket_close_call_check call check
3150 std::cout << "[9] up_thread_run up_thread_all_socket_close_call_check call check" << std::endl;
3151 BOOST_CHECK(test_obj.up_thread_all_socket_close_call_check);
3153 // unit_test [10] up_thread_run down thread end wait check
3154 std::cout << "[10] up_thread_run down thread wait check" << std::endl;
3155 BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
3156 BOOST_CHECK(thread_state.test(1)); // DOWN_THREAD_ALIVE
3157 BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
3158 BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
3159 BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
3160 BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
3163 // proto_test.handle_session_finalize_in_up_thread_id = boost::thread::id();
3164 // proto_test.handle_session_finalize_in_down_thread_id = boost::thread::id();
3165 // BOOST_CHECK(proto_test.handle_session_finalize_in_up_thread_id != test_id);
3166 // BOOST_CHECK(proto_test.handle_session_finalize_in_down_thread_id != proc_id);
3167 // vs.release_session_ptr = NULL;
3168 // BOOST_CHECK(vs.release_session_ptr != test_id);
3170 thread_state[1] = 0;
3173 // unit_test [11] up_thread_run handle_session_finalize call check
3174 std::cout << "[11] up_thread_run handle_session_finalize call check" << std::endl;
3175 BOOST_CHECK(proto_test.handle_session_finalize_in_up_thread_id == test_id);
3176 BOOST_CHECK(proto_test.handle_session_finalize_in_down_thread_id == proc_id);
3178 // unit_test [12] up_thread_run release_session_id call check
3179 std::cout << "[12] up_thread_run release_session_id call check" << std::endl;
3180 // BOOST_CHECK(vs.release_session_id == test_id);
3182 // unit_test [13] up_thread_run state update(UP_THREAD_ACTIVE) check
3183 std::cout << "[13] up_thread_run state update(UP_THREAD_ACTIVE) check" << std::endl;
3184 BOOST_CHECK(!thread_state.test(0)); // UP_THREAD_ACTIVE
3186 // message call test
3188 session_pause_flag = false;
3189 l7vs::tcp_data& msg_data = test_obj.get_up_thread_message_data();
3190 test_obj.test_message_set(connect_end);
3191 thread_state[0] = 0; // UP_THREAD_ALIVE
3192 thread_state[1] = 1; // DOWN_THREAD_ALIVE
3193 thread_state[2] = 0; // UP_THREAD_ACTIVE
3194 thread_state[3] = 0; // DOWN_THREAD_ACTIVE
3195 thread_state[4] = 0; // UP_THREAD_LOCK
3196 thread_state[5] = 0; // DOWN_THREAD_LOCK
3197 msg_data.set_endpoint(boost::asio::ip::tcp::endpoint());
3198 test_obj.up_thread_exit_call_check = false;
3199 test_obj.up_thread_exit_process_type = l7vs::tcp_session::LOCAL_PROC;
3200 proto_test.handle_session_initialize_res_tag = l7vs::protocol_module_base::CLIENT_DISCONNECT;
3202 // test thread start
3203 test_obj.test_wait = false;
3205 BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
3206 BOOST_CHECK(thread_state.test(1)); // DOWN_THREAD_ALIVE
3207 BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
3208 BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
3209 BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
3210 BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
3212 // unit_test [14] up_thread_run message call check
3213 std::cout << "[14] up_thread_run message call check" << std::endl;
3214 BOOST_CHECK(test_obj.up_thread_exit_call_check);
3215 BOOST_CHECK(test_obj.up_thread_exit_process_type == l7vs::tcp_session::MESSAGE_PROC);
3217 proto_test.handle_session_initialize_res_tag = l7vs::protocol_module_base::FINALIZE;
3218 thread_state[1] = 0;
3221 // error test not find function map
3222 test_obj.clear_function_array();
3224 session_pause_flag = false;
3225 thread_state[1] = 1;
3227 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
3228 l7vs::Logger::putLogError_id = 0;
3230 test_obj.test_wait = false;
3233 // unit_test [15] up_thread_run not find function map error test
3234 std::cout << "[15] up_thread_run not find function map error test" << std::endl;
3235 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
3236 BOOST_CHECK_EQUAL(15,l7vs::Logger::putLogError_id);
3237 std::cout << l7vs::Logger::putLogError_message << std::endl;
3239 thread_state[1] = 0;
3242 //error test protocol_module returnd illegal EVENT_TAG
3243 test_obj.clear_event_map();
3245 session_pause_flag = false;
3246 thread_state[1] = 1;
3248 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
3249 l7vs::Logger::putLogError_id = 0;
3251 test_obj.test_wait = false;
3254 // unit_test [16] up_thread_run protocol_module returnd illegal EVENT_TAG error test
3255 std::cout << "[16] up_thread_run protocol_module returnd illegal EVENT_TAG error test" << std::endl;
3256 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
3257 BOOST_CHECK_EQUAL(14,l7vs::Logger::putLogError_id);
3258 std::cout << l7vs::Logger::putLogError_message << std::endl;
3260 thread_state[1] = 0;
3264 // unit_test [17] up_thread_run set non blocking fail check
3265 std::cout << "[17] up_thread_run set non blocking fail check" << std::endl;
3267 session_pause_flag = false;
3268 thread_state[1] = 1;
3270 l7vs::tcp_socket::set_non_blocking_mode_res = false;
3271 l7vs::tcp_socket::set_non_blocking_mode_ec = boost::asio::error::bad_descriptor;
3272 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
3273 l7vs::Logger::putLogError_id = 0;
3275 test_obj.test_wait = false;
3278 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
3279 BOOST_CHECK_EQUAL(11,l7vs::Logger::putLogError_id);
3280 std::cout << l7vs::Logger::putLogError_message << std::endl;
3281 l7vs::tcp_socket::set_non_blocking_mode_res = true;
3282 l7vs::tcp_socket::set_non_blocking_mode_ec.clear();
3284 thread_state[1] = 0;
3287 //error test client endpoint get error
3288 client_socket.get_socket().close(ec);
3290 session_pause_flag = false;
3291 thread_state[1] = 1;
3293 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
3294 l7vs::Logger::putLogError_id = 0;
3296 test_obj.test_wait = false;
3299 // unit_test [18] up_thread_run client endpoint get error test
3300 std::cout << "[18] up_thread_run client endpoint get error test" << std::endl;
3301 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
3302 BOOST_CHECK_EQUAL(9,l7vs::Logger::putLogError_id);
3303 std::cout << l7vs::Logger::putLogError_message << std::endl;
3305 thread_state[1] = 0;
3308 //error test protocol module null error
3309 test_obj.set_protocol_module(NULL);
3311 session_pause_flag = false;
3312 thread_state[1] = 1;
3314 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
3315 l7vs::Logger::putLogError_id = 0;
3317 test_obj.test_wait = false;
3320 // unit_test [19] up_thread_run protocol module null error test
3321 std::cout << "[19] up_thread_run protocol module null error test" << std::endl;
3322 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
3323 BOOST_CHECK_EQUAL(8,l7vs::Logger::putLogError_id);
3324 std::cout << l7vs::Logger::putLogError_message << std::endl;
3326 thread_state[1] = 0;
3329 test_obj.test_end = true;
3330 test_obj.test_wait = false;
3331 std::cout << "test_thread.join wait" << std::endl;
3333 std::cout << "test_thread.join ok" << std::endl;
3336 test_server.breq_close_wait_flag = false;
3337 test_server.bstop_flag = true;
3338 std::cout << "server_thread.join wait" << std::endl;
3339 server_thread.join();
3340 std::cout << "server_thread.join ok" << std::endl;
3343 BOOST_MESSAGE( "----- up_thread_run test end -----" );
3350 // down_thread_run test class
3351 class down_thread_run_test_class : public l7vs::tcp_session{
3353 // down_thread_run_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){
3354 down_thread_run_test_class(
3355 l7vs::virtualservice_tcp& vs,
3356 boost::asio::io_service& session_io,
3357 l7vs::tcp_socket_option_info& set_socket_option,
3358 boost::asio::ip::tcp::endpoint listen_endpoint,
3360 boost::asio::ssl::context& set_ssl_context,
3361 bool set_ssl_cache_flag,
3362 int set_ssl_handshake_time_out,
3363 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
3370 set_ssl_handshake_time_out,
3375 ~down_thread_run_test_class(){};
3376 bool& get_exit_flag(){
3380 bool& get_session_pause_flag(){
3381 return session_pause_flag;
3384 std::bitset<TCP_SESSION_THREAD_STATE_BIT>& get_thread_state(){
3385 return thread_state;
3388 boost::mutex test_thread_wait;
3390 boost::mutex::scoped_lock scope_lock(test_thread_wait);
3400 void set_protocol_module(l7vs::protocol_module_base* set_proto){
3401 protocol_module = set_proto;
3404 boost::thread::id& get_down_thread_id(){
3405 return down_thread_id;
3408 void down_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
3409 down_thread_exit_process_type = process_type;
3410 l7vs::tcp_session::down_thread_exit(process_type);
3411 down_thread_exit_call_check = true;
3413 TCP_PROCESS_TYPE_TAG down_thread_exit_process_type;
3414 bool down_thread_exit_call_check;
3416 void down_thread_all_socket_close(void){
3417 down_thread_all_socket_close_call_check = true;
3419 bool down_thread_all_socket_close_call_check;
3421 void test_message_set(boost::asio::ip::tcp::endpoint set_endpoint){
3422 l7vs::tcp_thread_message* chk_msg = new l7vs::tcp_thread_message;
3423 down_thread_message_que.push(chk_msg);
3424 chk_msg->endpoint_info = set_endpoint;
3425 down_thread_function_pair func = down_thread_function_array[DOWN_FUNC_EXIT];
3426 chk_msg->message = func.second;
3429 l7vs::tcp_data& get_down_thread_message_data(){
3430 return down_thread_message_data;
3433 void clear_function_array(){
3434 for(int i = 0;i < DOWN_FUNC_EXIT;i++){
3435 down_thread_function_array[i].second = NULL;
3439 void down_thread_realserver_receive(const TCP_PROCESS_TYPE_TAG process_type){
3440 down_thread_realserver_receive_call_check = true;
3441 down_thread_realserver_receive_process_type = process_type;
3444 bool down_thread_realserver_receive_call_check;
3445 TCP_PROCESS_TYPE_TAG down_thread_realserver_receive_process_type;
3447 void set_down_thread_connect_socket_list(){
3448 for(int i = 0 ; i < 1024;i++){
3449 std::pair<boost::asio::ip::tcp::endpoint,tcp_socket_ptr > push_element;
3450 boost::asio::ip::tcp::endpoint set_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), i);
3451 push_element.first = set_end;
3452 down_thread_connect_socket_list.push_back(push_element);
3453 //std::cout << push_element.first << std::endl;
3455 if(down_thread_connect_socket_list.empty()){
3456 std::cout << "down_thread_connect_socket_list.empty!" << std::endl;
3460 bool check_down_thread_receive_realserver_socket_list(){
3462 std::list<socket_element>::iterator cur_it = down_thread_receive_realserver_socket_list.begin();
3463 for(int i = 0 ; i < 1024;i++){
3464 if(cur_it == down_thread_receive_realserver_socket_list.end()){
3465 std::cout << "DEBUG index[";
3467 std::cout << "] not element" << std::endl;
3471 boost::asio::ip::tcp::endpoint set_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), i);
3472 if(cur_it->first != set_end){
3473 int port = (int)cur_it->first.port();
3475 std::cout << "DEBUG index[";
3477 std::cout << "] port[";
3479 std::cout << "]" << std::endl;
3487 void down_thread_run_test(){
3489 BOOST_MESSAGE( "----- down_thread_run test start -----" );
3491 boost::asio::io_service io;
3492 l7vs::virtualservice_tcp vs;
3493 l7vs::tcp_socket_option_info set_option;
3494 //! TCP_NODELAY (false:not set,true:set option)
3495 set_option.nodelay_opt = false;
3496 //! TCP_NODELAY option value (false:off,true:on)
3497 set_option.nodelay_val = false;
3498 //! TCP_CORK (false:not set,true:set option)
3499 set_option.cork_opt = false;
3500 //! TCP_CORK option value (false:off,true:on)
3501 set_option.cork_val = false;
3502 //! TCP_QUICKACK (false:not set,true:set option)
3503 set_option.quickack_opt = false;
3504 //! TCP_QUICKACK option value (false:off,true:on)
3505 set_option.quickack_val = false;
3507 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
3508 bool set_mode(false);
3509 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
3510 bool set_ssl_cache_flag(false);
3511 int set_ssl_handshake_time_out = 0;
3512 //std::string access_log_file_name = "test";
3513 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
3515 boost::system::error_code ec;
3517 std::string test_protocol_name("test protocol");
3518 l7vs::test_protocol_module proto_test(test_protocol_name);
3520 // down_thread_run_test_class test_obj(vs,io);
3521 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);
3523 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
3524 bool& exit_flag = test_obj.get_exit_flag();
3525 bool& session_pause_flag = test_obj.get_session_pause_flag();
3526 boost::thread::id& down_thread_id = test_obj.get_down_thread_id();
3529 boost::asio::ip::tcp::endpoint connect_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
3530 std::bitset<TCP_SESSION_THREAD_STATE_BIT>& thread_state = test_obj.get_thread_state();
3532 test_obj.test_thread_wait.lock();
3533 thread_state[0] = 1; // UP_THREAD_ALIVE
3534 thread_state[1] = 0; // DOWN_THREAD_ALIVE
3535 thread_state[2] = 0; // UP_THREAD_ACTIVE
3536 thread_state[3] = 0; // DOWN_THREAD_ACTIVE
3537 thread_state[4] = 0; // UP_THREAD_LOCK
3538 thread_state[5] = 0; // DOWN_THREAD_LOCK
3539 down_thread_id = boost::thread::id();
3540 boost::thread test_thread(boost::bind(&down_thread_run_test_class::test_run,&test_obj));
3542 boost::thread::id test_id = test_thread.get_id();
3543 boost::thread::id proc_id = boost::this_thread::get_id();
3545 BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
3546 BOOST_CHECK(!thread_state.test(1)); // DOWN_THREAD_ALIVE
3547 BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
3548 BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
3549 BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
3550 BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
3551 BOOST_CHECK(down_thread_id != test_id);
3552 test_obj.test_thread_wait.unlock();
3555 // unit_test [1] down_thread_run thread id update check
3556 std::cout << "[1] down_thread_run thread id update check" << std::endl;
3557 BOOST_CHECK(down_thread_id == test_id);
3559 // unit_test [2] down_thread_run up thread active wait check
3560 std::cout << "[2] down_thread_run up thread active wait check" << std::endl;
3561 BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
3562 BOOST_CHECK(thread_state.test(1)); // DOWN_THREAD_ALIVE
3563 BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
3564 BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
3565 BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
3566 BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
3568 session_pause_flag = true;
3571 thread_state[2] = 1;
3574 // unit_test [3] down_thread_run state update(DOWN_THREAD_ACTIVE) check
3575 std::cout << "[3] down_thread_run state update(DOWN_THREAD_ACTIVE) check" << std::endl;
3576 BOOST_CHECK(thread_state.test(3)); // DOWN_THREAD_ACTIVE
3578 // unit_test [4] down_thread_run pause check
3579 std::cout << "[4] down_thread_run pause check" << std::endl;
3580 BOOST_CHECK(thread_state.test(5)); // DOWN_THREAD_LOCK
3582 test_obj.down_thread_realserver_receive_call_check = false;
3583 test_obj.down_thread_realserver_receive_process_type = l7vs::tcp_session::MESSAGE_PROC;
3584 test_obj.down_thread_all_socket_close_call_check = false;
3586 test_obj.set_down_thread_connect_socket_list();
3588 session_pause_flag = false;
3591 // unit_test [5] down_thread_run restart check
3592 std::cout << "[5] down_thread_run restart check" << std::endl;
3593 BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
3596 // unit_test [6] down_thread_run connect realserver set receive list check
3597 std::cout << "[6] down_thread_run connect realserver set receive list check" << std::endl;
3598 BOOST_CHECK(test_obj.check_down_thread_receive_realserver_socket_list());
3600 // unit_test [7] down_thread_run down_thread_next_call_function call (down_thread_realserver_receive) check
3601 std::cout << "[7] down_thread_run down_thread_next_call_function call (down_thread_realserver_receive) check" << std::endl;
3602 BOOST_CHECK(test_obj.down_thread_realserver_receive_call_check);
3603 BOOST_CHECK(test_obj.down_thread_realserver_receive_process_type == l7vs::tcp_session::LOCAL_PROC);
3605 // unit_test [8] down_thread_run main loop exit check
3606 std::cout << "[8] down_thread_run main loop exit check" << std::endl;
3607 BOOST_CHECK(exit_flag);
3608 BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
3610 // unit_test [9] down_thread_run down_thread_all_socket_close_call_check call check
3611 std::cout << "[9] down_thread_run down_thread_all_socket_close_call_check call check" << std::endl;
3612 BOOST_CHECK(test_obj.down_thread_all_socket_close_call_check);
3614 // unit_test [10] down_thread_run state update(DOWN_THREAD_ACTIVE) check
3615 std::cout << "[10] down_thread_run state update(DOWN_THREAD_ACTIVE) check" << std::endl;
3616 BOOST_CHECK(!thread_state.test(1)); // DOWN_THREAD_ACTIVE
3618 // message call test
3620 session_pause_flag = false;
3621 l7vs::tcp_data& msg_data = test_obj.get_down_thread_message_data();
3622 test_obj.test_message_set(connect_end);
3623 thread_state[0] = 1; // UP_THREAD_ALIVE
3624 thread_state[2] = 1; // UP_THREAD_ACTIVE
3625 msg_data.set_endpoint(boost::asio::ip::tcp::endpoint());
3626 test_obj.down_thread_exit_call_check = false;
3627 test_obj.down_thread_exit_process_type = l7vs::tcp_session::LOCAL_PROC;
3629 // test thread start
3630 test_obj.test_wait = false;
3633 // unit_test [11] down_thread_run message call check
3634 std::cout << "[11] down_thread_run message call check" << std::endl;
3635 BOOST_CHECK(test_obj.down_thread_exit_call_check);
3636 BOOST_CHECK(test_obj.down_thread_exit_process_type == l7vs::tcp_session::MESSAGE_PROC);
3638 // error test not find function map
3639 test_obj.clear_function_array();
3641 session_pause_flag = true;
3642 thread_state[0] = 1; // UP_THREAD_ALIVE
3643 thread_state[2] = 1; // UP_THREAD_ACTIVE
3645 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
3646 l7vs::Logger::putLogError_id = 0;
3648 test_obj.test_wait = false;
3651 // unit_test [12] down_thread_run not find function map error test
3652 std::cout << "[12] down_thread_run not find function map error test" << std::endl;
3653 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
3654 BOOST_CHECK_EQUAL(16,l7vs::Logger::putLogError_id);
3655 std::cout << l7vs::Logger::putLogError_message << std::endl;
3658 test_obj.test_end = true;
3659 test_obj.test_wait = false;
3663 BOOST_MESSAGE( "----- down_thread_run test end -----" );
3668 // thread_state_update test
3669 // thread_state_update test class
3670 class thread_state_update_test_class : public l7vs::tcp_session{
3672 // thread_state_update_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){};
3673 thread_state_update_test_class(
3674 l7vs::virtualservice_tcp& vs,
3675 boost::asio::io_service& session_io,
3676 l7vs::tcp_socket_option_info& set_socket_option,
3677 boost::asio::ip::tcp::endpoint listen_endpoint,
3679 boost::asio::ssl::context& set_ssl_context,
3680 bool set_ssl_cache_flag,
3681 int set_ssl_handshake_time_out,
3682 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
3689 set_ssl_handshake_time_out,
3690 set_access_logger){};
3694 ~thread_state_update_test_class(){};
3695 std::bitset<TCP_SESSION_THREAD_STATE_BIT>& get_thread_state(){
3696 return thread_state;
3699 void test_call(const std::bitset<TCP_SESSION_THREAD_STATE_BIT> thread_flag,const bool regist){
3700 thread_state_update(thread_flag,regist);
3703 void thread_state_update_test(){
3705 BOOST_MESSAGE( "----- thread_state_update test start -----" );
3707 // boost::asio::io_service io;
3708 // l7vs::virtualservice_tcp vs;
3709 // thread_state_update_test_class test_obj(vs,io);
3710 l7vs::virtualservice_tcp vs;
3711 boost::asio::io_service io;
3712 l7vs::tcp_socket_option_info set_option;
3713 //! TCP_NODELAY (false:not set,true:set option)
3714 set_option.nodelay_opt = false;
3715 //! TCP_NODELAY option value (false:off,true:on)
3716 set_option.nodelay_val = false;
3717 //! TCP_CORK (false:not set,true:set option)
3718 set_option.cork_opt = false;
3719 //! TCP_CORK option value (false:off,true:on)
3720 set_option.cork_val = false;
3721 //! TCP_QUICKACK (false:not set,true:set option)
3722 set_option.quickack_opt = false;
3723 //! TCP_QUICKACK option value (false:off,true:on)
3724 set_option.quickack_val = false;
3726 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
3727 bool set_mode(false);
3728 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
3729 bool set_ssl_cache_flag(false);
3730 int set_ssl_handshake_time_out = 0;
3731 //std::string access_log_file_name = "test";
3732 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
3734 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);
3739 std::bitset<TCP_SESSION_THREAD_STATE_BIT>& thread_state = test_obj.get_thread_state();
3741 thread_state[0] = 0; // UP_THREAD_ALIVE
3742 thread_state[1] = 0; // DOWN_THREAD_ALIVE
3743 thread_state[2] = 0; // UP_THREAD_ACTIVE
3744 thread_state[3] = 0; // DOWN_THREAD_ACTIVE
3745 thread_state[4] = 0; // UP_THREAD_LOCK
3746 thread_state[5] = 0; // DOWN_THREAD_LOCK
3747 BOOST_CHECK(!thread_state.test(0)); // UP_THREAD_ALIVE
3748 BOOST_CHECK(!thread_state.test(1)); // DOWN_THREAD_ALIVE
3749 BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
3750 BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
3751 BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
3752 BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
3755 // unit_test [1] thread_state_update set flag test
3756 std::cout << "[1] thread_state_update set flag test" << std::endl;
3757 test_obj.test_call(UP_THREAD_ALIVE,true);
3758 BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
3759 BOOST_CHECK(!thread_state.test(1)); // DOWN_THREAD_ALIVE
3760 BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
3761 BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
3762 BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
3763 BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
3765 test_obj.test_call(DOWN_THREAD_ALIVE,true);
3766 BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
3767 BOOST_CHECK(thread_state.test(1)); // DOWN_THREAD_ALIVE
3768 BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
3769 BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
3770 BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
3771 BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
3773 test_obj.test_call(UP_THREAD_ACTIVE,true);
3774 BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
3775 BOOST_CHECK(thread_state.test(1)); // DOWN_THREAD_ALIVE
3776 BOOST_CHECK(thread_state.test(2)); // UP_THREAD_ACTIVE
3777 BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
3778 BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
3779 BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
3781 test_obj.test_call(DOWN_THREAD_ACTIVE,true);
3782 BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
3783 BOOST_CHECK(thread_state.test(1)); // DOWN_THREAD_ALIVE
3784 BOOST_CHECK(thread_state.test(2)); // UP_THREAD_ACTIVE
3785 BOOST_CHECK(thread_state.test(3)); // DOWN_THREAD_ACTIVE
3786 BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
3787 BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
3789 test_obj.test_call(UP_THREAD_LOCK,true);
3790 BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
3791 BOOST_CHECK(thread_state.test(1)); // DOWN_THREAD_ALIVE
3792 BOOST_CHECK(thread_state.test(2)); // UP_THREAD_ACTIVE
3793 BOOST_CHECK(thread_state.test(3)); // DOWN_THREAD_ACTIVE
3794 BOOST_CHECK(thread_state.test(4)); // UP_THREAD_LOCK
3795 BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
3797 test_obj.test_call(DOWN_THREAD_LOCK,true);
3798 BOOST_CHECK(thread_state.test(0)); // UP_THREAD_ALIVE
3799 BOOST_CHECK(thread_state.test(1)); // DOWN_THREAD_ALIVE
3800 BOOST_CHECK(thread_state.test(2)); // UP_THREAD_ACTIVE
3801 BOOST_CHECK(thread_state.test(3)); // DOWN_THREAD_ACTIVE
3802 BOOST_CHECK(thread_state.test(4)); // UP_THREAD_LOCK
3803 BOOST_CHECK(thread_state.test(5)); // DOWN_THREAD_LOCK
3805 // unit_test [2] thread_state_update reset flag test
3806 std::cout << "[2] thread_state_update reset flag test" << std::endl;
3807 test_obj.test_call(UP_THREAD_ALIVE,false);
3808 BOOST_CHECK(!thread_state.test(0)); // UP_THREAD_ALIVE
3809 BOOST_CHECK(thread_state.test(1)); // DOWN_THREAD_ALIVE
3810 BOOST_CHECK(thread_state.test(2)); // UP_THREAD_ACTIVE
3811 BOOST_CHECK(thread_state.test(3)); // DOWN_THREAD_ACTIVE
3812 BOOST_CHECK(thread_state.test(4)); // UP_THREAD_LOCK
3813 BOOST_CHECK(thread_state.test(5)); // DOWN_THREAD_LOCK
3815 test_obj.test_call(DOWN_THREAD_ALIVE,false);
3816 BOOST_CHECK(!thread_state.test(0)); // UP_THREAD_ALIVE
3817 BOOST_CHECK(!thread_state.test(1)); // DOWN_THREAD_ALIVE
3818 BOOST_CHECK(thread_state.test(2)); // UP_THREAD_ACTIVE
3819 BOOST_CHECK(thread_state.test(3)); // DOWN_THREAD_ACTIVE
3820 BOOST_CHECK(thread_state.test(4)); // UP_THREAD_LOCK
3821 BOOST_CHECK(thread_state.test(5)); // DOWN_THREAD_LOCK
3823 test_obj.test_call(UP_THREAD_ACTIVE,false);
3824 BOOST_CHECK(!thread_state.test(0)); // UP_THREAD_ALIVE
3825 BOOST_CHECK(!thread_state.test(1)); // DOWN_THREAD_ALIVE
3826 BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
3827 BOOST_CHECK(thread_state.test(3)); // DOWN_THREAD_ACTIVE
3828 BOOST_CHECK(thread_state.test(4)); // UP_THREAD_LOCK
3829 BOOST_CHECK(thread_state.test(5)); // DOWN_THREAD_LOCK
3831 test_obj.test_call(DOWN_THREAD_ACTIVE,false);
3832 BOOST_CHECK(!thread_state.test(0)); // UP_THREAD_ALIVE
3833 BOOST_CHECK(!thread_state.test(1)); // DOWN_THREAD_ALIVE
3834 BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
3835 BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
3836 BOOST_CHECK(thread_state.test(4)); // UP_THREAD_LOCK
3837 BOOST_CHECK(thread_state.test(5)); // DOWN_THREAD_LOCK
3839 test_obj.test_call(UP_THREAD_LOCK,false);
3840 BOOST_CHECK(!thread_state.test(0)); // UP_THREAD_ALIVE
3841 BOOST_CHECK(!thread_state.test(1)); // DOWN_THREAD_ALIVE
3842 BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
3843 BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
3844 BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
3845 BOOST_CHECK(thread_state.test(5)); // DOWN_THREAD_LOCK
3847 test_obj.test_call(DOWN_THREAD_LOCK,false);
3848 BOOST_CHECK(!thread_state.test(0)); // UP_THREAD_ALIVE
3849 BOOST_CHECK(!thread_state.test(1)); // DOWN_THREAD_ALIVE
3850 BOOST_CHECK(!thread_state.test(2)); // UP_THREAD_ACTIVE
3851 BOOST_CHECK(!thread_state.test(3)); // DOWN_THREAD_ACTIVE
3852 BOOST_CHECK(!thread_state.test(4)); // UP_THREAD_LOCK
3853 BOOST_CHECK(!thread_state.test(5)); // DOWN_THREAD_LOCK
3855 boost::thread::id proc_id = boost::this_thread::get_id();
3856 // mutex_lock_test test_lock_obj(vs,io);
3857 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);
3859 test_lock_obj.set_thread_state_update_test();
3861 test_lock_obj.test_thread_wait.lock();
3862 test_lock_obj.befor_thread_id = proc_id;
3863 test_lock_obj.after_thread_id = proc_id;
3864 test_lock_obj.mutex_lock();
3866 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
3868 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
3869 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
3871 boost::thread::id test_id = test_thread.get_id();
3872 BOOST_CHECK(test_id != proc_id);
3875 test_lock_obj.test_thread_wait.unlock();
3878 // unit_test [3] thread_state_update thread block test (mutex lock)
3879 std::cout << "[3] thread_state_update thread block test (mutex lock)" << std::endl;
3880 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
3881 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
3883 test_lock_obj.mutex_unlock();
3886 // unit_test [4] thread_state_update thread run test (mutex unlock)
3887 std::cout << "[4] thread_state_update thread run test (mutex unlock)" << std::endl;
3888 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
3889 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
3891 BOOST_MESSAGE( "----- thread_state_update test end -----" );
3897 // up_thread_exit test
3898 // up_thread_exit test class
3899 class up_thread_exit_test_class : public l7vs::tcp_session{
3901 // up_thread_exit_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){};
3902 up_thread_exit_test_class(
3903 l7vs::virtualservice_tcp& vs,
3904 boost::asio::io_service& session_io,
3905 l7vs::tcp_socket_option_info& set_socket_option,
3906 boost::asio::ip::tcp::endpoint listen_endpoint,
3908 boost::asio::ssl::context& set_ssl_context,
3909 bool set_ssl_cache_flag,
3910 int set_ssl_handshake_time_out,
3911 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
3918 set_ssl_handshake_time_out,
3919 set_access_logger){};
3920 ~up_thread_exit_test_class(){};
3921 bool& get_exit_flag(){
3925 l7vs::tcp_session::up_thread_exit(LOCAL_PROC);
3928 void up_thread_exit_test(){
3930 BOOST_MESSAGE( "----- up_thread_exit test start -----" );
3932 // boost::asio::io_service io;
3933 // l7vs::virtualservice_tcp vs;
3934 // up_thread_exit_test_class test_obj(vs,io);
3935 l7vs::virtualservice_tcp vs;
3936 boost::asio::io_service io;
3937 l7vs::tcp_socket_option_info set_option;
3938 //! TCP_NODELAY (false:not set,true:set option)
3939 set_option.nodelay_opt = false;
3940 //! TCP_NODELAY option value (false:off,true:on)
3941 set_option.nodelay_val = false;
3942 //! TCP_CORK (false:not set,true:set option)
3943 set_option.cork_opt = false;
3944 //! TCP_CORK option value (false:off,true:on)
3945 set_option.cork_val = false;
3946 //! TCP_QUICKACK (false:not set,true:set option)
3947 set_option.quickack_opt = false;
3948 //! TCP_QUICKACK option value (false:off,true:on)
3949 set_option.quickack_val = false;
3951 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
3952 bool set_mode(false);
3953 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
3954 bool set_ssl_cache_flag(false);
3955 int set_ssl_handshake_time_out = 0;
3956 //std::string access_log_file_name = "test";
3957 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
3959 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);
3961 // unit_test [1] up_thread_exit update exit_flag
3962 std::cout << "[1] up_thread_exit update exit_flag" << std::endl;
3965 bool& ref_exit_flag = test_obj.get_exit_flag();
3967 ref_exit_flag = false;
3969 test_obj.test_call();
3971 BOOST_CHECK(ref_exit_flag);
3974 // mutex_lock_test test_lock_obj(vs,io);
3975 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);
3977 test_lock_obj.set_up_thread_exit_test();
3980 test_lock_obj.test_thread_wait.lock();
3981 boost::thread::id proc_id = boost::this_thread::get_id();
3982 test_lock_obj.befor_thread_id = proc_id;
3983 test_lock_obj.after_thread_id = proc_id;
3984 test_lock_obj.mutex_lock();
3986 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
3988 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
3989 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
3991 boost::thread::id test_id = test_thread.get_id();
3993 BOOST_CHECK(test_id != proc_id);
3996 test_lock_obj.test_thread_wait.unlock();
3999 // unit_test [2] up_thread_exit thread block test (mutex lock)
4000 std::cout << "[2] up_thread_exit thread block test (mutex lock)" << std::endl;
4001 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
4002 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
4004 test_lock_obj.mutex_unlock();
4007 // unit_test [3] up_thread_exit thread run test (mutex unlock)
4008 std::cout << "[3] up_thread_exit thread run test (mutex unlock)" << std::endl;
4009 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
4010 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
4013 // // unit_test [4] up_thread_exit thread run after mutex unlock test
4014 // std::cout << "[4] up_thread_exit thread run after mutex unlock test" << std::endl;
4015 // BOOST_CHECK(test_lock_obj.mutex_trylock());
4016 // test_lock_obj.mutex_unlock();
4018 BOOST_MESSAGE( "----- up_thread_exit test end -----" );
4021 // down_thread_exit test
4022 // down_thread_exit test class
4023 class down_thread_exit_test_class : public l7vs::tcp_session{
4025 // down_thread_exit_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){};
4026 down_thread_exit_test_class(
4027 l7vs::virtualservice_tcp& vs,
4028 boost::asio::io_service& session_io,
4029 l7vs::tcp_socket_option_info& set_socket_option,
4030 boost::asio::ip::tcp::endpoint listen_endpoint,
4032 boost::asio::ssl::context& set_ssl_context,
4033 bool set_ssl_cache_flag,
4034 int set_ssl_handshake_time_out,
4035 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
4042 set_ssl_handshake_time_out,
4043 set_access_logger){};
4045 ~down_thread_exit_test_class(){};
4046 bool& get_exit_flag(){
4050 l7vs::tcp_session::down_thread_exit(LOCAL_PROC);
4053 void down_thread_exit_test(){
4055 BOOST_MESSAGE( "----- down_thread_exit test start -----" );
4057 // boost::asio::io_service io;
4058 // l7vs::virtualservice_tcp vs;
4059 // down_thread_exit_test_class test_obj(vs,io);
4060 l7vs::virtualservice_tcp vs;
4061 boost::asio::io_service io;
4062 l7vs::tcp_socket_option_info set_option;
4063 //! TCP_NODELAY (false:not set,true:set option)
4064 set_option.nodelay_opt = false;
4065 //! TCP_NODELAY option value (false:off,true:on)
4066 set_option.nodelay_val = false;
4067 //! TCP_CORK (false:not set,true:set option)
4068 set_option.cork_opt = false;
4069 //! TCP_CORK option value (false:off,true:on)
4070 set_option.cork_val = false;
4071 //! TCP_QUICKACK (false:not set,true:set option)
4072 set_option.quickack_opt = false;
4073 //! TCP_QUICKACK option value (false:off,true:on)
4074 set_option.quickack_val = false;
4076 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
4077 bool set_mode(false);
4078 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
4079 bool set_ssl_cache_flag(false);
4080 int set_ssl_handshake_time_out = 0;
4081 //std::string access_log_file_name = "test";
4082 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
4084 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);
4086 // unit_test [1] down_thread_exit update exit_flag
4087 std::cout << "[1] down_thread_exit update exit_flag" << std::endl;
4090 bool& ref_exit_flag = test_obj.get_exit_flag();
4092 ref_exit_flag = false;
4094 test_obj.test_call();
4096 BOOST_CHECK(ref_exit_flag);
4099 // mutex_lock_test test_lock_obj(vs,io);
4100 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);
4101 test_lock_obj.set_down_thread_exit_test();
4104 test_lock_obj.test_thread_wait.lock();
4105 boost::thread::id proc_id = boost::this_thread::get_id();
4106 test_lock_obj.befor_thread_id = proc_id;
4107 test_lock_obj.after_thread_id = proc_id;
4108 test_lock_obj.mutex_lock();
4110 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
4112 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
4113 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
4115 boost::thread::id test_id = test_thread.get_id();
4117 BOOST_CHECK(test_id != proc_id);
4120 test_lock_obj.test_thread_wait.unlock();
4123 // unit_test [2] down_thread_exit thread block test (mutex lock)
4124 std::cout << "[2] down_thread_exit thread block test (mutex lock)" << std::endl;
4125 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
4126 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
4128 test_lock_obj.mutex_unlock();
4131 // unit_test [3] down_thread_exit thread run test (mutex unlock)
4132 std::cout << "[3] down_thread_exit thread run test (mutex unlock)" << std::endl;
4133 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
4134 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
4137 // // unit_test [4] down_thread_exit thread run after mutex unlock test
4138 // std::cout << "[4] down_thread_exit thread run after mutex unlock test" << std::endl;
4139 // BOOST_CHECK(test_lock_obj.mutex_trylock());
4140 // test_lock_obj.mutex_unlock();
4144 BOOST_MESSAGE( "----- down_thread_exit test end -----" );
4148 // up_thread_client_disconnect_event test
4149 // up_thread_client_disconnect_event test class
4150 class up_thread_client_disconnect_event_test_class : public module_event_map_test_base_class{
4152 // 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){
4154 up_thread_client_disconnect_event_test_class(
4155 l7vs::virtualservice_tcp& vs,
4156 boost::asio::io_service& session_io,
4157 l7vs::tcp_socket_option_info& set_socket_option,
4158 boost::asio::ip::tcp::endpoint listen_endpoint,
4160 boost::asio::ssl::context& set_ssl_context,
4161 bool set_ssl_cache_flag,
4162 int set_ssl_handshake_time_out,
4163 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
4170 set_ssl_handshake_time_out,
4171 set_access_logger){};
4173 ~up_thread_client_disconnect_event_test_class(){};
4176 l7vs::tcp_session::up_thread_client_disconnect_event(LOCAL_PROC);
4180 void up_thread_client_disconnect_event_test(){
4182 BOOST_MESSAGE( "----- up_thread_client_disconnect_event test start -----" );
4184 // boost::asio::io_service io;
4185 // l7vs::virtualservice_tcp vs;
4186 // up_thread_client_disconnect_event_test_class test_obj(vs,io);
4187 l7vs::virtualservice_tcp vs;
4188 boost::asio::io_service io;
4189 l7vs::tcp_socket_option_info set_option;
4190 //! TCP_NODELAY (false:not set,true:set option)
4191 set_option.nodelay_opt = false;
4192 //! TCP_NODELAY option value (false:off,true:on)
4193 set_option.nodelay_val = false;
4194 //! TCP_CORK (false:not set,true:set option)
4195 set_option.cork_opt = false;
4196 //! TCP_CORK option value (false:off,true:on)
4197 set_option.cork_val = false;
4198 //! TCP_QUICKACK (false:not set,true:set option)
4199 set_option.quickack_opt = false;
4200 //! TCP_QUICKACK option value (false:off,true:on)
4201 set_option.quickack_val = false;
4203 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
4204 bool set_mode(false);
4205 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
4206 bool set_ssl_cache_flag(false);
4207 int set_ssl_handshake_time_out = 0;
4208 //std::string access_log_file_name = "test";
4209 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
4211 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);
4213 std::string test_protocol_name("test protocol");
4214 l7vs::test_protocol_module proto_test(test_protocol_name);
4216 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
4218 l7vs::protocol_module_base::EVENT_TAG chek_event[13];
4219 chek_event[0] = l7vs::protocol_module_base::ACCEPT;
4220 chek_event[1] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
4221 chek_event[2] = l7vs::protocol_module_base::CLIENT_RECV;
4222 chek_event[3] = l7vs::protocol_module_base::CLIENT_RESPONSE_SEND;
4223 chek_event[4] = l7vs::protocol_module_base::REALSERVER_SELECT;
4224 chek_event[5] = l7vs::protocol_module_base::REALSERVER_CONNECT;
4225 chek_event[6] = l7vs::protocol_module_base::REALSERVER_SEND;
4226 chek_event[7] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
4227 chek_event[8] = l7vs::protocol_module_base::SORRYSERVER_SELECT;
4228 chek_event[9] = l7vs::protocol_module_base::SORRYSERVER_CONNECT;
4229 chek_event[10] = l7vs::protocol_module_base::SORRYSERVER_SEND;
4230 chek_event[11] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
4231 chek_event[12] = l7vs::protocol_module_base::FINALIZE;
4233 // unit_test [1] up_thread_client_disconnect_event up_thread_next_call_function update check
4234 std::cout << "[1] up_thread_client_disconnect_event up_thread_next_call_function update check" << std::endl;
4235 for(int i = 0; i < 13;i++){
4236 proto_test.handle_client_disconnect_res_tag = chek_event[i];
4237 test_obj.test_call();
4238 BOOST_CHECK(test_obj.chk_up_thread_next_call_function(chek_event[i]));
4241 // unit_test [2] up_thread_client_disconnect_event module parameter check thread id
4242 std::cout << "[2] up_thread_client_disconnect_event module parameter check thread id" << std::endl;
4243 boost::thread::id def_id;
4244 boost::thread::id proc_id = boost::this_thread::get_id();
4245 test_obj.set_up_thread_id(proc_id);
4246 proto_test.handle_client_disconnect_thread_id = def_id;
4247 proto_test.handle_client_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
4248 BOOST_CHECK(proto_test.handle_client_disconnect_thread_id != proc_id);
4249 test_obj.test_call();
4250 BOOST_CHECK(proto_test.handle_client_disconnect_thread_id == proc_id);
4252 // unit_test [3] up_thread_client_disconnect_event not fond function error check
4253 std::cout << "[3] up_thread_client_disconnect_event not fond function error check" << std::endl;
4254 test_obj.up_thread_function_array_clear();
4255 proto_test.handle_client_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
4256 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
4257 l7vs::Logger::putLogError_id = 0;
4258 test_obj.test_call();
4259 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
4260 BOOST_CHECK_EQUAL(29,l7vs::Logger::putLogError_id);
4261 std::cout << l7vs::Logger::putLogError_message << std::endl;
4263 // unit_test [4] up_thread_client_disconnect_event returnd illegal EVENT_TAG error check
4264 std::cout << "[4] up_thread_client_disconnect_event returnd illegal EVENT_TAG error check" << std::endl;
4265 test_obj.up_thread_module_event_map_clear();
4266 proto_test.handle_client_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
4267 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
4268 l7vs::Logger::putLogError_id = 0;
4269 test_obj.test_call();
4270 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
4271 BOOST_CHECK_EQUAL(28,l7vs::Logger::putLogError_id);
4272 std::cout << l7vs::Logger::putLogError_message << std::endl;
4274 // mutex_lock_test test_lock_obj(vs,io);
4275 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);
4277 test_lock_obj.set_up_thread_client_disconnect_event_test();
4278 test_lock_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
4281 test_lock_obj.test_thread_wait.lock();
4282 test_lock_obj.befor_thread_id = proc_id;
4283 test_lock_obj.after_thread_id = proc_id;
4284 test_lock_obj.mutex_lock();
4286 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
4288 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
4289 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
4291 boost::thread::id test_id = test_thread.get_id();
4293 BOOST_CHECK(test_id != proc_id);
4296 test_lock_obj.test_thread_wait.unlock();
4299 // unit_test [5] up_thread_client_disconnect_event thread block test (mutex lock)
4300 std::cout << "[5] up_thread_client_disconnect_event thread block test (mutex lock)" << std::endl;
4301 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
4302 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
4304 test_lock_obj.mutex_unlock();
4307 // unit_test [6] up_thread_client_disconnect_event thread run test (mutex unlock)
4308 std::cout << "[6] up_thread_client_disconnect_event thread run test (mutex unlock)" << std::endl;
4309 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
4310 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
4312 BOOST_MESSAGE( "----- up_thread_client_disconnect_event test end -----" );
4315 // down_thread_client_disconnetc_event test
4316 // dwon_thread_client_disconnetc_event test class
4317 class down_thread_client_disconnect_event_test_class : public module_event_map_test_base_class{
4319 // 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){
4321 down_thread_client_disconnect_event_test_class(
4322 l7vs::virtualservice_tcp& vs,
4323 boost::asio::io_service& session_io,
4324 l7vs::tcp_socket_option_info& set_socket_option,
4325 boost::asio::ip::tcp::endpoint listen_endpoint,
4327 boost::asio::ssl::context& set_ssl_context,
4328 bool set_ssl_cache_flag,
4329 int set_ssl_handshake_time_out,
4330 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
4337 set_ssl_handshake_time_out,
4338 set_access_logger){};
4340 ~down_thread_client_disconnect_event_test_class(){};
4343 l7vs::tcp_session::down_thread_client_disconnect_event(LOCAL_PROC);
4347 void down_thread_client_disconnect_event_test(){
4349 BOOST_MESSAGE( "----- down_thread_client_disconnect_event test start -----" );
4351 // boost::asio::io_service io;
4352 // l7vs::virtualservice_tcp vs;
4353 // down_thread_client_disconnect_event_test_class test_obj(vs,io);
4354 l7vs::virtualservice_tcp vs;
4355 boost::asio::io_service io;
4356 l7vs::tcp_socket_option_info set_option;
4357 //! TCP_NODELAY (false:not set,true:set option)
4358 set_option.nodelay_opt = false;
4359 //! TCP_NODELAY option value (false:off,true:on)
4360 set_option.nodelay_val = false;
4361 //! TCP_CORK (false:not set,true:set option)
4362 set_option.cork_opt = false;
4363 //! TCP_CORK option value (false:off,true:on)
4364 set_option.cork_val = false;
4365 //! TCP_QUICKACK (false:not set,true:set option)
4366 set_option.quickack_opt = false;
4367 //! TCP_QUICKACK option value (false:off,true:on)
4368 set_option.quickack_val = false;
4370 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
4371 bool set_mode(false);
4372 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
4373 bool set_ssl_cache_flag(false);
4374 int set_ssl_handshake_time_out = 0;
4375 //std::string access_log_file_name = "test";
4376 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
4378 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);
4380 std::string test_protocol_name("test protocol");
4381 l7vs::test_protocol_module proto_test(test_protocol_name);
4383 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
4385 l7vs::protocol_module_base::EVENT_TAG chek_event[7];
4386 chek_event[0] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
4387 chek_event[1] = l7vs::protocol_module_base::CLIENT_CONNECTION_CHECK;
4388 chek_event[2] = l7vs::protocol_module_base::REALSERVER_RECV;
4389 chek_event[3] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
4390 chek_event[4] = l7vs::protocol_module_base::SORRYSERVER_RECV;
4391 chek_event[5] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
4392 chek_event[6] = l7vs::protocol_module_base::FINALIZE;
4394 // unit_test [1] down_thread_client_disconnect_event up_thread_next_call_function update check
4395 std::cout << "[1] down_thread_client_disconnect_event up_thread_next_call_function update check" << std::endl;
4396 for(int i = 0; i < 7;i++){
4397 proto_test.handle_client_disconnect_res_tag = chek_event[i];
4398 test_obj.test_call();
4399 BOOST_CHECK(test_obj.chk_down_thread_next_call_function(chek_event[i]));
4402 // unit_test [2] down_thread_client_disconnect_event module parameter check thread id
4403 std::cout << "[2] down_thread_client_disconnect_event module parameter check thread id" << std::endl;
4404 boost::thread::id def_id;
4405 boost::thread::id proc_id = boost::this_thread::get_id();
4406 test_obj.set_down_thread_id(proc_id);
4407 proto_test.handle_client_disconnect_thread_id = def_id;
4408 proto_test.handle_client_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
4409 BOOST_CHECK(proto_test.handle_client_disconnect_thread_id != proc_id);
4410 test_obj.test_call();
4411 BOOST_CHECK(proto_test.handle_client_disconnect_thread_id == proc_id);
4413 // unit_test [3] down_thread_client_disconnect_event not fond function error check
4414 std::cout << "[3] down_thread_client_disconnect_event not fond function error check" << std::endl;
4415 test_obj.down_thread_function_array_clear();
4416 proto_test.handle_client_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
4417 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
4418 l7vs::Logger::putLogError_id = 0;
4419 test_obj.test_call();
4420 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
4421 BOOST_CHECK_EQUAL(87,l7vs::Logger::putLogError_id);
4422 std::cout << l7vs::Logger::putLogError_message << std::endl;
4424 // unit_test [4] down_thread_client_disconnect_event returnd illegal EVENT_TAG error check
4425 std::cout << "[4] down_thread_client_disconnect_event returnd illegal EVENT_TAG error check" << std::endl;
4426 test_obj.down_thread_module_event_map_clear();
4427 proto_test.handle_client_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
4428 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
4429 l7vs::Logger::putLogError_id = 0;
4430 test_obj.test_call();
4431 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
4432 BOOST_CHECK_EQUAL(86,l7vs::Logger::putLogError_id);
4433 std::cout << l7vs::Logger::putLogError_message << std::endl;
4435 // mutex_lock_test test_lock_obj(vs,io);
4436 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);
4438 test_lock_obj.set_down_thread_client_disconnect_event_test();
4439 test_lock_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
4441 test_lock_obj.test_thread_wait.lock();
4442 test_lock_obj.befor_thread_id = proc_id;
4443 test_lock_obj.after_thread_id = proc_id;
4444 test_lock_obj.mutex_lock();
4446 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
4448 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
4449 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
4451 boost::thread::id test_id = test_thread.get_id();
4453 BOOST_CHECK(test_id != proc_id);
4456 test_lock_obj.test_thread_wait.unlock();
4459 // unit_test [5] down_thread_client_disconnect_event thread block test (mutex lock)
4460 std::cout << "[5] down_thread_client_disconnect_event thread block test (mutex lock)" << std::endl;
4461 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
4462 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
4464 test_lock_obj.mutex_unlock();
4467 // unit_test [6] down_thread_client_disconnect_event thread run test (mutex unlock)
4468 std::cout << "[6] down_thread_client_disconnect_event thread run test (mutex unlock)" << std::endl;
4469 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
4470 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
4472 BOOST_MESSAGE( "----- down_thread_client_disconnect_event test end -----" );
4475 // up_thread_realserver_get_detination_event test
4476 // up_thread_realserver_get_detination_event test class
4477 class up_thread_realserver_get_detination_event_test_class : public l7vs::tcp_session{
4479 // up_thread_realserver_get_detination_event_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){
4481 up_thread_realserver_get_detination_event_test_class(
4482 l7vs::virtualservice_tcp& vs,
4483 boost::asio::io_service& session_io,
4484 l7vs::tcp_socket_option_info& set_socket_option,
4485 boost::asio::ip::tcp::endpoint listen_endpoint,
4487 boost::asio::ssl::context& set_ssl_context,
4488 bool set_ssl_cache_flag,
4489 int set_ssl_handshake_time_out,
4490 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
4497 set_ssl_handshake_time_out,
4498 set_access_logger){};
4500 ~up_thread_realserver_get_detination_event_test_class(){};
4503 tcp_session::up_thread_realserver_get_destination_event(LOCAL_PROC);
4506 l7vs::tcp_data& get_up_thread_data_dest_side(){
4507 return up_thread_data_dest_side;
4510 up_thread_next_call_function.second(LOCAL_PROC);
4513 void up_thread_realserver_connect(const TCP_PROCESS_TYPE_TAG process_type){
4514 up_thread_realserver_connect_call_check = true;
4517 bool up_thread_realserver_connect_call_check;
4519 void set_protocol_module(l7vs::protocol_module_base* set_proto){
4520 protocol_module = set_proto;
4523 void set_up_thread_id(boost::thread::id set_id){
4524 up_thread_id = set_id;
4527 void up_thread_function_array_clear(){
4528 for(int i = 0; i <= UP_FUNC_EXIT;i++){
4529 up_thread_function_array[i].second = NULL;
4532 void up_thread_module_event_map_clear(){
4533 up_thread_module_event_map.clear();
4536 void up_thread_realserver_get_detination_event_test(){
4537 BOOST_MESSAGE( "----- up_thread_realserver_get_detination_event test start -----" );
4539 // boost::asio::io_service io;
4540 // l7vs::virtualservice_tcp vs;
4541 // up_thread_realserver_get_detination_event_test_class test_obj(vs,io);
4542 l7vs::virtualservice_tcp vs;
4543 boost::asio::io_service io;
4544 l7vs::tcp_socket_option_info set_option;
4545 //! TCP_NODELAY (false:not set,true:set option)
4546 set_option.nodelay_opt = false;
4547 //! TCP_NODELAY option value (false:off,true:on)
4548 set_option.nodelay_val = false;
4549 //! TCP_CORK (false:not set,true:set option)
4550 set_option.cork_opt = false;
4551 //! TCP_CORK option value (false:off,true:on)
4552 set_option.cork_val = false;
4553 //! TCP_QUICKACK (false:not set,true:set option)
4554 set_option.quickack_opt = false;
4555 //! TCP_QUICKACK option value (false:off,true:on)
4556 set_option.quickack_val = false;
4558 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
4559 bool set_mode(false);
4560 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
4561 bool set_ssl_cache_flag(false);
4562 int set_ssl_handshake_time_out = 0;
4563 //std::string access_log_file_name = "test";
4564 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
4566 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);
4569 std::string test_protocol_name("test protocol");
4570 l7vs::test_protocol_module proto_test(test_protocol_name);
4571 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
4572 l7vs::tcp_data& up_thread_data_dest_side = test_obj.get_up_thread_data_dest_side();
4573 boost::thread::id proc_id = boost::this_thread::get_id();
4574 test_obj.set_up_thread_id(proc_id);
4576 proto_test.handle_realserver_select_tcp_res_tag = l7vs::protocol_module_base::REALSERVER_CONNECT;
4577 proto_test.handle_realserver_select_out_rs_endpoint = boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string("100.101.102.103"), 7777);
4578 up_thread_data_dest_side.initialize();
4579 BOOST_CHECK(proto_test.handle_realserver_select_in_thread_id != proc_id);
4581 test_obj.test_call();
4583 // unit_test [1] up_thread_realserver_get_detination_event handle_realserver_select call check
4584 std::cout << "[1] up_thread_realserver_get_detination_event handle_realserver_select call check" << std::endl;
4585 BOOST_CHECK(proto_test.handle_realserver_select_in_thread_id == proc_id);
4586 boost::asio::ip::tcp::endpoint get_endpoint = up_thread_data_dest_side.get_endpoint();
4587 BOOST_CHECK(get_endpoint == proto_test.handle_realserver_select_out_rs_endpoint);
4589 // unit_test [2] up_thread_realserver_get_detination_event up_thread_next_call_function update check
4590 std::cout << "[2] up_thread_realserver_get_detination_event up_thread_next_call_function update check" << std::endl;
4591 test_obj.up_thread_realserver_connect_call_check = false;
4592 test_obj.next_call();
4593 BOOST_CHECK(test_obj.up_thread_realserver_connect_call_check);
4595 // unit_test [3] up_thread_realserver_get_detination_event not fond function error check
4596 std::cout << "[3] up_thread_realserver_get_detination_event not fond function error check" << std::endl;
4597 test_obj.up_thread_function_array_clear();
4598 proto_test.handle_realserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
4599 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
4600 l7vs::Logger::putLogError_id = 0;
4601 test_obj.test_call();
4602 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
4603 BOOST_CHECK_EQUAL(33,l7vs::Logger::putLogError_id);
4604 std::cout << l7vs::Logger::putLogError_message << std::endl;
4606 // unit_test [4] up_thread_realserver_get_detination_event returnd illegal EVENT_TAG error check
4607 std::cout << "[4] up_thread_realserver_get_detination_event returnd illegal EVENT_TAG error check" << std::endl;
4608 test_obj.up_thread_module_event_map_clear();
4609 proto_test.handle_realserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
4610 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
4611 l7vs::Logger::putLogError_id = 0;
4612 test_obj.test_call();
4613 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
4614 BOOST_CHECK_EQUAL(32,l7vs::Logger::putLogError_id);
4615 std::cout << l7vs::Logger::putLogError_message << std::endl;
4617 BOOST_MESSAGE( "----- up_thread_realserver_get_detination_event test end -----" );
4619 // up_thread_sorryserver_get_detination_event test
4620 // up_thread_sorryserver_get_detination_event test class
4621 class up_thread_sorryserver_get_detination_event_test_class : public l7vs::tcp_session{
4623 // up_thread_sorryserver_get_detination_event_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){
4625 up_thread_sorryserver_get_detination_event_test_class(
4626 l7vs::virtualservice_tcp& vs,
4627 boost::asio::io_service& session_io,
4628 l7vs::tcp_socket_option_info& set_socket_option,
4629 boost::asio::ip::tcp::endpoint listen_endpoint,
4631 boost::asio::ssl::context& set_ssl_context,
4632 bool set_ssl_cache_flag,
4633 int set_ssl_handshake_time_out,
4634 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
4641 set_ssl_handshake_time_out,
4642 set_access_logger){};
4644 ~up_thread_sorryserver_get_detination_event_test_class(){};
4647 tcp_session::up_thread_sorryserver_get_destination_event(LOCAL_PROC);
4650 l7vs::tcp_data& get_up_thread_data_dest_side(){
4651 return up_thread_data_dest_side;
4654 up_thread_next_call_function.second(LOCAL_PROC);
4657 void up_thread_sorryserver_connect(const TCP_PROCESS_TYPE_TAG process_type){
4658 up_thread_sorryserver_connect_call_check = true;
4661 bool up_thread_sorryserver_connect_call_check;
4663 void set_protocol_module(l7vs::protocol_module_base* set_proto){
4664 protocol_module = set_proto;
4667 void set_up_thread_id(boost::thread::id set_id){
4668 up_thread_id = set_id;
4671 void up_thread_function_array_clear(){
4672 for(int i = 0; i <= UP_FUNC_EXIT; i++){
4673 up_thread_function_array[i].second = NULL;
4676 void up_thread_module_event_map_clear(){
4677 up_thread_module_event_map.clear();
4680 void up_thread_sorryserver_get_detination_event_test(){
4681 BOOST_MESSAGE( "----- up_thread_sorryserver_get_detination_event test start -----" );
4683 // boost::asio::io_service io;
4684 // l7vs::virtualservice_tcp vs;
4685 // up_thread_sorryserver_get_detination_event_test_class test_obj(vs,io);
4686 l7vs::virtualservice_tcp vs;
4687 boost::asio::io_service io;
4688 l7vs::tcp_socket_option_info set_option;
4689 //! TCP_NODELAY (false:not set,true:set option)
4690 set_option.nodelay_opt = false;
4691 //! TCP_NODELAY option value (false:off,true:on)
4692 set_option.nodelay_val = false;
4693 //! TCP_CORK (false:not set,true:set option)
4694 set_option.cork_opt = false;
4695 //! TCP_CORK option value (false:off,true:on)
4696 set_option.cork_val = false;
4697 //! TCP_QUICKACK (false:not set,true:set option)
4698 set_option.quickack_opt = false;
4699 //! TCP_QUICKACK option value (false:off,true:on)
4700 set_option.quickack_val = false;
4702 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
4703 bool set_mode(false);
4704 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
4705 bool set_ssl_cache_flag(false);
4706 int set_ssl_handshake_time_out = 0;
4707 //std::string access_log_file_name = "test";
4708 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
4710 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);
4712 std::string test_protocol_name("test protocol");
4713 l7vs::test_protocol_module proto_test(test_protocol_name);
4714 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
4715 l7vs::tcp_data& up_thread_data_dest_side = test_obj.get_up_thread_data_dest_side();
4716 boost::thread::id proc_id = boost::this_thread::get_id();
4717 test_obj.set_up_thread_id(proc_id);
4719 proto_test.handle_sorryserver_select_res_tag = l7vs::protocol_module_base::SORRYSERVER_CONNECT;
4720 proto_test.handle_sorryserver_select_out_sorry_endpoint = boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string("100.101.102.103"), 7777);
4721 vs.my_element.sorry_endpoint = boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string("200.201.202.203"), 8888);
4723 up_thread_data_dest_side.initialize();
4724 BOOST_CHECK(proto_test.handle_sorryserver_select_in_thread_id != proc_id);
4726 test_obj.test_call();
4728 // unit_test [1] up_thread_sorryserver_get_detination_event handle_realserver_select call check
4729 std::cout << "[1] up_thread_sorryserver_get_detination_event handle_realserver_select call check" << std::endl;
4730 BOOST_CHECK(proto_test.handle_sorryserver_select_in_thread_id == proc_id);
4731 boost::asio::ip::tcp::endpoint get_endpoint = up_thread_data_dest_side.get_endpoint();
4732 BOOST_CHECK(get_endpoint == proto_test.handle_sorryserver_select_out_sorry_endpoint);
4733 BOOST_CHECK(vs.my_element.sorry_endpoint == proto_test.handle_sorryserver_select_in_sorry_endpoint);
4735 // unit_test [2] up_thread_sorryserver_get_detination_event up_thread_next_call_function update check
4736 std::cout << "[2] up_thread_sorryserver_get_detination_event up_thread_next_call_function update check" << std::endl;
4737 test_obj.up_thread_sorryserver_connect_call_check = false;
4738 test_obj.next_call();
4739 BOOST_CHECK(test_obj.up_thread_sorryserver_connect_call_check);
4741 // unit_test [3] up_thread_sorryserver_get_detination_event not fond function error check
4742 std::cout << "[3] up_thread_sorryserver_get_detination_event not fond function error check" << std::endl;
4743 test_obj.up_thread_function_array_clear();
4744 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
4745 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
4746 l7vs::Logger::putLogError_id = 0;
4747 test_obj.test_call();
4748 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
4749 BOOST_CHECK_EQUAL(52,l7vs::Logger::putLogError_id);
4750 std::cout << l7vs::Logger::putLogError_message << std::endl;
4752 // unit_test [4] up_thread_sorryserver_get_detination_event returnd illegal EVENT_TAG error check
4753 std::cout << "[4] up_thread_sorryserver_get_detination_event returnd illegal EVENT_TAG error check" << std::endl;
4754 test_obj.up_thread_module_event_map_clear();
4755 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
4756 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
4757 l7vs::Logger::putLogError_id = 0;
4758 test_obj.test_call();
4759 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
4760 BOOST_CHECK_EQUAL(51,l7vs::Logger::putLogError_id);
4761 std::cout << l7vs::Logger::putLogError_message << std::endl;
4763 BOOST_MESSAGE( "----- up_thread_sorryserver_get_detination_event test end -----" );
4767 // up_thread_realserver_disconnect_event test
4768 // up_thread_realserver_disconnect_event test class
4769 class up_thread_realserver_disconnect_event_test_class : public module_event_map_test_base_class{
4771 // 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){
4773 up_thread_realserver_disconnect_event_test_class(
4774 l7vs::virtualservice_tcp& vs,
4775 boost::asio::io_service& session_io,
4776 l7vs::tcp_socket_option_info& set_socket_option,
4777 boost::asio::ip::tcp::endpoint listen_endpoint,
4779 boost::asio::ssl::context& set_ssl_context,
4780 bool set_ssl_cache_flag,
4781 int set_ssl_handshake_time_out,
4782 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
4789 set_ssl_handshake_time_out,
4790 set_access_logger){};
4793 ~up_thread_realserver_disconnect_event_test_class(){};
4796 l7vs::tcp_session::up_thread_realserver_disconnect_event(LOCAL_PROC);
4799 std::map<endpoint,tcp_socket_ptr>& get_realserver_socket_map(){
4800 return up_thread_send_realserver_socket_map;
4804 void up_thread_realserver_disconnect_event_test(){
4806 BOOST_MESSAGE( "----- up_thread_realserver_disconnect_event test start -----" );
4808 boost::asio::io_service io;
4809 l7vs::virtualservice_tcp vs;
4810 // up_thread_realserver_disconnect_event_test_class test_obj(vs,io);
4811 l7vs::tcp_socket_option_info set_option;
4812 //! TCP_NODELAY (false:not set,true:set option)
4813 set_option.nodelay_opt = false;
4814 //! TCP_NODELAY option value (false:off,true:on)
4815 set_option.nodelay_val = false;
4816 //! TCP_CORK (false:not set,true:set option)
4817 set_option.cork_opt = false;
4818 //! TCP_CORK option value (false:off,true:on)
4819 set_option.cork_val = false;
4820 //! TCP_QUICKACK (false:not set,true:set option)
4821 set_option.quickack_opt = false;
4822 //! TCP_QUICKACK option value (false:off,true:on)
4823 set_option.quickack_val = false;
4825 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
4826 bool set_mode(false);
4827 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
4828 bool set_ssl_cache_flag(false);
4829 int set_ssl_handshake_time_out = 0;
4830 //std::string access_log_file_name = "test";
4831 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
4833 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);
4838 std::string test_protocol_name("test protocol");
4839 l7vs::test_protocol_module proto_test(test_protocol_name);
4841 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
4843 l7vs::protocol_module_base::EVENT_TAG chek_event[13];
4844 chek_event[0] = l7vs::protocol_module_base::ACCEPT;
4845 chek_event[1] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
4846 chek_event[2] = l7vs::protocol_module_base::CLIENT_RECV;
4847 chek_event[3] = l7vs::protocol_module_base::CLIENT_RESPONSE_SEND;
4848 chek_event[4] = l7vs::protocol_module_base::REALSERVER_SELECT;
4849 chek_event[5] = l7vs::protocol_module_base::REALSERVER_CONNECT;
4850 chek_event[6] = l7vs::protocol_module_base::REALSERVER_SEND;
4851 chek_event[7] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
4852 chek_event[8] = l7vs::protocol_module_base::SORRYSERVER_SELECT;
4853 chek_event[9] = l7vs::protocol_module_base::SORRYSERVER_CONNECT;
4854 chek_event[10] = l7vs::protocol_module_base::SORRYSERVER_SEND;
4855 chek_event[11] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
4856 chek_event[12] = l7vs::protocol_module_base::FINALIZE;
4858 // unit_test [1] up_thread_realserver_disconnect_event up_thread_next_call_function update check
4859 std::cout << "[1] up_thread_realserver_disconnect_event up_thread_next_call_function update check" << std::endl;
4860 for(int i = 0; i < 13;i++){
4861 proto_test.handle_realserver_disconnect_res_tag = chek_event[i];
4862 test_obj.test_call();
4863 BOOST_CHECK(test_obj.chk_up_thread_next_call_function(chek_event[i]));
4866 // module parameter check
4867 boost::thread::id def_id;
4868 boost::thread::id proc_id = boost::this_thread::get_id();
4869 boost::asio::ip::tcp::endpoint test_end(boost::asio::ip::address::from_string("100.102.103.104"), 7777);
4870 l7vs::tcp_data test_message;
4871 test_message.set_endpoint(test_end);
4872 test_obj.set_up_thread_id(proc_id);
4873 test_obj.set_up_thread_message_data(test_message);
4874 proto_test.handle_realserver_disconnect_thread_id = def_id;
4875 proto_test.handle_realserver_disconnect_rs_endpoint = boost::asio::ip::tcp::endpoint();
4876 proto_test.handle_realserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
4877 BOOST_CHECK(proto_test.handle_realserver_disconnect_thread_id != proc_id);
4878 BOOST_CHECK(proto_test.handle_realserver_disconnect_rs_endpoint != test_end);
4879 test_obj.test_call();
4880 // unit_test [2] up_thread_realserver_disconnect_event module parameter check thread id
4881 std::cout << "[2] up_thread_realserver_disconnect_event module parameter check thread id" << std::endl;
4882 BOOST_CHECK(proto_test.handle_realserver_disconnect_thread_id == proc_id);
4884 // unit_test [3] up_thread_realserver_disconnect_event module parameter check endpoint
4885 std::cout << "[3] up_thread_realserver_disconnect_event module parameter check endpoint" << std::endl;
4886 BOOST_CHECK(proto_test.handle_realserver_disconnect_rs_endpoint == test_end);
4889 // unit_test [4] up_thread_realserver_disconnect_event realserver map erase check
4890 std::cout << "[4] up_thread_realserver_disconnect_event realserver map erase check" << std::endl;
4892 std::map<boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > >& realserver_map = test_obj.get_realserver_socket_map();
4893 boost::shared_ptr< l7vs::tcp_socket > test_tcp_sock0(new l7vs::tcp_socket(io));
4894 boost::shared_ptr< l7vs::tcp_socket > test_tcp_sock1(new l7vs::tcp_socket(io));
4895 boost::shared_ptr< l7vs::tcp_socket > test_tcp_sock2(new l7vs::tcp_socket(io));
4896 std::pair< boost::asio::ip::tcp::endpoint , boost::shared_ptr< l7vs::tcp_socket > > test_sock_list[3];
4897 test_sock_list[0].first = boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string("100.100.100.100"), 0);
4898 test_sock_list[0].second = test_tcp_sock0;
4899 test_sock_list[1].first = boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string("101.101.101.101"), 1);
4900 test_sock_list[1].second = test_tcp_sock1;
4901 test_sock_list[2].first = boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string("102.102.102.102"), 2);
4902 test_sock_list[2].second = test_tcp_sock2;
4903 for(int i = 0;i < 3;i++){
4904 realserver_map.insert(test_sock_list[i]);
4906 proto_test.handle_realserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
4909 test_message.set_endpoint(test_sock_list[1].first);
4910 test_obj.set_up_thread_message_data(test_message);
4911 BOOST_CHECK(realserver_map.find(test_sock_list[0].first) != realserver_map.end());
4912 BOOST_CHECK(realserver_map.find(test_sock_list[1].first) != realserver_map.end());
4913 BOOST_CHECK(realserver_map.find(test_sock_list[2].first) != realserver_map.end());
4914 test_obj.test_call();
4915 BOOST_CHECK(realserver_map.find(test_sock_list[0].first) != realserver_map.end());
4916 BOOST_CHECK(realserver_map.find(test_sock_list[1].first) == realserver_map.end());
4917 BOOST_CHECK(realserver_map.find(test_sock_list[2].first) != realserver_map.end());
4919 test_message.set_endpoint(test_sock_list[0].first);
4920 test_obj.set_up_thread_message_data(test_message);
4921 BOOST_CHECK(realserver_map.find(test_sock_list[0].first) != realserver_map.end());
4922 BOOST_CHECK(realserver_map.find(test_sock_list[1].first) == realserver_map.end());
4923 BOOST_CHECK(realserver_map.find(test_sock_list[2].first) != realserver_map.end());
4924 test_obj.test_call();
4925 BOOST_CHECK(realserver_map.find(test_sock_list[0].first) == realserver_map.end());
4926 BOOST_CHECK(realserver_map.find(test_sock_list[1].first) == realserver_map.end());
4927 BOOST_CHECK(realserver_map.find(test_sock_list[2].first) != realserver_map.end());
4929 test_message.set_endpoint(test_sock_list[2].first);
4930 test_obj.set_up_thread_message_data(test_message);
4931 BOOST_CHECK(realserver_map.find(test_sock_list[0].first) == realserver_map.end());
4932 BOOST_CHECK(realserver_map.find(test_sock_list[1].first) == realserver_map.end());
4933 BOOST_CHECK(realserver_map.find(test_sock_list[2].first) != realserver_map.end());
4934 test_obj.test_call();
4935 BOOST_CHECK(realserver_map.find(test_sock_list[0].first) == realserver_map.end());
4936 BOOST_CHECK(realserver_map.find(test_sock_list[1].first) == realserver_map.end());
4937 BOOST_CHECK(realserver_map.find(test_sock_list[2].first) == realserver_map.end());
4938 BOOST_CHECK(realserver_map.empty());
4940 // unit_test [5] up_thread_realserver_disconnect_event not fond function error check
4941 std::cout << "[5] up_thread_realserver_disconnect_event not fond function error check" << std::endl;
4942 test_obj.up_thread_function_array_clear();
4943 proto_test.handle_realserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
4944 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
4945 l7vs::Logger::putLogError_id = 0;
4946 test_obj.test_call();
4947 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
4948 BOOST_CHECK_EQUAL(46,l7vs::Logger::putLogError_id);
4949 std::cout << l7vs::Logger::putLogError_message << std::endl;
4951 // unit_test [6] up_thread_realserver_disconnect_event returnd illegal EVENT_TAG error check
4952 std::cout << "[6] up_thread_realserver_disconnect_event returnd illegal EVENT_TAG error check" << std::endl;
4953 test_obj.up_thread_module_event_map_clear();
4954 proto_test.handle_realserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
4955 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
4956 l7vs::Logger::putLogError_id = 0;
4957 test_obj.test_call();
4958 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
4959 BOOST_CHECK_EQUAL(45,l7vs::Logger::putLogError_id);
4960 std::cout << l7vs::Logger::putLogError_message << std::endl;
4962 // mutex_lock_test test_lock_obj(vs,io);
4963 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);
4965 test_lock_obj.set_up_thread_realserver_disconnect_event_test();
4966 test_lock_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
4968 test_lock_obj.test_thread_wait.lock();
4969 test_lock_obj.befor_thread_id = proc_id;
4970 test_lock_obj.after_thread_id = proc_id;
4971 test_lock_obj.mutex_lock();
4973 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
4975 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
4976 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
4978 boost::thread::id test_id = test_thread.get_id();
4980 BOOST_CHECK(test_id != proc_id);
4983 test_lock_obj.test_thread_wait.unlock();
4986 // unit_test [7] up_thread_realserver_disconnect_event thread block test (mutex lock)
4987 std::cout << "[7] up_thread_realserver_disconnect_event thread block test (mutex lock)" << std::endl;
4988 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
4989 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
4991 test_lock_obj.mutex_unlock();
4994 // unit_test [8] up_thread_realserver_disconnect_event thread run test (mutex unlock)
4995 std::cout << "[8] up_thread_realserver_disconnect_event thread run test (mutex unlock)" << std::endl;
4996 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
4997 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
4999 BOOST_MESSAGE( "----- up_thread_realserver_disconnect_event test end -----" );
5004 // down_thread_realserver_disconnetc_event test
5005 // down_thread_realserver_disconnetc_event test class
5006 class down_thread_realserver_disconnect_event_test_class : public module_event_map_test_base_class{
5008 // 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){
5010 down_thread_realserver_disconnect_event_test_class(
5011 l7vs::virtualservice_tcp& vs,
5012 boost::asio::io_service& session_io,
5013 l7vs::tcp_socket_option_info& set_socket_option,
5014 boost::asio::ip::tcp::endpoint listen_endpoint,
5016 boost::asio::ssl::context& set_ssl_context,
5017 bool set_ssl_cache_flag,
5018 int set_ssl_handshake_time_out,
5019 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
5026 set_ssl_handshake_time_out,
5027 set_access_logger){};
5030 ~down_thread_realserver_disconnect_event_test_class(){};
5033 l7vs::tcp_session::down_thread_realserver_disconnect_event(LOCAL_PROC);
5036 std::list<socket_element>& get_realserver_socket_list(){
5037 return down_thread_receive_realserver_socket_list;
5041 void down_thread_realserver_disconnect_event_test(){
5043 BOOST_MESSAGE( "----- down_thread_realserver_disconnect_event test start -----" );
5045 boost::asio::io_service io;
5046 l7vs::virtualservice_tcp vs;
5047 l7vs::tcp_socket_option_info set_option;
5048 //! TCP_NODELAY (false:not set,true:set option)
5049 set_option.nodelay_opt = false;
5050 //! TCP_NODELAY option value (false:off,true:on)
5051 set_option.nodelay_val = false;
5052 //! TCP_CORK (false:not set,true:set option)
5053 set_option.cork_opt = false;
5054 //! TCP_CORK option value (false:off,true:on)
5055 set_option.cork_val = false;
5056 //! TCP_QUICKACK (false:not set,true:set option)
5057 set_option.quickack_opt = false;
5058 //! TCP_QUICKACK option value (false:off,true:on)
5059 set_option.quickack_val = false;
5061 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
5062 bool set_mode(false);
5063 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
5064 bool set_ssl_cache_flag(false);
5065 int set_ssl_handshake_time_out = 0;
5066 //std::string access_log_file_name = "test";
5067 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
5068 // down_thread_realserver_disconnect_event_test_class test_obj(vs,io);
5069 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);
5075 std::string test_protocol_name("test protocol");
5076 l7vs::test_protocol_module proto_test(test_protocol_name);
5078 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
5080 l7vs::protocol_module_base::EVENT_TAG chek_event[7];
5081 chek_event[0] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
5082 chek_event[1] = l7vs::protocol_module_base::CLIENT_CONNECTION_CHECK;
5083 chek_event[2] = l7vs::protocol_module_base::REALSERVER_RECV;
5084 chek_event[3] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
5085 chek_event[4] = l7vs::protocol_module_base::SORRYSERVER_RECV;
5086 chek_event[5] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
5087 chek_event[6] = l7vs::protocol_module_base::FINALIZE;
5089 // unit_test [1] down_thread_realserver_disconnect_event down_thread_next_call_function update check
5090 std::cout << "[1] down_thread_realserver_disconnect_event down_thread_next_call_function update check" << std::endl;
5091 for(int i = 0; i < 7;i++){
5092 proto_test.handle_realserver_disconnect_res_tag = chek_event[i];
5093 test_obj.test_call();
5094 BOOST_CHECK(test_obj.chk_down_thread_next_call_function(chek_event[i]));
5097 // module parameter check
5098 boost::thread::id def_id;
5099 boost::thread::id proc_id = boost::this_thread::get_id();
5100 boost::asio::ip::tcp::endpoint test_end(boost::asio::ip::address::from_string("100.102.103.104"), 7777);
5101 l7vs::tcp_data test_message;
5102 test_message.set_endpoint(test_end);
5103 test_obj.set_down_thread_id(proc_id);
5104 test_obj.set_down_thread_message_data(test_message);
5105 proto_test.handle_realserver_disconnect_thread_id = def_id;
5106 proto_test.handle_realserver_disconnect_rs_endpoint = boost::asio::ip::tcp::endpoint();
5107 proto_test.handle_realserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5108 BOOST_CHECK(proto_test.handle_realserver_disconnect_thread_id != proc_id);
5109 BOOST_CHECK(proto_test.handle_realserver_disconnect_rs_endpoint != test_end);
5110 test_obj.test_call();
5111 // unit_test [2] down_thread_realserver_disconnect_event module parameter check thread id
5112 std::cout << "[2] down_thread_realserver_disconnect_event module parameter check thread id" << std::endl;
5113 BOOST_CHECK(proto_test.handle_realserver_disconnect_thread_id == proc_id);
5115 // unit_test [3] down_thread_realserver_disconnect_event module parameter check endpoint
5116 std::cout << "[3] down_thread_realserver_disconnect_event module parameter check endpoint" << std::endl;
5117 BOOST_CHECK(proto_test.handle_realserver_disconnect_rs_endpoint == test_end);
5120 // unit_test [4] down_thread_realserver_disconnect_event realserver map erase check
5121 std::cout << "[4] down_thread_realserver_disconnect_event realserver map erase check" << std::endl;
5123 std::list< std::pair< boost::asio::ip::tcp::endpoint , boost::shared_ptr< l7vs::tcp_socket > > >& realserver_list = test_obj.get_realserver_socket_list();
5124 boost::shared_ptr< l7vs::tcp_socket > test_tcp_sock0(new l7vs::tcp_socket(io));
5125 boost::shared_ptr< l7vs::tcp_socket > test_tcp_sock1(new l7vs::tcp_socket(io));
5126 boost::shared_ptr< l7vs::tcp_socket > test_tcp_sock2(new l7vs::tcp_socket(io));
5127 std::pair< boost::asio::ip::tcp::endpoint , boost::shared_ptr< l7vs::tcp_socket > > test_sock_list[3];
5128 test_sock_list[0].first = boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string("100.100.100.100"), 0);
5129 test_sock_list[0].second = test_tcp_sock0;
5130 test_sock_list[1].first = boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string("101.101.101.101"), 1);
5131 test_sock_list[1].second = test_tcp_sock1;
5132 test_sock_list[2].first = boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string("102.102.102.102"), 2);
5133 test_sock_list[2].second = test_tcp_sock2;
5134 for(int i = 0;i < 3;i++){
5135 realserver_list.push_back(test_sock_list[i]);
5137 proto_test.handle_realserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5138 std::list< std::pair< boost::asio::ip::tcp::endpoint , boost::shared_ptr< l7vs::tcp_socket > > >::iterator ret_ite;
5141 test_message.set_endpoint(test_sock_list[1].first);
5142 test_obj.set_down_thread_message_data(test_message);
5143 ret_ite = realserver_list.begin();
5144 BOOST_CHECK(ret_ite->first == test_sock_list[0].first);
5146 BOOST_CHECK(ret_ite->first == test_sock_list[1].first);
5148 BOOST_CHECK(ret_ite->first == test_sock_list[2].first);
5150 BOOST_CHECK(ret_ite == realserver_list.end());
5151 test_obj.test_call();
5152 ret_ite = realserver_list.begin();
5153 BOOST_CHECK(ret_ite->first == test_sock_list[0].first);
5155 BOOST_CHECK(ret_ite->first == test_sock_list[2].first);
5157 BOOST_CHECK(ret_ite == realserver_list.end());
5160 test_message.set_endpoint(test_sock_list[0].first);
5161 test_obj.set_down_thread_message_data(test_message);
5162 ret_ite = realserver_list.begin();
5163 BOOST_CHECK(ret_ite->first == test_sock_list[0].first);
5165 BOOST_CHECK(ret_ite->first == test_sock_list[2].first);
5167 BOOST_CHECK(ret_ite == realserver_list.end());
5168 test_obj.test_call();
5169 ret_ite = realserver_list.begin();
5170 BOOST_CHECK(ret_ite->first == test_sock_list[2].first);
5172 BOOST_CHECK(ret_ite == realserver_list.end());
5175 test_message.set_endpoint(test_sock_list[2].first);
5176 test_obj.set_down_thread_message_data(test_message);
5177 ret_ite = realserver_list.begin();
5178 BOOST_CHECK(ret_ite->first == test_sock_list[2].first);
5180 BOOST_CHECK(ret_ite == realserver_list.end());
5181 test_obj.test_call();
5182 ret_ite = realserver_list.begin();
5183 BOOST_CHECK(ret_ite == realserver_list.end());
5184 BOOST_CHECK(realserver_list.empty());
5186 // unit_test [5] down_thread_realserver_disconnect_event not fond function error check
5187 std::cout << "[5] down_thread_realserver_disconnect_event not fond function error check" << std::endl;
5188 test_obj.down_thread_function_array_clear();
5189 proto_test.handle_realserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5190 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
5191 l7vs::Logger::putLogError_id = 0;
5192 test_obj.test_call();
5193 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
5194 BOOST_CHECK_EQUAL(75,l7vs::Logger::putLogError_id);
5195 std::cout << l7vs::Logger::putLogError_message << std::endl;
5197 // unit_test [6] down_thread_realserver_disconnect_event returnd illegal EVENT_TAG error check
5198 std::cout << "[6] down_thread_realserver_disconnect_event returnd illegal EVENT_TAG error check" << std::endl;
5199 test_obj.down_thread_module_event_map_clear();
5200 proto_test.handle_realserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5201 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
5202 l7vs::Logger::putLogError_id = 0;
5203 test_obj.test_call();
5204 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
5205 BOOST_CHECK_EQUAL(74,l7vs::Logger::putLogError_id);
5206 std::cout << l7vs::Logger::putLogError_message << std::endl;
5208 // mutex_lock_test test_lock_obj(vs,io);
5209 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);
5210 test_lock_obj.set_down_thread_realserver_disconnect_event_test();
5211 test_lock_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
5213 test_lock_obj.test_thread_wait.lock();
5214 test_lock_obj.befor_thread_id = proc_id;
5215 test_lock_obj.after_thread_id = proc_id;
5216 test_lock_obj.mutex_lock();
5218 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
5220 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
5221 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
5223 boost::thread::id test_id = test_thread.get_id();
5225 BOOST_CHECK(test_id != proc_id);
5228 test_lock_obj.test_thread_wait.unlock();
5231 // unit_test [7] down_thread_realserver_disconnect_event thread block test (mutex lock)
5232 std::cout << "[7] down_thread_realserver_disconnect_event thread block test (mutex lock)" << std::endl;
5233 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
5234 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
5236 test_lock_obj.mutex_unlock();
5239 // unit_test [8] down_thread_realserver_disconnect_event thread run test (mutex unlock)
5240 std::cout << "[8] down_thread_realserver_disconnect_event thread run test (mutex unlock)" << std::endl;
5241 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
5242 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
5244 BOOST_MESSAGE( "----- down_thread_realserver_disconnect_event test end -----" );
5247 // up_thread_sorryserver_disconnect_event test
5248 // up_thread_sorryserver_disconnect_event test class
5249 class up_thread_sorryserver_disconnect_event_test_class : public module_event_map_test_base_class{
5251 // 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){
5253 up_thread_sorryserver_disconnect_event_test_class(
5254 l7vs::virtualservice_tcp& vs,
5255 boost::asio::io_service& session_io,
5256 l7vs::tcp_socket_option_info& set_socket_option,
5257 boost::asio::ip::tcp::endpoint listen_endpoint,
5259 boost::asio::ssl::context& set_ssl_context,
5260 bool set_ssl_cache_flag,
5261 int set_ssl_handshake_time_out,
5262 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
5269 set_ssl_handshake_time_out,
5270 set_access_logger){};
5273 ~up_thread_sorryserver_disconnect_event_test_class(){};
5276 l7vs::tcp_session::up_thread_sorryserver_disconnect_event(LOCAL_PROC);
5280 void up_thread_sorryserver_disconnect_event_test(){
5282 BOOST_MESSAGE( "----- up_thread_sorryserver_disconnect_event_test test start -----" );
5284 boost::asio::io_service io;
5285 l7vs::virtualservice_tcp vs;
5286 l7vs::tcp_socket_option_info set_option;
5287 //! TCP_NODELAY (false:not set,true:set option)
5288 set_option.nodelay_opt = false;
5289 //! TCP_NODELAY option value (false:off,true:on)
5290 set_option.nodelay_val = false;
5291 //! TCP_CORK (false:not set,true:set option)
5292 set_option.cork_opt = false;
5293 //! TCP_CORK option value (false:off,true:on)
5294 set_option.cork_val = false;
5295 //! TCP_QUICKACK (false:not set,true:set option)
5296 set_option.quickack_opt = false;
5297 //! TCP_QUICKACK option value (false:off,true:on)
5298 set_option.quickack_val = false;
5300 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
5301 bool set_mode(false);
5302 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
5303 bool set_ssl_cache_flag(false);
5304 int set_ssl_handshake_time_out = 0;
5305 //std::string access_log_file_name = "test";
5306 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
5308 // up_thread_sorryserver_disconnect_event_test_class test_obj(vs,io);
5309 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);
5315 std::string test_protocol_name("test protocol");
5316 l7vs::test_protocol_module proto_test(test_protocol_name);
5318 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
5320 l7vs::protocol_module_base::EVENT_TAG chek_event[13];
5321 chek_event[0] = l7vs::protocol_module_base::ACCEPT;
5322 chek_event[1] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
5323 chek_event[2] = l7vs::protocol_module_base::CLIENT_RECV;
5324 chek_event[3] = l7vs::protocol_module_base::CLIENT_RESPONSE_SEND;
5325 chek_event[4] = l7vs::protocol_module_base::REALSERVER_SELECT;
5326 chek_event[5] = l7vs::protocol_module_base::REALSERVER_CONNECT;
5327 chek_event[6] = l7vs::protocol_module_base::REALSERVER_SEND;
5328 chek_event[7] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
5329 chek_event[8] = l7vs::protocol_module_base::SORRYSERVER_SELECT;
5330 chek_event[9] = l7vs::protocol_module_base::SORRYSERVER_CONNECT;
5331 chek_event[10] = l7vs::protocol_module_base::SORRYSERVER_SEND;
5332 chek_event[11] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
5333 chek_event[12] = l7vs::protocol_module_base::FINALIZE;
5335 // unit_test [1] up_thread_sorryserver_disconnect_event up_thread_next_call_function update check
5336 std::cout << "[1] up_thread_sorryserver_disconnect_event up_thread_next_call_function update check" << std::endl;
5337 for(int i = 0; i < 13;i++){
5338 proto_test.handle_sorryserver_disconnect_res_tag = chek_event[i];
5339 test_obj.test_call();
5340 BOOST_CHECK(test_obj.chk_up_thread_next_call_function(chek_event[i]));
5343 // module parameter check
5344 boost::thread::id def_id;
5345 boost::thread::id proc_id = boost::this_thread::get_id();
5346 boost::asio::ip::tcp::endpoint test_end(boost::asio::ip::address::from_string("100.102.103.104"), 7777);
5347 l7vs::tcp_data test_message;
5348 test_message.set_endpoint(test_end);
5349 test_obj.set_up_thread_id(proc_id);
5350 test_obj.set_up_thread_message_data(test_message);
5351 proto_test.handle_sorryserver_disconnect_thread_id = def_id;
5352 proto_test.handle_sorryserver_disconnect_rs_endpoint = boost::asio::ip::tcp::endpoint();
5353 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5354 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_thread_id != proc_id);
5355 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_rs_endpoint != test_end);
5356 test_obj.test_call();
5357 // unit_test [2] up_thread_sorryserver_disconnect_event module parameter check thread id
5358 std::cout << "[2] up_thread_sorryserver_disconnect_event module parameter check thread id" << std::endl;
5359 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_thread_id == proc_id);
5361 // unit_test [3] up_thread_sorryserver_disconnect_event module parameter check endpoint
5362 std::cout << "[3] up_thread_sorryserver_disconnect_event module parameter check endpoint" << std::endl;
5363 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_rs_endpoint == test_end);
5365 // unit_test [4] up_thread_sorryserver_disconnect_event not fond function error check
5366 std::cout << "[4] up_thread_sorryserver_disconnect_event not fond function error check" << std::endl;
5367 test_obj.up_thread_function_array_clear();
5368 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5369 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
5370 l7vs::Logger::putLogError_id = 0;
5371 test_obj.test_call();
5372 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
5373 BOOST_CHECK_EQUAL(65,l7vs::Logger::putLogError_id);
5374 std::cout << l7vs::Logger::putLogError_message << std::endl;
5376 // unit_test [5] up_thread_sorryserver_disconnect_event returnd illegal EVENT_TAG error check
5377 std::cout << "[5] up_thread_sorryserver_disconnect_event returnd illegal EVENT_TAG error check" << std::endl;
5378 test_obj.up_thread_module_event_map_clear();
5379 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5380 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
5381 l7vs::Logger::putLogError_id = 0;
5382 test_obj.test_call();
5383 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
5384 BOOST_CHECK_EQUAL(64,l7vs::Logger::putLogError_id);
5385 std::cout << l7vs::Logger::putLogError_message << std::endl;
5387 // mutex_lock_test test_lock_obj(vs,io);
5388 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);
5389 test_lock_obj.set_up_thread_sorryserver_disconnect_event_test();
5390 test_lock_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
5392 test_lock_obj.test_thread_wait.lock();
5393 test_lock_obj.befor_thread_id = proc_id;
5394 test_lock_obj.after_thread_id = proc_id;
5395 test_lock_obj.mutex_lock();
5397 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
5399 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
5400 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
5402 boost::thread::id test_id = test_thread.get_id();
5404 BOOST_CHECK(test_id != proc_id);
5407 test_lock_obj.test_thread_wait.unlock();
5410 // unit_test [6] up_thread_sorryserver_disconnect_event thread block test (mutex lock)
5411 std::cout << "[6] up_thread_sorryserver_disconnect_event thread block test (mutex lock)" << std::endl;
5412 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
5413 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
5415 test_lock_obj.mutex_unlock();
5418 // unit_test [7] up_thread_sorryserver_disconnect_event thread run test (mutex unlock)
5419 std::cout << "[7] up_thread_sorryserver_disconnect_event thread run test (mutex unlock)" << std::endl;
5420 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
5421 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
5423 BOOST_MESSAGE( "----- up_thread_sorryserver_disconnect_event_test test end -----" );
5426 // up_thread_sorryserver_mod_disconnect test
5427 // up_thread_sorryserver_mod_disconnect test class
5428 class up_thread_sorryserver_mod_disconnect_test_class : public module_event_map_test_base_class{
5430 // 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){
5432 up_thread_sorryserver_mod_disconnect_test_class(
5433 l7vs::virtualservice_tcp& vs,
5434 boost::asio::io_service& session_io,
5435 l7vs::tcp_socket_option_info& set_socket_option,
5436 boost::asio::ip::tcp::endpoint listen_endpoint,
5438 boost::asio::ssl::context& set_ssl_context,
5439 bool set_ssl_cache_flag,
5440 int set_ssl_handshake_time_out,
5441 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
5448 set_ssl_handshake_time_out,
5449 set_access_logger){};
5451 ~up_thread_sorryserver_mod_disconnect_test_class(){};
5454 l7vs::tcp_session::up_thread_sorryserver_mod_disconnect(LOCAL_PROC);
5457 boost::shared_ptr< l7vs::tcp_socket > get_sorry_socket(){
5458 return sorryserver_socket.second;
5461 boost::asio::ip::tcp::endpoint& get_sorry_endpoint(){
5462 return sorryserver_socket.first;
5467 void up_thread_sorryserver_mod_disconnect_test(){
5469 BOOST_MESSAGE( "----- up_thread_sorryserver_mod_disconnect test start -----" );
5471 boost::asio::io_service io;
5472 l7vs::virtualservice_tcp vs;
5473 l7vs::tcp_socket_option_info set_option;
5474 //! TCP_NODELAY (false:not set,true:set option)
5475 set_option.nodelay_opt = false;
5476 //! TCP_NODELAY option value (false:off,true:on)
5477 set_option.nodelay_val = false;
5478 //! TCP_CORK (false:not set,true:set option)
5479 set_option.cork_opt = false;
5480 //! TCP_CORK option value (false:off,true:on)
5481 set_option.cork_val = false;
5482 //! TCP_QUICKACK (false:not set,true:set option)
5483 set_option.quickack_opt = false;
5484 //! TCP_QUICKACK option value (false:off,true:on)
5485 set_option.quickack_val = false;
5487 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
5488 bool set_mode(false);
5489 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
5490 bool set_ssl_cache_flag(false);
5491 int set_ssl_handshake_time_out = 0;
5492 //std::string access_log_file_name = "test";
5493 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
5495 // up_thread_sorryserver_mod_disconnect_test_class test_obj(vs,io);
5496 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);
5499 std::string test_protocol_name("test protocol");
5500 l7vs::test_protocol_module proto_test(test_protocol_name);
5502 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
5504 l7vs::protocol_module_base::EVENT_TAG chek_event[13];
5505 chek_event[0] = l7vs::protocol_module_base::ACCEPT;
5506 chek_event[1] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
5507 chek_event[2] = l7vs::protocol_module_base::CLIENT_RECV;
5508 chek_event[3] = l7vs::protocol_module_base::CLIENT_RESPONSE_SEND;
5509 chek_event[4] = l7vs::protocol_module_base::REALSERVER_SELECT;
5510 chek_event[5] = l7vs::protocol_module_base::REALSERVER_CONNECT;
5511 chek_event[6] = l7vs::protocol_module_base::REALSERVER_SEND;
5512 chek_event[7] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
5513 chek_event[8] = l7vs::protocol_module_base::SORRYSERVER_SELECT;
5514 chek_event[9] = l7vs::protocol_module_base::SORRYSERVER_CONNECT;
5515 chek_event[10] = l7vs::protocol_module_base::SORRYSERVER_SEND;
5516 chek_event[11] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
5517 chek_event[12] = l7vs::protocol_module_base::FINALIZE;
5519 // unit_test [1] up_thread_sorryserver_mod_disconnect up_thread_next_call_function update check
5520 std::cout << "[1] up_thread_sorryserver_mod_disconnect up_thread_next_call_function update check" << std::endl;
5521 for(int i = 0; i < 13;i++){
5522 proto_test.handle_sorryserver_disconnect_res_tag = chek_event[i];
5523 test_obj.test_call();
5524 BOOST_CHECK(test_obj.chk_up_thread_next_call_function(chek_event[i]));
5527 // module parameter check
5528 boost::thread::id def_id;
5529 boost::thread::id proc_id = boost::this_thread::get_id();
5530 boost::asio::ip::tcp::endpoint test_end(boost::asio::ip::address::from_string("100.102.103.104"), 7777);
5531 test_obj.get_sorry_endpoint() = test_end;
5532 test_obj.set_up_thread_id(proc_id);
5533 proto_test.handle_sorryserver_disconnect_thread_id = def_id;
5534 proto_test.handle_sorryserver_disconnect_rs_endpoint = boost::asio::ip::tcp::endpoint();
5535 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5536 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_thread_id != proc_id);
5537 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_rs_endpoint != test_end);
5538 test_obj.get_sorry_socket()->close_call_check = false;
5539 test_obj.get_sorry_socket()->close_res = true;
5541 test_obj.test_call();
5543 // unit_test [2] up_thread_sorryserver_mod_disconnect socket close check
5544 std::cout << "[2] up_thread_sorryserver_mod_disconnect socket close check" << std::endl;
5545 BOOST_CHECK(test_obj.get_sorry_socket()->close_call_check);
5547 // unit_test [3] up_thread_sorryserver_mod_disconnect endpoint not update check
5548 std::cout << "[3] up_thread_sorryserver_mod_disconnect endpoint not update check" << std::endl;
5549 BOOST_CHECK(test_obj.get_sorry_endpoint() == test_end);
5551 // unit_test [4] up_thread_sorryserver_mod_disconnect module parameter check thread id
5552 std::cout << "[4] up_thread_sorryserver_mod_disconnect module parameter check thread id" << std::endl;
5553 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_thread_id == proc_id);
5555 // unit_test [5] up_thread_sorryserver_mod_disconnect module parameter check endpoint
5556 std::cout << "[5] up_thread_sorryserver_mod_disconnect module parameter check endpoint" << std::endl;
5557 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_rs_endpoint == test_end);
5560 proto_test.handle_sorryserver_disconnect_thread_id = def_id;
5561 proto_test.handle_sorryserver_disconnect_rs_endpoint = boost::asio::ip::tcp::endpoint();
5562 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5563 test_obj.get_sorry_socket()->close_call_check = false;
5564 test_obj.get_sorry_socket()->close_res = false;
5566 test_obj.test_call();
5568 // unit_test [6] up_thread_sorryserver_mod_disconnect socket close check
5569 std::cout << "[6] up_thread_sorryserver_mod_disconnect socket close check" << std::endl;
5570 BOOST_CHECK(test_obj.get_sorry_socket()->close_call_check);
5572 // unit_test [7] up_thread_sorryserver_mod_disconnect endpoint not update check
5573 std::cout << "[7] up_thread_sorryserver_mod_disconnect endpoint not update check" << std::endl;
5574 BOOST_CHECK(test_obj.get_sorry_endpoint() == boost::asio::ip::tcp::endpoint());
5576 // unit_test [8] up_thread_sorryserver_mod_disconnect module parameter check thread id
5577 std::cout << "[8] up_thread_sorryserver_mod_disconnect module parameter check thread id" << std::endl;
5578 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_thread_id == proc_id);
5580 // unit_test [9] up_thread_sorryserver_mod_disconnect module parameter check endpoint
5581 std::cout << "[9] up_thread_sorryserver_mod_disconnect module parameter check endpoint" << std::endl;
5582 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_rs_endpoint == test_end);
5584 proto_test.handle_sorryserver_disconnect_thread_id = def_id;
5585 proto_test.handle_sorryserver_disconnect_rs_endpoint = boost::asio::ip::tcp::endpoint();
5586 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5587 test_obj.get_sorry_socket()->close_call_check = false;
5588 test_obj.get_sorry_socket()->close_res = false;
5590 test_obj.test_call();
5592 // unit_test [10] up_thread_sorryserver_mod_disconnect socket close check
5593 std::cout << "[10] up_thread_sorryserver_mod_disconnect socket close check" << std::endl;
5594 BOOST_CHECK(test_obj.get_sorry_socket()->close_call_check);
5596 // unit_test [11] up_thread_sorryserver_mod_disconnect endpoint not update check
5597 std::cout << "[11] up_thread_sorryserver_mod_disconnect endpoint not update check" << std::endl;
5598 BOOST_CHECK(test_obj.get_sorry_endpoint() == boost::asio::ip::tcp::endpoint());
5600 // unit_test [12] up_thread_sorryserver_mod_disconnect module parameter check thread id
5601 std::cout << "[12] up_thread_sorryserver_mod_disconnect module parameter check thread id" << std::endl;
5602 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_thread_id == proc_id);
5604 // unit_test [13] up_thread_sorryserver_mod_disconnect module parameter check endpoint
5605 std::cout << "[13] up_thread_sorryserver_mod_disconnect module parameter check endpoint" << std::endl;
5606 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_rs_endpoint == boost::asio::ip::tcp::endpoint());
5608 // unit_test [14] up_thread_sorryserver_mod_disconnect not fond function error check
5609 std::cout << "[14] up_thread_sorryserver_mod_disconnect not fond function error check" << std::endl;
5610 test_obj.up_thread_function_array_clear();
5611 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5612 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
5613 l7vs::Logger::putLogError_id = 0;
5614 test_obj.test_call();
5615 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
5616 BOOST_CHECK_EQUAL(63,l7vs::Logger::putLogError_id);
5617 std::cout << l7vs::Logger::putLogError_message << std::endl;
5619 // unit_test [15] up_thread_sorryserver_mod_disconnect returnd illegal EVENT_TAG error check
5620 std::cout << "[15] up_thread_sorryserver_mod_disconnect returnd illegal EVENT_TAG error check" << std::endl;
5621 test_obj.up_thread_module_event_map_clear();
5622 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5623 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
5624 l7vs::Logger::putLogError_id = 0;
5625 test_obj.test_call();
5626 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
5627 BOOST_CHECK_EQUAL(62,l7vs::Logger::putLogError_id);
5628 std::cout << l7vs::Logger::putLogError_message << std::endl;
5630 // mutex_lock_test test_lock_obj(vs,io);
5631 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);
5632 test_lock_obj.set_up_thread_sorryserver_disconnect_event_test();
5633 test_lock_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
5635 test_lock_obj.test_thread_wait.lock();
5636 test_lock_obj.befor_thread_id = proc_id;
5637 test_lock_obj.after_thread_id = proc_id;
5638 test_lock_obj.mutex_lock();
5640 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
5642 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
5643 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
5645 boost::thread::id test_id = test_thread.get_id();
5647 BOOST_CHECK(test_id != proc_id);
5650 test_lock_obj.test_thread_wait.unlock();
5653 // unit_test [16] up_thread_sorryserver_mod_disconnect thread block test (mutex lock)
5654 std::cout << "[16] up_thread_sorryserver_mod_disconnect thread block test (mutex lock)" << std::endl;
5655 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
5656 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
5658 test_lock_obj.mutex_unlock();
5661 // unit_test [17] up_thread_sorryserver_mod_disconnect thread run test (mutex unlock)
5662 std::cout << "[17] up_thread_sorryserver_mod_disconnect thread run test (mutex unlock)" << std::endl;
5663 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
5664 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
5666 BOOST_MESSAGE( "----- up_thread_sorryserver_mod_disconnect test end -----" );
5669 // down_thread_sorryserver_mod_disconnect test
5670 // down_thread_sorryserver_mod_disconnect test class
5671 class down_thread_sorryserver_mod_disconnect_test_class : public module_event_map_test_base_class{
5673 // 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){
5675 down_thread_sorryserver_mod_disconnect_test_class(
5676 l7vs::virtualservice_tcp& vs,
5677 boost::asio::io_service& session_io,
5678 l7vs::tcp_socket_option_info& set_socket_option,
5679 boost::asio::ip::tcp::endpoint listen_endpoint,
5681 boost::asio::ssl::context& set_ssl_context,
5682 bool set_ssl_cache_flag,
5683 int set_ssl_handshake_time_out,
5684 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
5691 set_ssl_handshake_time_out,
5692 set_access_logger){};
5695 ~down_thread_sorryserver_mod_disconnect_test_class(){};
5698 l7vs::tcp_session::down_thread_sorryserver_mod_disconnect(LOCAL_PROC);
5701 boost::shared_ptr< l7vs::tcp_socket > get_sorry_socket(){
5702 return sorryserver_socket.second;
5705 boost::asio::ip::tcp::endpoint& get_sorry_endpoint(){
5706 return sorryserver_socket.first;
5711 void down_thread_sorryserver_mod_disconnect_test(){
5713 BOOST_MESSAGE( "----- down_thread_sorryserver_mod_disconnect test start -----" );
5715 boost::asio::io_service io;
5716 l7vs::virtualservice_tcp vs;
5717 l7vs::tcp_socket_option_info set_option;
5718 //! TCP_NODELAY (false:not set,true:set option)
5719 set_option.nodelay_opt = false;
5720 //! TCP_NODELAY option value (false:off,true:on)
5721 set_option.nodelay_val = false;
5722 //! TCP_CORK (false:not set,true:set option)
5723 set_option.cork_opt = false;
5724 //! TCP_CORK option value (false:off,true:on)
5725 set_option.cork_val = false;
5726 //! TCP_QUICKACK (false:not set,true:set option)
5727 set_option.quickack_opt = false;
5728 //! TCP_QUICKACK option value (false:off,true:on)
5729 set_option.quickack_val = false;
5731 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
5732 bool set_mode(false);
5733 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
5734 bool set_ssl_cache_flag(false);
5735 int set_ssl_handshake_time_out = 0;
5736 //std::string access_log_file_name = "test";
5737 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
5739 // down_thread_sorryserver_mod_disconnect_test_class test_obj(vs,io);
5740 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);
5743 std::string test_protocol_name("test protocol");
5744 l7vs::test_protocol_module proto_test(test_protocol_name);
5746 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
5748 l7vs::protocol_module_base::EVENT_TAG chek_event[7];
5749 chek_event[0] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
5750 chek_event[1] = l7vs::protocol_module_base::CLIENT_CONNECTION_CHECK;
5751 chek_event[2] = l7vs::protocol_module_base::REALSERVER_RECV;
5752 chek_event[3] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
5753 chek_event[4] = l7vs::protocol_module_base::SORRYSERVER_RECV;
5754 chek_event[5] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
5755 chek_event[6] = l7vs::protocol_module_base::FINALIZE;
5757 // unit_test [1] down_thread_sorryserver_mod_disconnect down_thread_next_call_function update check
5758 std::cout << "[1] down_thread_sorryserver_mod_disconnect down_thread_next_call_function update check" << std::endl;
5759 for(int i = 0; i < 7;i++){
5760 proto_test.handle_sorryserver_disconnect_res_tag = chek_event[i];
5761 test_obj.test_call();
5762 BOOST_CHECK(test_obj.chk_down_thread_next_call_function(chek_event[i]));
5765 // module parameter check
5766 boost::thread::id def_id;
5767 boost::thread::id proc_id = boost::this_thread::get_id();
5768 boost::asio::ip::tcp::endpoint test_end(boost::asio::ip::address::from_string("100.102.103.104"), 7777);
5769 test_obj.get_sorry_endpoint() = test_end;
5770 test_obj.set_down_thread_id(proc_id);
5771 proto_test.handle_sorryserver_disconnect_thread_id = def_id;
5772 proto_test.handle_sorryserver_disconnect_rs_endpoint = boost::asio::ip::tcp::endpoint();
5773 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5774 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_thread_id != proc_id);
5775 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_rs_endpoint != test_end);
5776 test_obj.get_sorry_socket()->close_call_check = false;
5777 test_obj.get_sorry_socket()->close_res = true;
5779 test_obj.test_call();
5781 // unit_test [2] down_thread_sorryserver_mod_disconnect socket close check
5782 std::cout << "[2] down_thread_sorryserver_mod_disconnect socket close check" << std::endl;
5783 BOOST_CHECK(test_obj.get_sorry_socket()->close_call_check);
5785 // unit_test [3] down_thread_sorryserver_mod_disconnect endpoint not update check
5786 std::cout << "[3] down_thread_sorryserver_mod_disconnect endpoint not update check" << std::endl;
5787 BOOST_CHECK(test_obj.get_sorry_endpoint() == test_end);
5789 // unit_test [4] down_thread_sorryserver_mod_disconnect module parameter check thread id
5790 std::cout << "[4] down_thread_sorryserver_mod_disconnect module parameter check thread id" << std::endl;
5791 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_thread_id == proc_id);
5793 // unit_test [5] down_thread_sorryserver_mod_disconnect module parameter check endpoint
5794 std::cout << "[5] down_thread_sorryserver_mod_disconnect module parameter check endpoint" << std::endl;
5795 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_rs_endpoint == test_end);
5797 proto_test.handle_sorryserver_disconnect_thread_id = def_id;
5798 proto_test.handle_sorryserver_disconnect_rs_endpoint = boost::asio::ip::tcp::endpoint();
5799 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5800 test_obj.get_sorry_socket()->close_call_check = false;
5801 test_obj.get_sorry_socket()->close_res = false;
5803 test_obj.test_call();
5805 // unit_test [6] down_thread_sorryserver_mod_disconnect socket close check
5806 std::cout << "[6] down_thread_sorryserver_mod_disconnect socket close check" << std::endl;
5807 BOOST_CHECK(test_obj.get_sorry_socket()->close_call_check);
5809 // unit_test [7] down_thread_sorryserver_mod_disconnect endpoint not update check
5810 std::cout << "[7] down_thread_sorryserver_mod_disconnect endpoint not update check" << std::endl;
5811 BOOST_CHECK(test_obj.get_sorry_endpoint() == boost::asio::ip::tcp::endpoint());
5813 // unit_test [8] down_thread_sorryserver_mod_disconnect module parameter check thread id
5814 std::cout << "[8] down_thread_sorryserver_mod_disconnect module parameter check thread id" << std::endl;
5815 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_thread_id == proc_id);
5817 // unit_test [9] down_thread_sorryserver_mod_disconnect module parameter check endpoint
5818 std::cout << "[9] down_thread_sorryserver_mod_disconnect module parameter check endpoint" << std::endl;
5819 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_rs_endpoint == test_end);
5821 proto_test.handle_sorryserver_disconnect_thread_id = def_id;
5822 proto_test.handle_sorryserver_disconnect_rs_endpoint = boost::asio::ip::tcp::endpoint();
5823 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5824 test_obj.get_sorry_socket()->close_call_check = false;
5825 test_obj.get_sorry_socket()->close_res = false;
5827 test_obj.test_call();
5829 // unit_test [10] down_thread_sorryserver_mod_disconnect socket close check
5830 std::cout << "[10] down_thread_sorryserver_mod_disconnect socket close check" << std::endl;
5831 BOOST_CHECK(test_obj.get_sorry_socket()->close_call_check);
5833 // unit_test [11] down_thread_sorryserver_mod_disconnect endpoint not update check
5834 std::cout << "[11] down_thread_sorryserver_mod_disconnect endpoint not update check" << std::endl;
5835 BOOST_CHECK(test_obj.get_sorry_endpoint() == boost::asio::ip::tcp::endpoint());
5837 // unit_test [12] down_thread_sorryserver_mod_disconnect module parameter check thread id
5838 std::cout << "[12] down_thread_sorryserver_mod_disconnect module parameter check thread id" << std::endl;
5839 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_thread_id == proc_id);
5841 // unit_test [13] down_thread_sorryserver_mod_disconnect module parameter check endpoint
5842 std::cout << "[13] down_thread_sorryserver_mod_disconnect module parameter check endpoint" << std::endl;
5843 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_rs_endpoint == boost::asio::ip::tcp::endpoint());
5845 // unit_test [14] down_thread_sorryserver_mod_disconnect not fond function error check
5846 std::cout << "[14] down_thread_sorryserver_mod_disconnect not fond function error check" << std::endl;
5847 test_obj.down_thread_function_array_clear();
5848 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5849 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
5850 l7vs::Logger::putLogError_id = 0;
5851 test_obj.test_call();
5852 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
5853 BOOST_CHECK_EQUAL(93,l7vs::Logger::putLogError_id);
5854 std::cout << l7vs::Logger::putLogError_message << std::endl;
5856 // unit_test [15] down_thread_sorryserver_mod_disconnect returnd illegal EVENT_TAG error check
5857 std::cout << "[15] down_thread_sorryserver_mod_disconnect returnd illegal EVENT_TAG error check" << std::endl;
5858 test_obj.down_thread_module_event_map_clear();
5859 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
5860 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
5861 l7vs::Logger::putLogError_id = 0;
5862 test_obj.test_call();
5863 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
5864 BOOST_CHECK_EQUAL(92,l7vs::Logger::putLogError_id);
5865 std::cout << l7vs::Logger::putLogError_message << std::endl;
5867 // mutex_lock_test test_lock_obj(vs,io);
5868 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);
5869 test_lock_obj.set_down_thread_sorryserver_disconnect_event_test();
5870 test_lock_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
5872 test_lock_obj.test_thread_wait.lock();
5873 test_lock_obj.befor_thread_id = proc_id;
5874 test_lock_obj.after_thread_id = proc_id;
5875 test_lock_obj.mutex_lock();
5877 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
5879 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
5880 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
5882 boost::thread::id test_id = test_thread.get_id();
5884 BOOST_CHECK(test_id != proc_id);
5887 test_lock_obj.test_thread_wait.unlock();
5890 // unit_test [16] down_thread_sorryserver_mod_disconnect thread block test (mutex lock)
5891 std::cout << "[16] down_thread_sorryserver_mod_disconnect thread block test (mutex lock)" << std::endl;
5892 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
5893 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
5895 test_lock_obj.mutex_unlock();
5898 // unit_test [17] down_thread_sorryserver_mod_disconnect thread run test (mutex unlock)
5899 std::cout << "[17] down_thread_sorryserver_mod_disconnect thread run test (mutex unlock)" << std::endl;
5900 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
5901 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
5903 BOOST_MESSAGE( "----- down_thread_sorryserver_mod_disconnect test end -----" );
5908 // down_thread_sorryserver_disconnetc_event test
5909 // down_thread_sorryserver_disconnetc_event test class
5910 class down_thread_sorryserver_disconnect_event_test_class : public module_event_map_test_base_class{
5912 // 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){
5914 down_thread_sorryserver_disconnect_event_test_class(
5915 l7vs::virtualservice_tcp& vs,
5916 boost::asio::io_service& session_io,
5917 l7vs::tcp_socket_option_info& set_socket_option,
5918 boost::asio::ip::tcp::endpoint listen_endpoint,
5920 boost::asio::ssl::context& set_ssl_context,
5921 bool set_ssl_cache_flag,
5922 int set_ssl_handshake_time_out,
5923 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
5930 set_ssl_handshake_time_out,
5931 set_access_logger){};
5934 ~down_thread_sorryserver_disconnect_event_test_class(){};
5937 l7vs::tcp_session::down_thread_sorryserver_disconnect_event(LOCAL_PROC);
5941 void down_thread_sorryserver_disconnect_event_test(){
5943 BOOST_MESSAGE( "----- down_thread_sorryserver_disconnect_event test start -----" );
5945 boost::asio::io_service io;
5946 l7vs::virtualservice_tcp vs;
5947 l7vs::tcp_socket_option_info set_option;
5948 //! TCP_NODELAY (false:not set,true:set option)
5949 set_option.nodelay_opt = false;
5950 //! TCP_NODELAY option value (false:off,true:on)
5951 set_option.nodelay_val = false;
5952 //! TCP_CORK (false:not set,true:set option)
5953 set_option.cork_opt = false;
5954 //! TCP_CORK option value (false:off,true:on)
5955 set_option.cork_val = false;
5956 //! TCP_QUICKACK (false:not set,true:set option)
5957 set_option.quickack_opt = false;
5958 //! TCP_QUICKACK option value (false:off,true:on)
5959 set_option.quickack_val = false;
5961 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
5962 bool set_mode(false);
5963 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
5964 bool set_ssl_cache_flag(false);
5965 int set_ssl_handshake_time_out = 0;
5966 //std::string access_log_file_name = "test";
5967 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
5969 // down_thread_sorryserver_disconnect_event_test_class test_obj(vs,io);
5970 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);
5972 std::string test_protocol_name("test protocol");
5973 l7vs::test_protocol_module proto_test(test_protocol_name);
5975 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
5977 l7vs::protocol_module_base::EVENT_TAG chek_event[7];
5978 chek_event[0] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
5979 chek_event[1] = l7vs::protocol_module_base::CLIENT_CONNECTION_CHECK;
5980 chek_event[2] = l7vs::protocol_module_base::REALSERVER_RECV;
5981 chek_event[3] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
5982 chek_event[4] = l7vs::protocol_module_base::SORRYSERVER_RECV;
5983 chek_event[5] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
5984 chek_event[6] = l7vs::protocol_module_base::FINALIZE;
5986 // unit_test [1] down_thread_sorryserver_disconnect_event down_thread_next_call_function update check
5987 std::cout << "[1] down_thread_sorryserver_disconnect_event down_thread_next_call_function update check" << std::endl;
5988 for(int i = 0; i < 7;i++){
5989 proto_test.handle_sorryserver_disconnect_res_tag = chek_event[i];
5990 test_obj.test_call();
5991 BOOST_CHECK(test_obj.chk_down_thread_next_call_function(chek_event[i]));
5994 // module parameter check
5995 boost::thread::id def_id;
5996 boost::thread::id proc_id = boost::this_thread::get_id();
5997 boost::asio::ip::tcp::endpoint test_end(boost::asio::ip::address::from_string("100.102.103.104"), 7777);
5998 l7vs::tcp_data test_message;
5999 test_message.set_endpoint(test_end);
6000 test_obj.set_down_thread_id(proc_id);
6001 test_obj.set_down_thread_message_data(test_message);
6002 proto_test.handle_sorryserver_disconnect_thread_id = def_id;
6003 proto_test.handle_sorryserver_disconnect_rs_endpoint = boost::asio::ip::tcp::endpoint();
6004 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
6005 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_thread_id != proc_id);
6006 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_rs_endpoint != test_end);
6007 test_obj.test_call();
6008 // unit_test [2] down_thread_sorryserver_disconnect_event module parameter check thread id
6009 std::cout << "[2] down_thread_sorryserver_disconnect_event module parameter check thread id" << std::endl;
6010 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_thread_id == proc_id);
6012 // unit_test [3] down_thread_sorryserver_disconnect_event module parameter check endpoint
6013 std::cout << "[3] down_thread_sorryserver_disconnect_event module parameter check endpoint" << std::endl;
6014 BOOST_CHECK(proto_test.handle_sorryserver_disconnect_rs_endpoint == test_end);
6016 // unit_test [4] down_thread_sorryserver_disconnect_event not fond function error check
6017 std::cout << "[4] down_thread_sorryserver_disconnect_event not fond function error check" << std::endl;
6018 test_obj.down_thread_function_array_clear();
6019 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
6020 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
6021 l7vs::Logger::putLogError_id = 0;
6022 test_obj.test_call();
6023 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
6024 BOOST_CHECK_EQUAL(95,l7vs::Logger::putLogError_id);
6025 std::cout << l7vs::Logger::putLogError_message << std::endl;
6027 // unit_test [5] down_thread_sorryserver_disconnect_event returnd illegal EVENT_TAG error check
6028 std::cout << "[5] down_thread_sorryserver_disconnect_event returnd illegal EVENT_TAG error check" << std::endl;
6029 test_obj.down_thread_module_event_map_clear();
6030 proto_test.handle_sorryserver_disconnect_res_tag = l7vs::protocol_module_base::FINALIZE;
6031 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
6032 l7vs::Logger::putLogError_id = 0;
6033 test_obj.test_call();
6034 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
6035 BOOST_CHECK_EQUAL(94,l7vs::Logger::putLogError_id);
6036 std::cout << l7vs::Logger::putLogError_message << std::endl;
6038 // mutex_lock_test test_lock_obj(vs,io);
6039 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);
6040 test_lock_obj.set_down_thread_sorryserver_disconnect_event_test();
6041 test_lock_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
6043 test_lock_obj.test_thread_wait.lock();
6044 test_lock_obj.befor_thread_id = proc_id;
6045 test_lock_obj.after_thread_id = proc_id;
6046 test_lock_obj.mutex_lock();
6048 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
6050 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
6051 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
6053 boost::thread::id test_id = test_thread.get_id();
6055 BOOST_CHECK(test_id != proc_id);
6058 test_lock_obj.test_thread_wait.unlock();
6061 // unit_test [6] down_thread_sorryserver_disconnect_event thread block test (mutex lock)
6062 std::cout << "[6] down_thread_sorryserver_disconnect_event thread block test (mutex lock)" << std::endl;
6063 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
6064 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
6066 test_lock_obj.mutex_unlock();
6069 // unit_test [7] down_thread_sorryserver_disconnect_event thread run test (mutex unlock)
6070 std::cout << "[7] down_thread_sorryserver_disconnect_event thread run test (mutex unlock)" << std::endl;
6071 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
6072 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
6074 BOOST_MESSAGE( "----- down_thread_sorryserver_disconnect_event test end -----" );
6077 // up_thread_sorry_enable_event test
6078 // up_thread_sorry_enable_event test class
6079 class up_thread_sorry_enable_event_test_class : public module_event_map_test_base_class{
6081 // 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){
6083 up_thread_sorry_enable_event_test_class(
6084 l7vs::virtualservice_tcp& vs,
6085 boost::asio::io_service& session_io,
6086 l7vs::tcp_socket_option_info& set_socket_option,
6087 boost::asio::ip::tcp::endpoint listen_endpoint,
6089 boost::asio::ssl::context& set_ssl_context,
6090 bool set_ssl_cache_flag,
6091 int set_ssl_handshake_time_out,
6092 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
6099 set_ssl_handshake_time_out,
6100 set_access_logger){};
6103 ~up_thread_sorry_enable_event_test_class(){};
6106 l7vs::tcp_session::up_thread_sorry_enable_event(LOCAL_PROC);
6110 void up_thread_sorry_enable_event_test(){
6112 BOOST_MESSAGE( "----- up_thread_sorry_enable_event test start -----" );
6114 boost::asio::io_service io;
6115 l7vs::virtualservice_tcp vs;
6116 l7vs::tcp_socket_option_info set_option;
6117 //! TCP_NODELAY (false:not set,true:set option)
6118 set_option.nodelay_opt = false;
6119 //! TCP_NODELAY option value (false:off,true:on)
6120 set_option.nodelay_val = false;
6121 //! TCP_CORK (false:not set,true:set option)
6122 set_option.cork_opt = false;
6123 //! TCP_CORK option value (false:off,true:on)
6124 set_option.cork_val = false;
6125 //! TCP_QUICKACK (false:not set,true:set option)
6126 set_option.quickack_opt = false;
6127 //! TCP_QUICKACK option value (false:off,true:on)
6128 set_option.quickack_val = false;
6130 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
6131 bool set_mode(false);
6132 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
6133 bool set_ssl_cache_flag(false);
6134 int set_ssl_handshake_time_out = 0;
6135 //std::string access_log_file_name = "test";
6136 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
6138 // up_thread_sorry_enable_event_test_class test_obj(vs,io);
6139 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);
6142 std::string test_protocol_name("test protocol");
6143 l7vs::test_protocol_module proto_test(test_protocol_name);
6145 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
6147 l7vs::protocol_module_base::EVENT_TAG chek_event[13];
6148 chek_event[0] = l7vs::protocol_module_base::ACCEPT;
6149 chek_event[1] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
6150 chek_event[2] = l7vs::protocol_module_base::CLIENT_RECV;
6151 chek_event[3] = l7vs::protocol_module_base::CLIENT_RESPONSE_SEND;
6152 chek_event[4] = l7vs::protocol_module_base::REALSERVER_SELECT;
6153 chek_event[5] = l7vs::protocol_module_base::REALSERVER_CONNECT;
6154 chek_event[6] = l7vs::protocol_module_base::REALSERVER_SEND;
6155 chek_event[7] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
6156 chek_event[8] = l7vs::protocol_module_base::SORRYSERVER_SELECT;
6157 chek_event[9] = l7vs::protocol_module_base::SORRYSERVER_CONNECT;
6158 chek_event[10] = l7vs::protocol_module_base::SORRYSERVER_SEND;
6159 chek_event[11] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
6160 chek_event[12] = l7vs::protocol_module_base::FINALIZE;
6162 // unit_test [1] up_thread_sorry_enable_event up_thread_next_call_function update check
6163 std::cout << "[1] up_thread_sorry_enable_event up_thread_next_call_function update check" << std::endl;
6164 for(int i = 0; i < 13;i++){
6165 proto_test.handle_sorry_enable_res_tag = chek_event[i];
6166 test_obj.test_call();
6167 BOOST_CHECK(test_obj.chk_up_thread_next_call_function(chek_event[i]));
6170 // unit_test [2] up_thread_sorry_enable_event module parameter check thread id
6171 std::cout << "[2] up_thread_sorry_enable_event module parameter check thread id" << std::endl;
6172 boost::thread::id def_id;
6173 boost::thread::id proc_id = boost::this_thread::get_id();
6174 test_obj.set_up_thread_id(proc_id);
6175 proto_test.handle_sorry_enable_thread_id = def_id;
6176 proto_test.handle_sorry_enable_res_tag = l7vs::protocol_module_base::FINALIZE;
6177 BOOST_CHECK(proto_test.handle_sorry_enable_thread_id != proc_id);
6178 test_obj.test_call();
6179 BOOST_CHECK(proto_test.handle_sorry_enable_thread_id == proc_id);
6181 // unit_test [3] up_thread_sorry_enable_event not fond function error check
6182 std::cout << "[3] up_thread_sorry_enable_event not fond function error check" << std::endl;
6183 test_obj.up_thread_function_array_clear();
6184 proto_test.handle_sorry_enable_res_tag = l7vs::protocol_module_base::FINALIZE;
6185 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
6186 l7vs::Logger::putLogError_id = 0;
6187 test_obj.test_call();
6188 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
6189 BOOST_CHECK_EQUAL(67,l7vs::Logger::putLogError_id);
6190 std::cout << l7vs::Logger::putLogError_message << std::endl;
6192 // unit_test [4] up_thread_sorry_enable_event returnd illegal EVENT_TAG error check
6193 std::cout << "[4] up_thread_sorry_enable_event returnd illegal EVENT_TAG error check" << std::endl;
6194 test_obj.up_thread_module_event_map_clear();
6195 proto_test.handle_sorry_enable_res_tag = l7vs::protocol_module_base::FINALIZE;
6196 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
6197 l7vs::Logger::putLogError_id = 0;
6198 test_obj.test_call();
6199 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
6200 BOOST_CHECK_EQUAL(66,l7vs::Logger::putLogError_id);
6201 std::cout << l7vs::Logger::putLogError_message << std::endl;
6203 // mutex_lock_test test_lock_obj(vs,io);
6204 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);
6205 test_lock_obj.set_up_thread_sorry_enable_event_test();
6206 test_lock_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
6208 test_lock_obj.test_thread_wait.lock();
6209 test_lock_obj.befor_thread_id = proc_id;
6210 test_lock_obj.after_thread_id = proc_id;
6211 test_lock_obj.mutex_lock();
6213 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
6215 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
6216 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
6218 boost::thread::id test_id = test_thread.get_id();
6220 BOOST_CHECK(test_id != proc_id);
6223 test_lock_obj.test_thread_wait.unlock();
6226 // unit_test [5] up_thread_sorry_enable_event thread block test (mutex lock)
6227 std::cout << "[5] up_thread_sorry_enable_event thread block test (mutex lock)" << std::endl;
6228 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
6229 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
6231 test_lock_obj.mutex_unlock();
6234 // unit_test [6] up_thread_sorry_enable_event thread run test (mutex unlock)
6235 std::cout << "[6] up_thread_sorry_enable_event thread run test (mutex unlock)" << std::endl;
6236 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
6237 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
6239 BOOST_MESSAGE( "----- up_thread_sorry_enable_event test end -----" );
6242 // up_thread_sorry_disable_event test
6243 // up_thread_sorry_disable_event test class
6244 class up_thread_sorry_disable_event_test_class : public module_event_map_test_base_class{
6246 // 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){
6248 up_thread_sorry_disable_event_test_class(
6249 l7vs::virtualservice_tcp& vs,
6250 boost::asio::io_service& session_io,
6251 l7vs::tcp_socket_option_info& set_socket_option,
6252 boost::asio::ip::tcp::endpoint listen_endpoint,
6254 boost::asio::ssl::context& set_ssl_context,
6255 bool set_ssl_cache_flag,
6256 int set_ssl_handshake_time_out,
6257 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
6264 set_ssl_handshake_time_out,
6265 set_access_logger){};
6270 ~up_thread_sorry_disable_event_test_class(){};
6273 l7vs::tcp_session::up_thread_sorry_disable_event(LOCAL_PROC);
6277 void up_thread_sorry_disable_event_test(){
6279 BOOST_MESSAGE( "----- up_thread_sorry_disable_event test start -----" );
6281 boost::asio::io_service io;
6282 l7vs::virtualservice_tcp vs;
6283 l7vs::tcp_socket_option_info set_option;
6284 //! TCP_NODELAY (false:not set,true:set option)
6285 set_option.nodelay_opt = false;
6286 //! TCP_NODELAY option value (false:off,true:on)
6287 set_option.nodelay_val = false;
6288 //! TCP_CORK (false:not set,true:set option)
6289 set_option.cork_opt = false;
6290 //! TCP_CORK option value (false:off,true:on)
6291 set_option.cork_val = false;
6292 //! TCP_QUICKACK (false:not set,true:set option)
6293 set_option.quickack_opt = false;
6294 //! TCP_QUICKACK option value (false:off,true:on)
6295 set_option.quickack_val = false;
6297 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
6298 bool set_mode(false);
6299 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
6300 bool set_ssl_cache_flag(false);
6301 int set_ssl_handshake_time_out = 0;
6302 //std::string access_log_file_name = "test";
6303 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
6305 // up_thread_sorry_disable_event_test_class test_obj(vs,io);
6306 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);
6310 std::string test_protocol_name("test protocol");
6311 l7vs::test_protocol_module proto_test(test_protocol_name);
6313 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
6315 l7vs::protocol_module_base::EVENT_TAG chek_event[13];
6316 chek_event[0] = l7vs::protocol_module_base::ACCEPT;
6317 chek_event[1] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
6318 chek_event[2] = l7vs::protocol_module_base::CLIENT_RECV;
6319 chek_event[3] = l7vs::protocol_module_base::CLIENT_RESPONSE_SEND;
6320 chek_event[4] = l7vs::protocol_module_base::REALSERVER_SELECT;
6321 chek_event[5] = l7vs::protocol_module_base::REALSERVER_CONNECT;
6322 chek_event[6] = l7vs::protocol_module_base::REALSERVER_SEND;
6323 chek_event[7] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
6324 chek_event[8] = l7vs::protocol_module_base::SORRYSERVER_SELECT;
6325 chek_event[9] = l7vs::protocol_module_base::SORRYSERVER_CONNECT;
6326 chek_event[10] = l7vs::protocol_module_base::SORRYSERVER_SEND;
6327 chek_event[11] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
6328 chek_event[12] = l7vs::protocol_module_base::FINALIZE;
6330 // unit_test [1] up_thread_sorry_disable_event up_thread_next_call_function update check
6331 std::cout << "[1] up_thread_sorry_disable_event up_thread_next_call_function update check" << std::endl;
6332 for(int i = 0; i < 13;i++){
6333 proto_test.handle_sorry_disable_res_tag = chek_event[i];
6334 test_obj.test_call();
6335 BOOST_CHECK(test_obj.chk_up_thread_next_call_function(chek_event[i]));
6338 // unit_test [2] up_thread_sorry_disable_event module parameter check thread id
6339 std::cout << "[2] up_thread_sorry_disable_event module parameter check thread id" << std::endl;
6340 boost::thread::id def_id;
6341 boost::thread::id proc_id = boost::this_thread::get_id();
6342 test_obj.set_up_thread_id(proc_id);
6343 proto_test.handle_sorry_disable_thread_id = def_id;
6344 proto_test.handle_sorry_disable_res_tag = l7vs::protocol_module_base::FINALIZE;
6345 BOOST_CHECK(proto_test.handle_sorry_disable_thread_id != proc_id);
6346 test_obj.test_call();
6347 BOOST_CHECK(proto_test.handle_sorry_disable_thread_id == proc_id);
6349 // unit_test [3] up_thread_sorry_disable_event not fond function error check
6350 std::cout << "[3] up_thread_sorry_disable_event not fond function error check" << std::endl;
6351 test_obj.up_thread_function_array_clear();
6352 proto_test.handle_sorry_disable_res_tag = l7vs::protocol_module_base::FINALIZE;
6353 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
6354 l7vs::Logger::putLogError_id = 0;
6355 test_obj.test_call();
6356 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
6357 BOOST_CHECK_EQUAL(69,l7vs::Logger::putLogError_id);
6358 std::cout << l7vs::Logger::putLogError_message << std::endl;
6360 // unit_test [4] up_thread_sorry_disable_event returnd illegal EVENT_TAG error check
6361 std::cout << "[4] up_thread_sorry_disable_event returnd illegal EVENT_TAG error check" << std::endl;
6362 test_obj.up_thread_module_event_map_clear();
6363 proto_test.handle_sorry_disable_res_tag = l7vs::protocol_module_base::FINALIZE;
6364 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
6365 l7vs::Logger::putLogError_id = 0;
6366 test_obj.test_call();
6367 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
6368 BOOST_CHECK_EQUAL(68,l7vs::Logger::putLogError_id);
6369 std::cout << l7vs::Logger::putLogError_message << std::endl;
6371 // mutex_lock_test test_lock_obj(vs,io);
6372 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);
6373 test_lock_obj.set_up_thread_sorry_disable_event_test();
6374 test_lock_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
6376 test_lock_obj.test_thread_wait.lock();
6377 test_lock_obj.befor_thread_id = proc_id;
6378 test_lock_obj.after_thread_id = proc_id;
6379 test_lock_obj.mutex_lock();
6381 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
6383 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
6384 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
6386 boost::thread::id test_id = test_thread.get_id();
6388 BOOST_CHECK(test_id != proc_id);
6391 test_lock_obj.test_thread_wait.unlock();
6394 // unit_test [5] up_thread_sorry_disable_event thread block test (mutex lock)
6395 std::cout << "[5] up_thread_sorry_disable_event thread block test (mutex lock)" << std::endl;
6396 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
6397 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
6399 test_lock_obj.mutex_unlock();
6402 // unit_test [6] up_thread_sorry_disable_event thread run test (mutex unlock)
6403 std::cout << "[6] up_thread_sorry_disable_event thread run test (mutex unlock)" << std::endl;
6404 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
6405 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
6407 BOOST_MESSAGE( "----- up_thread_sorry_disable_event test end -----" );
6411 // down_thread_sorry_enable_event test
6412 // dwon_thread_sorry_enable_event test class
6413 class down_thread_sorry_enable_event_test_class : public module_event_map_test_base_class{
6415 // 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){
6417 down_thread_sorry_enable_event_test_class(
6418 l7vs::virtualservice_tcp& vs,
6419 boost::asio::io_service& session_io,
6420 l7vs::tcp_socket_option_info& set_socket_option,
6421 boost::asio::ip::tcp::endpoint listen_endpoint,
6423 boost::asio::ssl::context& set_ssl_context,
6424 bool set_ssl_cache_flag,
6425 int set_ssl_handshake_time_out,
6426 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
6433 set_ssl_handshake_time_out,
6434 set_access_logger){};
6438 ~down_thread_sorry_enable_event_test_class(){};
6441 l7vs::tcp_session::down_thread_sorry_enable_event(LOCAL_PROC);
6445 void down_thread_sorry_enable_event_test(){
6447 BOOST_MESSAGE( "----- down_thread_sorry_enable_event test start -----" );
6449 boost::asio::io_service io;
6450 l7vs::virtualservice_tcp vs;
6451 l7vs::tcp_socket_option_info set_option;
6452 //! TCP_NODELAY (false:not set,true:set option)
6453 set_option.nodelay_opt = false;
6454 //! TCP_NODELAY option value (false:off,true:on)
6455 set_option.nodelay_val = false;
6456 //! TCP_CORK (false:not set,true:set option)
6457 set_option.cork_opt = false;
6458 //! TCP_CORK option value (false:off,true:on)
6459 set_option.cork_val = false;
6460 //! TCP_QUICKACK (false:not set,true:set option)
6461 set_option.quickack_opt = false;
6462 //! TCP_QUICKACK option value (false:off,true:on)
6463 set_option.quickack_val = false;
6465 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
6466 bool set_mode(false);
6467 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
6468 bool set_ssl_cache_flag(false);
6469 int set_ssl_handshake_time_out = 0;
6470 //std::string access_log_file_name = "test";
6471 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
6473 // down_thread_sorry_enable_event_test_class test_obj(vs,io);
6474 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);
6476 std::string test_protocol_name("test protocol");
6477 l7vs::test_protocol_module proto_test(test_protocol_name);
6479 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
6481 l7vs::protocol_module_base::EVENT_TAG chek_event[7];
6482 chek_event[0] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
6483 chek_event[1] = l7vs::protocol_module_base::CLIENT_CONNECTION_CHECK;
6484 chek_event[2] = l7vs::protocol_module_base::REALSERVER_RECV;
6485 chek_event[3] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
6486 chek_event[4] = l7vs::protocol_module_base::SORRYSERVER_RECV;
6487 chek_event[5] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
6488 chek_event[6] = l7vs::protocol_module_base::FINALIZE;
6490 // unit_test [1] down_thread_sorry_enable_event up_thread_next_call_function update check
6491 std::cout << "[1] down_thread_sorry_enable_event up_thread_next_call_function update check" << std::endl;
6492 for(int i = 0; i < 7;i++){
6493 proto_test.handle_sorry_enable_res_tag = chek_event[i];
6494 test_obj.test_call();
6495 BOOST_CHECK(test_obj.chk_down_thread_next_call_function(chek_event[i]));
6498 // unit_test [2] down_thread_sorry_enable_event module parameter check thread id
6499 std::cout << "[2] down_thread_sorry_enable_event module parameter check thread id" << std::endl;
6500 boost::thread::id def_id;
6501 boost::thread::id proc_id = boost::this_thread::get_id();
6502 test_obj.set_down_thread_id(proc_id);
6503 proto_test.handle_sorry_enable_thread_id = def_id;
6504 proto_test.handle_sorry_enable_res_tag = l7vs::protocol_module_base::FINALIZE;
6505 BOOST_CHECK(proto_test.handle_sorry_enable_thread_id != proc_id);
6506 test_obj.test_call();
6507 BOOST_CHECK(proto_test.handle_sorry_enable_thread_id == proc_id);
6509 // unit_test [3] down_thread_sorry_enable_event not fond function error check
6510 std::cout << "[3] down_thread_sorry_enable_event not fond function error check" << std::endl;
6511 test_obj.down_thread_function_array_clear();
6512 proto_test.handle_sorry_enable_res_tag = l7vs::protocol_module_base::FINALIZE;
6513 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
6514 l7vs::Logger::putLogError_id = 0;
6515 test_obj.test_call();
6516 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
6517 BOOST_CHECK_EQUAL(97,l7vs::Logger::putLogError_id);
6518 std::cout << l7vs::Logger::putLogError_message << std::endl;
6520 // unit_test [4] down_thread_sorry_enable_event returnd illegal EVENT_TAG error check
6521 std::cout << "[4] down_thread_sorry_enable_event returnd illegal EVENT_TAG error check" << std::endl;
6522 test_obj.down_thread_module_event_map_clear();
6523 proto_test.handle_sorry_enable_res_tag = l7vs::protocol_module_base::FINALIZE;
6524 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
6525 l7vs::Logger::putLogError_id = 0;
6526 test_obj.test_call();
6527 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
6528 BOOST_CHECK_EQUAL(96,l7vs::Logger::putLogError_id);
6529 std::cout << l7vs::Logger::putLogError_message << std::endl;
6531 // mutex_lock_test test_lock_obj(vs,io);
6532 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);
6533 test_lock_obj.set_down_thread_sorry_enable_event_test();
6534 test_lock_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
6537 test_lock_obj.test_thread_wait.lock();
6538 test_lock_obj.befor_thread_id = proc_id;
6539 test_lock_obj.after_thread_id = proc_id;
6540 test_lock_obj.mutex_lock();
6542 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
6544 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
6545 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
6547 boost::thread::id test_id = test_thread.get_id();
6549 BOOST_CHECK(test_id != proc_id);
6552 test_lock_obj.test_thread_wait.unlock();
6555 // unit_test [5] down_thread_sorry_enable_event thread block test (mutex lock)
6556 std::cout << "[5] down_thread_sorry_enable_event thread block test (mutex lock)" << std::endl;
6557 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
6558 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
6560 test_lock_obj.mutex_unlock();
6563 // unit_test [6] down_thread_sorry_enable_event thread run test (mutex unlock)
6564 std::cout << "[6] down_thread_sorry_enable_event thread run test (mutex unlock)" << std::endl;
6565 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
6566 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
6568 BOOST_MESSAGE( "----- down_thread_sorry_enable_event test end -----" );
6570 // down_thread_sorry_disable_event test
6571 // dwon_thread_sorry_disable_event test class
6572 class down_thread_sorry_disable_event_test_class : public module_event_map_test_base_class{
6574 // 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){
6576 down_thread_sorry_disable_event_test_class(
6577 l7vs::virtualservice_tcp& vs,
6578 boost::asio::io_service& session_io,
6579 l7vs::tcp_socket_option_info& set_socket_option,
6580 boost::asio::ip::tcp::endpoint listen_endpoint,
6582 boost::asio::ssl::context& set_ssl_context,
6583 bool set_ssl_cache_flag,
6584 int set_ssl_handshake_time_out,
6585 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
6592 set_ssl_handshake_time_out,
6593 set_access_logger){};
6596 ~down_thread_sorry_disable_event_test_class(){};
6599 l7vs::tcp_session::down_thread_sorry_disable_event(LOCAL_PROC);
6603 void down_thread_sorry_disable_event_test(){
6605 BOOST_MESSAGE( "----- down_thread_sorry_disable_event test start -----" );
6607 boost::asio::io_service io;
6608 l7vs::virtualservice_tcp vs;
6609 l7vs::tcp_socket_option_info set_option;
6610 //! TCP_NODELAY (false:not set,true:set option)
6611 set_option.nodelay_opt = false;
6612 //! TCP_NODELAY option value (false:off,true:on)
6613 set_option.nodelay_val = false;
6614 //! TCP_CORK (false:not set,true:set option)
6615 set_option.cork_opt = false;
6616 //! TCP_CORK option value (false:off,true:on)
6617 set_option.cork_val = false;
6618 //! TCP_QUICKACK (false:not set,true:set option)
6619 set_option.quickack_opt = false;
6620 //! TCP_QUICKACK option value (false:off,true:on)
6621 set_option.quickack_val = false;
6623 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
6624 bool set_mode(false);
6625 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
6626 bool set_ssl_cache_flag(false);
6627 int set_ssl_handshake_time_out = 0;
6628 //std::string access_log_file_name = "test";
6629 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
6631 // down_thread_sorry_disable_event_test_class test_obj(vs,io);
6632 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);
6635 std::string test_protocol_name("test protocol");
6636 l7vs::test_protocol_module proto_test(test_protocol_name);
6638 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
6640 l7vs::protocol_module_base::EVENT_TAG chek_event[7];
6641 chek_event[0] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
6642 chek_event[1] = l7vs::protocol_module_base::CLIENT_CONNECTION_CHECK;
6643 chek_event[2] = l7vs::protocol_module_base::REALSERVER_RECV;
6644 chek_event[3] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
6645 chek_event[4] = l7vs::protocol_module_base::SORRYSERVER_RECV;
6646 chek_event[5] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
6647 chek_event[6] = l7vs::protocol_module_base::FINALIZE;
6649 // unit_test [1] down_thread_sorry_disable_event up_thread_next_call_function update check
6650 std::cout << "[1] down_thread_sorry_disable_event up_thread_next_call_function update check" << std::endl;
6651 for(int i = 0; i < 7;i++){
6652 proto_test.handle_sorry_disable_res_tag = chek_event[i];
6653 test_obj.test_call();
6654 BOOST_CHECK(test_obj.chk_down_thread_next_call_function(chek_event[i]));
6657 // unit_test [2] down_thread_sorry_disable_event module parameter check thread id
6658 std::cout << "[2] down_thread_sorry_disable_event module parameter check thread id" << std::endl;
6659 boost::thread::id def_id;
6660 boost::thread::id proc_id = boost::this_thread::get_id();
6661 test_obj.set_down_thread_id(proc_id);
6662 proto_test.handle_sorry_disable_thread_id = def_id;
6663 proto_test.handle_sorry_disable_res_tag = l7vs::protocol_module_base::FINALIZE;
6664 BOOST_CHECK(proto_test.handle_sorry_disable_thread_id != proc_id);
6665 test_obj.test_call();
6666 BOOST_CHECK(proto_test.handle_sorry_disable_thread_id == proc_id);
6668 // unit_test [3] down_thread_sorry_disable_event not fond function error check
6669 std::cout << "[3] down_thread_sorry_disable_event not fond function error check" << std::endl;
6670 test_obj.down_thread_function_array_clear();
6671 proto_test.handle_sorry_disable_res_tag = l7vs::protocol_module_base::FINALIZE;
6672 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
6673 l7vs::Logger::putLogError_id = 0;
6674 test_obj.test_call();
6675 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
6676 BOOST_CHECK_EQUAL(99,l7vs::Logger::putLogError_id);
6677 std::cout << l7vs::Logger::putLogError_message << std::endl;
6679 // unit_test [4] down_thread_sorry_disable_event returnd illegal EVENT_TAG error check
6680 std::cout << "[4] down_thread_sorry_disable_event returnd illegal EVENT_TAG error check" << std::endl;
6681 test_obj.down_thread_module_event_map_clear();
6682 proto_test.handle_sorry_disable_res_tag = l7vs::protocol_module_base::FINALIZE;
6683 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
6684 l7vs::Logger::putLogError_id = 0;
6685 test_obj.test_call();
6686 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
6687 BOOST_CHECK_EQUAL(98,l7vs::Logger::putLogError_id);
6688 std::cout << l7vs::Logger::putLogError_message << std::endl;
6690 // mutex_lock_test test_lock_obj(vs,io);
6691 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);
6692 test_lock_obj.set_down_thread_sorry_disable_event_test();
6693 test_lock_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
6695 test_lock_obj.test_thread_wait.lock();
6696 test_lock_obj.befor_thread_id = proc_id;
6697 test_lock_obj.after_thread_id = proc_id;
6698 test_lock_obj.mutex_lock();
6700 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
6702 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
6703 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
6705 boost::thread::id test_id = test_thread.get_id();
6707 BOOST_CHECK(test_id != proc_id);
6710 test_lock_obj.test_thread_wait.unlock();
6713 // unit_test [5] down_thread_sorry_disable_event thread block test (mutex lock)
6714 std::cout << "[5] down_thread_sorry_disable_event thread block test (mutex lock)" << std::endl;
6715 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
6716 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
6718 test_lock_obj.mutex_unlock();
6721 // unit_test [6] down_thread_sorry_disable_event thread run test (mutex unlock)
6722 std::cout << "[6] down_thread_sorry_disable_event thread run test (mutex unlock)" << std::endl;
6723 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
6724 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
6726 BOOST_MESSAGE( "----- down_thread_sorry_disable_event test end -----" );
6729 // up_thread_client_accept_event test
6730 // up_thread_client_accept_event test class
6731 class up_thread_client_accept_event_test_class : public module_event_map_test_base_class{
6733 // 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){
6735 up_thread_client_accept_event_test_class(
6736 l7vs::virtualservice_tcp& vs,
6737 boost::asio::io_service& session_io,
6738 l7vs::tcp_socket_option_info& set_socket_option,
6739 boost::asio::ip::tcp::endpoint listen_endpoint,
6741 boost::asio::ssl::context& set_ssl_context,
6742 bool set_ssl_cache_flag,
6743 int set_ssl_handshake_time_out,
6744 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
6751 set_ssl_handshake_time_out,
6752 set_access_logger){};
6755 ~up_thread_client_accept_event_test_class(){};
6758 l7vs::tcp_session::up_thread_client_accept_event(LOCAL_PROC);
6762 void up_thread_client_accept_event_test(){
6764 BOOST_MESSAGE( "----- up_thread_client_accept_event test start -----" );
6766 boost::asio::io_service io;
6767 l7vs::virtualservice_tcp vs;
6768 l7vs::tcp_socket_option_info set_option;
6769 //! TCP_NODELAY (false:not set,true:set option)
6770 set_option.nodelay_opt = false;
6771 //! TCP_NODELAY option value (false:off,true:on)
6772 set_option.nodelay_val = false;
6773 //! TCP_CORK (false:not set,true:set option)
6774 set_option.cork_opt = false;
6775 //! TCP_CORK option value (false:off,true:on)
6776 set_option.cork_val = false;
6777 //! TCP_QUICKACK (false:not set,true:set option)
6778 set_option.quickack_opt = false;
6779 //! TCP_QUICKACK option value (false:off,true:on)
6780 set_option.quickack_val = false;
6782 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
6783 bool set_mode(false);
6784 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
6785 bool set_ssl_cache_flag(false);
6786 int set_ssl_handshake_time_out = 0;
6787 //std::string access_log_file_name = "test";
6788 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
6790 // up_thread_client_accept_event_test_class test_obj(vs,io);
6791 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);
6793 std::string test_protocol_name("test protocol");
6794 l7vs::test_protocol_module proto_test(test_protocol_name);
6796 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
6798 l7vs::protocol_module_base::EVENT_TAG chek_event[13];
6799 chek_event[0] = l7vs::protocol_module_base::ACCEPT;
6800 chek_event[1] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
6801 chek_event[2] = l7vs::protocol_module_base::CLIENT_RECV;
6802 chek_event[3] = l7vs::protocol_module_base::CLIENT_RESPONSE_SEND;
6803 chek_event[4] = l7vs::protocol_module_base::REALSERVER_SELECT;
6804 chek_event[5] = l7vs::protocol_module_base::REALSERVER_CONNECT;
6805 chek_event[6] = l7vs::protocol_module_base::REALSERVER_SEND;
6806 chek_event[7] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
6807 chek_event[8] = l7vs::protocol_module_base::SORRYSERVER_SELECT;
6808 chek_event[9] = l7vs::protocol_module_base::SORRYSERVER_CONNECT;
6809 chek_event[10] = l7vs::protocol_module_base::SORRYSERVER_SEND;
6810 chek_event[11] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
6811 chek_event[12] = l7vs::protocol_module_base::FINALIZE;
6813 // unit_test [1] up_thread_client_accept_event up_thread_next_call_function update check
6814 std::cout << "[1] up_thread_client_accept_event up_thread_next_call_function update check" << std::endl;
6815 for(int i = 0; i < 13;i++){
6816 proto_test.handle_accept_res_tag = chek_event[i];
6817 test_obj.test_call();
6818 BOOST_CHECK(test_obj.chk_up_thread_next_call_function(chek_event[i]));
6821 // unit_test [2] up_thread_client_accept_event module parameter check thread id
6822 std::cout << "[2] up_thread_client_accept_event module parameter check thread id" << std::endl;
6823 boost::thread::id def_id;
6824 boost::thread::id proc_id = boost::this_thread::get_id();
6825 test_obj.set_up_thread_id(proc_id);
6826 proto_test.handle_accept_in_thread_id = def_id;
6827 proto_test.handle_accept_res_tag = l7vs::protocol_module_base::FINALIZE;
6828 BOOST_CHECK(proto_test.handle_accept_in_thread_id != proc_id);
6829 test_obj.test_call();
6830 BOOST_CHECK(proto_test.handle_accept_in_thread_id == proc_id);
6832 // unit_test [3] up_thread_client_accept_event not fond function error check
6833 std::cout << "[3] up_thread_client_accept_event not fond function error check" << std::endl;
6834 test_obj.up_thread_function_array_clear();
6835 proto_test.handle_accept_res_tag = l7vs::protocol_module_base::FINALIZE;
6836 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
6837 l7vs::Logger::putLogError_id = 0;
6838 test_obj.test_call();
6839 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
6840 BOOST_CHECK_EQUAL(19,l7vs::Logger::putLogError_id);
6841 std::cout << l7vs::Logger::putLogError_message << std::endl;
6843 // unit_test [4] up_thread_client_accept_event returnd illegal EVENT_TAG error check
6844 std::cout << "[4] up_thread_client_accept_event returnd illegal EVENT_TAG error check" << std::endl;
6845 test_obj.up_thread_module_event_map_clear();
6846 proto_test.handle_accept_res_tag = l7vs::protocol_module_base::FINALIZE;
6847 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
6848 l7vs::Logger::putLogError_id = 0;
6849 test_obj.test_call();
6850 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
6851 BOOST_CHECK_EQUAL(18,l7vs::Logger::putLogError_id);
6852 std::cout << l7vs::Logger::putLogError_message << std::endl;
6854 BOOST_MESSAGE( "----- up_thread_client_accept_event test end -----" );
6859 // up_thread_client_respond test
6860 // up_thread_client_respond test class
6861 class up_thread_client_respond_test_class : public l7vs::tcp_session{
6863 // up_thread_client_respond_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){
6865 up_thread_client_respond_test_class(
6866 l7vs::virtualservice_tcp& vs,
6867 boost::asio::io_service& session_io,
6868 l7vs::tcp_socket_option_info& set_socket_option,
6869 boost::asio::ip::tcp::endpoint listen_endpoint,
6871 boost::asio::ssl::context& set_ssl_context,
6872 bool set_ssl_cache_flag,
6873 int set_ssl_handshake_time_out,
6874 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
6881 set_ssl_handshake_time_out,
6882 set_access_logger){};
6885 ~up_thread_client_respond_test_class(){};
6888 l7vs::tcp_session::up_thread_client_respond(LOCAL_PROC);
6891 l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_up_thread_message_que(){
6892 return up_thread_message_que;
6895 l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_down_thread_message_que(){
6896 return down_thread_message_que;
6899 void up_thread_function_array_clear(){
6900 for(int i = 0;i <= UP_FUNC_EXIT;i++){
6901 up_thread_function_array[i].second = NULL;
6904 void up_thread_message_down_thread_function_map_clear(){
6905 up_thread_message_down_thread_function_map.clear();
6908 void up_thread_client_respond_event(const TCP_PROCESS_TYPE_TAG process_type){
6909 up_thread_client_respond_event_call_chek = true;
6911 bool up_thread_client_respond_event_call_chek;
6913 void down_thread_client_respond_event(const TCP_PROCESS_TYPE_TAG process_type){
6914 down_thread_client_respond_event_call_chek = true;
6916 bool down_thread_client_respond_event_call_chek;
6918 void up_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
6919 up_thread_exit_call_chek = true;
6921 bool up_thread_exit_call_chek;
6923 void up_thread_client_respond_test(){
6924 BOOST_MESSAGE( "----- up_thread_client_respond test start -----" );
6925 // boost::asio::io_service io;
6926 // l7vs::virtualservice_tcp vs;
6927 // up_thread_client_respond_test_class test_obj(vs,io);
6929 l7vs::virtualservice_tcp vs;
6930 boost::asio::io_service io;
6931 l7vs::tcp_socket_option_info set_option;
6932 //! TCP_NODELAY (false:not set,true:set option)
6933 set_option.nodelay_opt = false;
6934 //! TCP_NODELAY option value (false:off,true:on)
6935 set_option.nodelay_val = false;
6936 //! TCP_CORK (false:not set,true:set option)
6937 set_option.cork_opt = false;
6938 //! TCP_CORK option value (false:off,true:on)
6939 set_option.cork_val = false;
6940 //! TCP_QUICKACK (false:not set,true:set option)
6941 set_option.quickack_opt = false;
6942 //! TCP_QUICKACK option value (false:off,true:on)
6943 set_option.quickack_val = false;
6945 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
6946 bool set_mode(false);
6947 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
6948 bool set_ssl_cache_flag(false);
6949 int set_ssl_handshake_time_out = 0;
6950 //std::string access_log_file_name = "test";
6951 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
6953 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);
6957 l7vs::lockfree_queue<l7vs::tcp_thread_message>& up_thread_message_que = test_obj.get_up_thread_message_que();
6958 l7vs::lockfree_queue<l7vs::tcp_thread_message>& down_thread_message_que = test_obj.get_down_thread_message_que();
6960 BOOST_CHECK(up_thread_message_que.empty());
6961 BOOST_CHECK(down_thread_message_que.empty());
6963 test_obj.test_call();
6965 // unit_test [1] up_thread_client_respond up thread message set check
6966 std::cout << "[1] up_thread_client_respond up thread message set check" << std::endl;
6967 BOOST_CHECK(!up_thread_message_que.empty());
6968 l7vs::tcp_thread_message* up_msg = up_thread_message_que.pop();
6969 BOOST_CHECK(up_thread_message_que.empty());
6970 test_obj.up_thread_client_respond_event_call_chek = false;
6971 up_msg->message(l7vs::tcp_session::MESSAGE_PROC);
6972 BOOST_CHECK(test_obj.up_thread_client_respond_event_call_chek);
6975 // unit_test [2] up_thread_client_respond down thread message set check
6976 std::cout << "[2] up_thread_client_respond down thread message set check" << std::endl;
6977 BOOST_CHECK(!down_thread_message_que.empty());
6978 l7vs::tcp_thread_message* down_msg = down_thread_message_que.pop();
6979 BOOST_CHECK(down_thread_message_que.empty());
6980 test_obj.down_thread_client_respond_event_call_chek = false;
6981 down_msg->message(l7vs::tcp_session::MESSAGE_PROC);
6982 BOOST_CHECK(test_obj.down_thread_client_respond_event_call_chek);
6985 // unit_test [3] up_thread_client_respond not fond down_thread_client_respond_event function error check
6986 std::cout << "[3] up_thread_client_respond not fond down_thread_client_respond_event function error check" << std::endl;
6987 test_obj.up_thread_message_down_thread_function_map_clear();
6988 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
6989 l7vs::Logger::putLogError_id = 0;
6990 test_obj.up_thread_exit_call_chek = false;
6991 test_obj.test_call();
6992 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
6993 BOOST_CHECK_EQUAL(23,l7vs::Logger::putLogError_id);
6994 std::cout << l7vs::Logger::putLogError_message << std::endl;
6995 BOOST_CHECK(test_obj.up_thread_exit_call_chek);
6997 // unit_test [4] up_thread_client_respond not fond up_thread_client_respond_event function error check
6998 std::cout << "[4] up_thread_client_respond not fond up_thread_client_respond_event function error check" << std::endl;
6999 test_obj.up_thread_function_array_clear();
7000 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
7001 l7vs::Logger::putLogError_id = 0;
7002 test_obj.up_thread_exit_call_chek = false;
7003 test_obj.test_call();
7004 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
7005 BOOST_CHECK_EQUAL(22,l7vs::Logger::putLogError_id);
7006 std::cout << l7vs::Logger::putLogError_message << std::endl;
7007 BOOST_CHECK(test_obj.up_thread_exit_call_chek);
7009 BOOST_MESSAGE( "----- up_thread_client_respond test end -----" );
7013 // up_thread_client_respond_event test
7014 // up_thread_client_respond_event test class
7015 class up_thread_client_respond_event_test_class : public module_event_map_test_base_class{
7017 // 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){
7019 up_thread_client_respond_event_test_class(
7020 l7vs::virtualservice_tcp& vs,
7021 boost::asio::io_service& session_io,
7022 l7vs::tcp_socket_option_info& set_socket_option,
7023 boost::asio::ip::tcp::endpoint listen_endpoint,
7025 boost::asio::ssl::context& set_ssl_context,
7026 bool set_ssl_cache_flag,
7027 int set_ssl_handshake_time_out,
7028 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
7035 set_ssl_handshake_time_out,
7036 set_access_logger){};
7039 ~up_thread_client_respond_event_test_class(){};
7042 l7vs::tcp_session::up_thread_client_respond_event(LOCAL_PROC);
7046 void up_thread_client_respond_event_test(){
7048 BOOST_MESSAGE( "----- up_thread_client_respond_event test start -----" );
7050 // boost::asio::io_service io;
7051 // l7vs::virtualservice_tcp vs;
7052 // up_thread_client_respond_event_test_class test_obj(vs,io);
7053 l7vs::virtualservice_tcp vs;
7054 boost::asio::io_service io;
7055 l7vs::tcp_socket_option_info set_option;
7056 //! TCP_NODELAY (false:not set,true:set option)
7057 set_option.nodelay_opt = false;
7058 //! TCP_NODELAY option value (false:off,true:on)
7059 set_option.nodelay_val = false;
7060 //! TCP_CORK (false:not set,true:set option)
7061 set_option.cork_opt = false;
7062 //! TCP_CORK option value (false:off,true:on)
7063 set_option.cork_val = false;
7064 //! TCP_QUICKACK (false:not set,true:set option)
7065 set_option.quickack_opt = false;
7066 //! TCP_QUICKACK option value (false:off,true:on)
7067 set_option.quickack_val = false;
7069 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
7070 bool set_mode(false);
7071 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
7072 bool set_ssl_cache_flag(false);
7073 int set_ssl_handshake_time_out = 0;
7074 //std::string access_log_file_name = "test";
7075 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
7077 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);
7080 std::string test_protocol_name("test protocol");
7081 l7vs::test_protocol_module proto_test(test_protocol_name);
7083 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
7085 l7vs::protocol_module_base::EVENT_TAG chek_event[13];
7086 chek_event[0] = l7vs::protocol_module_base::ACCEPT;
7087 chek_event[1] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
7088 chek_event[2] = l7vs::protocol_module_base::CLIENT_RECV;
7089 chek_event[3] = l7vs::protocol_module_base::CLIENT_RESPONSE_SEND;
7090 chek_event[4] = l7vs::protocol_module_base::REALSERVER_SELECT;
7091 chek_event[5] = l7vs::protocol_module_base::REALSERVER_CONNECT;
7092 chek_event[6] = l7vs::protocol_module_base::REALSERVER_SEND;
7093 chek_event[7] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
7094 chek_event[8] = l7vs::protocol_module_base::SORRYSERVER_SELECT;
7095 chek_event[9] = l7vs::protocol_module_base::SORRYSERVER_CONNECT;
7096 chek_event[10] = l7vs::protocol_module_base::SORRYSERVER_SEND;
7097 chek_event[11] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
7098 chek_event[12] = l7vs::protocol_module_base::FINALIZE;
7100 // unit_test [1] up_thread_client_respond_event up_thread_next_call_function update check
7101 std::cout << "[1] up_thread_client_respond_event up_thread_next_call_function update check" << std::endl;
7102 for(int i = 0; i < 13;i++){
7103 proto_test.handle_response_send_inform_res_tag = chek_event[i];
7104 test_obj.test_call();
7105 BOOST_CHECK(test_obj.chk_up_thread_next_call_function(chek_event[i]));
7108 // unit_test [2] up_thread_client_respond_event module parameter check thread id
7109 std::cout << "[2] up_thread_client_respond_event module parameter check thread id" << std::endl;
7110 boost::thread::id def_id;
7111 boost::thread::id proc_id = boost::this_thread::get_id();
7112 test_obj.set_up_thread_id(proc_id);
7113 proto_test.handle_response_send_inform_thread_id = def_id;
7114 proto_test.handle_response_send_inform_res_tag = l7vs::protocol_module_base::FINALIZE;
7115 BOOST_CHECK(proto_test.handle_response_send_inform_thread_id != proc_id);
7116 test_obj.test_call();
7117 BOOST_CHECK(proto_test.handle_response_send_inform_thread_id == proc_id);
7119 // unit_test [3] up_thread_client_respond_event not fond function error check
7120 std::cout << "[3] up_thread_client_respond_event not fond function error check" << std::endl;
7121 test_obj.up_thread_function_array_clear();
7122 proto_test.handle_response_send_inform_res_tag = l7vs::protocol_module_base::FINALIZE;
7123 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
7124 l7vs::Logger::putLogError_id = 0;
7125 test_obj.test_call();
7126 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
7127 BOOST_CHECK_EQUAL(25,l7vs::Logger::putLogError_id);
7128 std::cout << l7vs::Logger::putLogError_message << std::endl;
7130 // unit_test [4] up_thread_client_respond_event returnd illegal EVENT_TAG error check
7131 std::cout << "[4] up_thread_client_respond_event returnd illegal EVENT_TAG error check" << std::endl;
7132 test_obj.up_thread_module_event_map_clear();
7133 proto_test.handle_response_send_inform_res_tag = l7vs::protocol_module_base::FINALIZE;
7134 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
7135 l7vs::Logger::putLogError_id = 0;
7136 test_obj.test_call();
7137 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
7138 BOOST_CHECK_EQUAL(24,l7vs::Logger::putLogError_id);
7139 std::cout << l7vs::Logger::putLogError_message << std::endl;
7141 // mutex_lock_test test_lock_obj(vs,io);
7142 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);
7143 test_lock_obj.set_up_thread_client_respond_event_test();
7144 test_lock_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
7146 test_lock_obj.test_thread_wait.lock();
7147 test_lock_obj.befor_thread_id = proc_id;
7148 test_lock_obj.after_thread_id = proc_id;
7149 test_lock_obj.mutex_lock();
7151 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
7153 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
7154 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
7156 boost::thread::id test_id = test_thread.get_id();
7158 BOOST_CHECK(test_id != proc_id);
7161 test_lock_obj.test_thread_wait.unlock();
7164 // unit_test [5] up_thread_client_respond_event thread block test (mutex lock)
7165 std::cout << "[5] up_thread_client_respond_event thread block test (mutex lock)" << std::endl;
7166 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
7167 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
7169 test_lock_obj.mutex_unlock();
7172 // unit_test [6] up_thread_client_respond_event thread run test (mutex unlock)
7173 std::cout << "[6] up_thread_client_respond_event thread run test (mutex unlock)" << std::endl;
7174 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
7175 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
7177 BOOST_MESSAGE( "----- up_thread_client_respond_event test end -----" );
7182 // down_thread_client_respond_event test
7183 // dwon_thread_client_respond_event test class
7184 class down_thread_client_respond_event_test_class : public module_event_map_test_base_class{
7186 // 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){
7188 down_thread_client_respond_event_test_class(
7189 l7vs::virtualservice_tcp& vs,
7190 boost::asio::io_service& session_io,
7191 l7vs::tcp_socket_option_info& set_socket_option,
7192 boost::asio::ip::tcp::endpoint listen_endpoint,
7194 boost::asio::ssl::context& set_ssl_context,
7195 bool set_ssl_cache_flag,
7196 int set_ssl_handshake_time_out,
7197 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
7204 set_ssl_handshake_time_out,
7205 set_access_logger){};
7208 ~down_thread_client_respond_event_test_class(){};
7211 l7vs::tcp_session::down_thread_client_respond_event(LOCAL_PROC);
7215 void down_thread_client_respond_event_test(){
7217 BOOST_MESSAGE( "----- down_thread_client_respond_event test start -----" );
7219 // boost::asio::io_service io;
7220 // l7vs::virtualservice_tcp vs;
7221 // down_thread_client_respond_event_test_class test_obj(vs,io);
7222 l7vs::virtualservice_tcp vs;
7223 boost::asio::io_service io;
7224 l7vs::tcp_socket_option_info set_option;
7225 //! TCP_NODELAY (false:not set,true:set option)
7226 set_option.nodelay_opt = false;
7227 //! TCP_NODELAY option value (false:off,true:on)
7228 set_option.nodelay_val = false;
7229 //! TCP_CORK (false:not set,true:set option)
7230 set_option.cork_opt = false;
7231 //! TCP_CORK option value (false:off,true:on)
7232 set_option.cork_val = false;
7233 //! TCP_QUICKACK (false:not set,true:set option)
7234 set_option.quickack_opt = false;
7235 //! TCP_QUICKACK option value (false:off,true:on)
7236 set_option.quickack_val = false;
7238 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
7239 bool set_mode(false);
7240 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
7241 bool set_ssl_cache_flag(false);
7242 int set_ssl_handshake_time_out = 0;
7243 //std::string access_log_file_name = "test";
7244 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
7246 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);
7249 std::string test_protocol_name("test protocol");
7250 l7vs::test_protocol_module proto_test(test_protocol_name);
7252 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
7254 l7vs::protocol_module_base::EVENT_TAG chek_event[7];
7255 chek_event[0] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
7256 chek_event[1] = l7vs::protocol_module_base::CLIENT_CONNECTION_CHECK;
7257 chek_event[2] = l7vs::protocol_module_base::REALSERVER_RECV;
7258 chek_event[3] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
7259 chek_event[4] = l7vs::protocol_module_base::SORRYSERVER_RECV;
7260 chek_event[5] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
7261 chek_event[6] = l7vs::protocol_module_base::FINALIZE;
7263 // unit_test [1] down_thread_client_respond_event down_thread_next_call_function update check
7264 std::cout << "[1] down_thread_client_respond_event down_thread_next_call_function update check" << std::endl;
7265 for(int i = 0; i < 7;i++){
7266 proto_test.handle_response_send_inform_res_tag = chek_event[i];
7267 test_obj.test_call();
7268 BOOST_CHECK(test_obj.chk_down_thread_next_call_function(chek_event[i]));
7271 // unit_test [2] down_thread_client_respond_event module parameter check thread id
7272 std::cout << "[2] down_thread_client_respond_event module parameter check thread id" << std::endl;
7273 boost::thread::id def_id;
7274 boost::thread::id proc_id = boost::this_thread::get_id();
7275 test_obj.set_down_thread_id(proc_id);
7276 proto_test.handle_response_send_inform_thread_id = def_id;
7277 proto_test.handle_response_send_inform_res_tag = l7vs::protocol_module_base::FINALIZE;
7278 BOOST_CHECK(proto_test.handle_response_send_inform_thread_id != proc_id);
7279 test_obj.test_call();
7280 BOOST_CHECK(proto_test.handle_response_send_inform_thread_id == proc_id);
7282 // unit_test [3] down_thread_client_respond_event not fond function error check
7283 std::cout << "[3] down_thread_client_respond_event not fond function error check" << std::endl;
7284 test_obj.down_thread_function_array_clear();
7285 proto_test.handle_response_send_inform_res_tag = l7vs::protocol_module_base::FINALIZE;
7286 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
7287 l7vs::Logger::putLogError_id = 0;
7288 test_obj.test_call();
7289 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
7290 BOOST_CHECK_EQUAL(81,l7vs::Logger::putLogError_id);
7291 std::cout << l7vs::Logger::putLogError_message << std::endl;
7293 // unit_test [4] down_thread_client_respond_event returnd illegal EVENT_TAG error check
7294 std::cout << "[4] down_thread_client_respond_event returnd illegal EVENT_TAG error check" << std::endl;
7295 test_obj.down_thread_module_event_map_clear();
7296 proto_test.handle_response_send_inform_res_tag = l7vs::protocol_module_base::FINALIZE;
7297 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
7298 l7vs::Logger::putLogError_id = 0;
7299 test_obj.test_call();
7300 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
7301 BOOST_CHECK_EQUAL(80,l7vs::Logger::putLogError_id);
7302 std::cout << l7vs::Logger::putLogError_message << std::endl;
7304 // mutex_lock_test test_lock_obj(vs,io);
7305 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);
7306 test_lock_obj.set_down_thread_client_respond_event_test();
7307 test_lock_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
7309 test_lock_obj.test_thread_wait.lock();
7310 test_lock_obj.befor_thread_id = proc_id;
7311 test_lock_obj.after_thread_id = proc_id;
7312 test_lock_obj.mutex_lock();
7314 boost::thread test_thread(boost::bind(&mutex_lock_test::test_run,&test_lock_obj));
7316 BOOST_CHECK(test_lock_obj.befor_thread_id == proc_id);
7317 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
7319 boost::thread::id test_id = test_thread.get_id();
7321 BOOST_CHECK(test_id != proc_id);
7324 test_lock_obj.test_thread_wait.unlock();
7327 // unit_test [5] down_thread_client_respond_event thread block test (mutex lock)
7328 std::cout << "[5] down_thread_client_respond_event thread block test (mutex lock)" << std::endl;
7329 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
7330 BOOST_CHECK(test_lock_obj.after_thread_id == proc_id);
7332 test_lock_obj.mutex_unlock();
7335 // unit_test [6] down_thread_client_respond_event thread run test (mutex unlock)
7336 std::cout << "[6] down_thread_client_respond_event thread run test (mutex unlock)" << std::endl;
7337 BOOST_CHECK(test_lock_obj.befor_thread_id == test_id);
7338 BOOST_CHECK(test_lock_obj.after_thread_id == test_id);
7340 BOOST_MESSAGE( "----- down_thread_client_respond_event test end -----" );
7344 // up_thread_all_socket_close test
7345 // up_thread_all_socket_close test class
7346 class up_thread_all_socket_close_test_class : public l7vs::tcp_session{
7348 // up_thread_all_socket_close_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){
7350 up_thread_all_socket_close_test_class(
7351 l7vs::virtualservice_tcp& vs,
7352 boost::asio::io_service& session_io,
7353 l7vs::tcp_socket_option_info& set_socket_option,
7354 boost::asio::ip::tcp::endpoint listen_endpoint,
7356 boost::asio::ssl::context& set_ssl_context,
7357 bool set_ssl_cache_flag,
7358 int set_ssl_handshake_time_out,
7359 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
7366 set_ssl_handshake_time_out,
7367 set_access_logger){};
7369 ~up_thread_all_socket_close_test_class(){};
7372 tcp_session::up_thread_all_socket_close();
7375 l7vs::tcp_socket& get_client_socket(){
7376 return client_socket;
7378 l7vs::tcp_ssl_socket& get_client_ssl_socket(){
7379 return client_ssl_socket;
7382 boost::shared_ptr< l7vs::tcp_socket > get_sorry_socket(){
7383 return sorryserver_socket.second;
7386 std::map<endpoint,tcp_socket_ptr>& get_up_thread_send_realserver_socket_map(){
7387 return up_thread_send_realserver_socket_map;
7390 l7vs::tcp_realserver_connect_socket_list& get_down_thread_connect_socket_list(){
7391 return down_thread_connect_socket_list;
7394 void up_thread_all_socket_close_test(){
7395 BOOST_MESSAGE( "----- up_thread_all_socket_close test start -----" );
7396 // boost::asio::io_service io;
7397 // l7vs::virtualservice_tcp vs;
7398 // up_thread_all_socket_close_test_class test_obj(vs,io);
7399 l7vs::virtualservice_tcp vs;
7400 boost::asio::io_service io;
7401 l7vs::tcp_socket_option_info set_option;
7402 //! TCP_NODELAY (false:not set,true:set option)
7403 set_option.nodelay_opt = false;
7404 //! TCP_NODELAY option value (false:off,true:on)
7405 set_option.nodelay_val = false;
7406 //! TCP_CORK (false:not set,true:set option)
7407 set_option.cork_opt = false;
7408 //! TCP_CORK option value (false:off,true:on)
7409 set_option.cork_val = false;
7410 //! TCP_QUICKACK (false:not set,true:set option)
7411 set_option.quickack_opt = false;
7412 //! TCP_QUICKACK option value (false:off,true:on)
7413 set_option.quickack_val = false;
7415 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
7416 bool set_mode(false);
7417 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
7418 bool set_ssl_cache_flag(false);
7419 int set_ssl_handshake_time_out = 0;
7420 //std::string access_log_file_name = "test";
7421 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
7423 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);
7426 l7vs::tcp_socket& client_socket = test_obj.get_client_socket();
7427 client_socket.close_call_check = false;
7428 l7vs::tcp_socket& sorry_socket = *(test_obj.get_sorry_socket());
7429 sorry_socket.close_call_check = false;
7430 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();
7431 std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > pair_socket;
7432 std::list< std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > > rs_socket_list;
7433 std::list< std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > >::iterator rs_list_it;
7434 pair_socket.first.address(boost::asio::ip::address::from_string(DUMMI_SERVER_IP));
7435 vs.connection_inactive_list.clear();
7436 std::list<boost::asio::ip::tcp::endpoint>::iterator inact_list_it;
7437 l7vs::tcp_realserver_connect_socket_list& connect_socket_list = test_obj.get_down_thread_connect_socket_list();
7439 for(int i = 0; i < 1024;i++){
7440 pair_socket.first.port(i);
7441 boost::shared_ptr< l7vs::tcp_socket > new_socket(new l7vs::tcp_socket(io));
7442 pair_socket.second = new_socket;
7443 new_socket->close_call_check = false;
7444 new_socket->close_res = true;
7445 rs_socket_list.push_back(pair_socket);
7446 up_thread_send_realserver_socket_map.insert(pair_socket);
7447 connect_socket_list.push_back(pair_socket);
7449 BOOST_CHECK(!up_thread_send_realserver_socket_map.empty());
7450 BOOST_CHECK(!connect_socket_list.empty());
7451 BOOST_CHECK(!rs_socket_list.empty());
7453 test_obj.test_call();
7455 // unit_test [1] up_thread_all_socket_close realserver socket close call check
7456 std::cout << "[1] up_thread_all_socket_close realserver socket close call check" << std::endl;
7457 rs_list_it = rs_socket_list.begin();
7458 for(int i = 0; i < 1024;i++){
7459 BOOST_CHECK(rs_list_it->second->close_call_check);
7463 // unit_test [2] up_thread_all_socket_close parent virtual service connection incactive call check
7464 std::cout << "[2] up_thread_all_socket_close parent virtual service connection incactive call check" << std::endl;
7465 rs_list_it = rs_socket_list.begin();
7466 for(int i = 0; i < 1024;i++){
7467 inact_list_it = vs.connection_inactive_list.begin();
7468 while(inact_list_it != vs.connection_inactive_list.end()){
7469 if(*inact_list_it == rs_list_it->first)
7473 BOOST_CHECK(inact_list_it != vs.connection_inactive_list.end());
7474 vs.connection_inactive_list.erase(inact_list_it);
7477 BOOST_CHECK(vs.connection_inactive_list.empty());
7479 // unit_test [3] up_thread_all_socket_close realserver send socket map clear check
7480 std::cout << "[3] up_thread_all_socket_close realserver send socket map clear check" << std::endl;
7481 BOOST_CHECK(up_thread_send_realserver_socket_map.empty());
7483 // unit_test [4] up_thread_all_socket_close down thread connect socket list clear check
7484 std::cout << "[4] up_thread_all_socket_close down thread connect socket list clear check" << std::endl;
7485 BOOST_CHECK(connect_socket_list.empty());
7487 // unit_test [5] up_thread_all_socket_close client socket close call check
7488 std::cout << "[5] up_thread_all_socket_close client socket close call check" << std::endl;
7489 BOOST_CHECK(client_socket.close_call_check);
7491 // unit_test [6] up_thread_all_socket_close sorry socket close call check
7492 std::cout << "[6] up_thread_all_socket_close sorry socket close call check" << std::endl;
7493 BOOST_CHECK(sorry_socket.close_call_check);
7496 rs_list_it = rs_socket_list.begin();
7497 for(int i = 0; i < 1024;i++){
7498 rs_list_it->second->close_res = false;
7499 up_thread_send_realserver_socket_map.insert(*rs_list_it);
7503 test_obj.test_call();
7505 // unit_test [7] up_thread_all_socket_close closed socket parent virtual service connection incactive not call check
7506 std::cout << "[7] up_thread_all_socket_close closed socket parent virtual service connection incactive not call check" << std::endl;
7507 BOOST_CHECK(vs.connection_inactive_list.empty());
7510 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);
7511 l7vs::tcp_ssl_socket& client_ssl_socket = ssl_test_obj.get_client_ssl_socket();
7512 client_ssl_socket.close_call_check = false;
7514 ssl_test_obj.test_call();
7516 // unit_test [8] up_thread_all_socket_close client ssl socket close call check
7517 std::cout << "[8] up_thread_all_socket_close client ssl socket close call check" << std::endl;
7518 BOOST_CHECK(client_ssl_socket.close_call_check);
7520 BOOST_MESSAGE( "----- up_thread_all_socket_close test end -----" );
7523 // down_thread_all_socket_close test
7524 // down_thread_all_socket_close test class
7525 class down_thread_all_socket_close_test_class : public l7vs::tcp_session{
7527 // down_thread_all_socket_close_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){
7529 down_thread_all_socket_close_test_class(
7530 l7vs::virtualservice_tcp& vs,
7531 boost::asio::io_service& session_io,
7532 l7vs::tcp_socket_option_info& set_socket_option,
7533 boost::asio::ip::tcp::endpoint listen_endpoint,
7535 boost::asio::ssl::context& set_ssl_context,
7536 bool set_ssl_cache_flag,
7537 int set_ssl_handshake_time_out,
7538 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
7545 set_ssl_handshake_time_out,
7546 set_access_logger){};
7548 ~down_thread_all_socket_close_test_class(){};
7550 tcp_session::down_thread_all_socket_close();
7552 l7vs::tcp_socket& get_client_socket(){
7553 return client_socket;
7555 l7vs::tcp_ssl_socket& get_client_ssl_socket(){
7556 return client_ssl_socket;
7558 boost::shared_ptr< l7vs::tcp_socket > get_sorry_socket(){
7559 return sorryserver_socket.second;
7561 std::list<socket_element>& get_down_thread_receive_realserver_socket_list(){
7562 return down_thread_receive_realserver_socket_list;
7565 void down_thread_all_socket_close_test(){
7566 BOOST_MESSAGE( "----- down_thread_all_socket_close test start -----" );
7567 // boost::asio::io_service io;
7568 // l7vs::virtualservice_tcp vs;
7569 // down_thread_all_socket_close_test_class test_obj(vs,io);
7570 l7vs::virtualservice_tcp vs;
7571 boost::asio::io_service io;
7572 l7vs::tcp_socket_option_info set_option;
7573 //! TCP_NODELAY (false:not set,true:set option)
7574 set_option.nodelay_opt = false;
7575 //! TCP_NODELAY option value (false:off,true:on)
7576 set_option.nodelay_val = false;
7577 //! TCP_CORK (false:not set,true:set option)
7578 set_option.cork_opt = false;
7579 //! TCP_CORK option value (false:off,true:on)
7580 set_option.cork_val = false;
7581 //! TCP_QUICKACK (false:not set,true:set option)
7582 set_option.quickack_opt = false;
7583 //! TCP_QUICKACK option value (false:off,true:on)
7584 set_option.quickack_val = false;
7586 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
7587 bool set_mode(false);
7588 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
7589 bool set_ssl_cache_flag(false);
7590 int set_ssl_handshake_time_out = 0;
7591 //std::string access_log_file_name = "test";
7592 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
7594 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);
7598 l7vs::tcp_socket& client_socket = test_obj.get_client_socket();
7599 client_socket.close_call_check = false;
7600 l7vs::tcp_socket& sorry_socket = *(test_obj.get_sorry_socket());
7601 sorry_socket.close_call_check = false;
7602 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();
7603 std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > pair_socket;
7604 std::list< std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > > rs_socket_list;
7605 std::list< std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > >::iterator rs_list_it;
7606 pair_socket.first.address(boost::asio::ip::address::from_string(DUMMI_SERVER_IP));
7607 vs.connection_inactive_list.clear();
7608 std::list<boost::asio::ip::tcp::endpoint>::iterator inact_list_it;
7610 for(int i = 0; i < 1024;i++){
7611 pair_socket.first.port(i);
7612 boost::shared_ptr< l7vs::tcp_socket > new_socket(new l7vs::tcp_socket(io));
7613 pair_socket.second = new_socket;
7614 new_socket->close_call_check = false;
7615 new_socket->close_res = true;
7616 rs_socket_list.push_back(pair_socket);
7617 down_thread_receive_realserver_socket_list.push_back(pair_socket);
7619 BOOST_CHECK(!down_thread_receive_realserver_socket_list.empty());
7620 BOOST_CHECK(!rs_socket_list.empty());
7622 test_obj.test_call();
7624 // unit_test [1] down_thread_all_socket_close realserver socket close call check
7625 std::cout << "[1] down_thread_all_socket_close realserver socket close call check" << std::endl;
7626 rs_list_it = rs_socket_list.begin();
7627 for(int i = 0; i < 1024;i++){
7628 BOOST_CHECK(rs_list_it->second->close_call_check);
7632 // unit_test [2] down_thread_all_socket_close parent virtual service connection incactive call check
7633 std::cout << "[2] down_thread_all_socket_close parent virtual service connection incactive call check" << std::endl;
7634 rs_list_it = rs_socket_list.begin();
7635 for(int i = 0; i < 1024;i++){
7636 inact_list_it = vs.connection_inactive_list.begin();
7637 while(inact_list_it != vs.connection_inactive_list.end()){
7638 if(*inact_list_it == rs_list_it->first)
7642 BOOST_CHECK(inact_list_it != vs.connection_inactive_list.end());
7643 vs.connection_inactive_list.erase(inact_list_it);
7646 BOOST_CHECK(vs.connection_inactive_list.empty());
7648 // unit_test [3] down_thread_all_socket_close realserver receive socket list clear check
7649 std::cout << "[3] down_thread_all_socket_close realserver receive socket list clear check" << std::endl;
7650 BOOST_CHECK(down_thread_receive_realserver_socket_list.empty());
7652 // unit_test [4] up_thread_all_socket_close client socket close call check
7653 std::cout << "[4] up_thread_all_socket_close client socket close call check" << std::endl;
7654 BOOST_CHECK(client_socket.close_call_check);
7656 // unit_test [5] up_thread_all_socket_close sorry socket close call check
7657 std::cout << "[5] up_thread_all_socket_close sorry socket close call check" << std::endl;
7658 BOOST_CHECK(sorry_socket.close_call_check);
7660 rs_list_it = rs_socket_list.begin();
7661 for(int i = 0; i < 1024;i++){
7662 rs_list_it->second->close_res = false;
7663 down_thread_receive_realserver_socket_list.push_back(*rs_list_it);
7667 test_obj.test_call();
7669 // unit_test [6] down_thread_all_socket_close closed socket parent virtual service connection incactive not call check
7670 std::cout << "[6] down_thread_all_socket_close closed socket parent virtual service connection incactive not call check" << std::endl;
7671 BOOST_CHECK(vs.connection_inactive_list.empty());
7674 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);
7675 l7vs::tcp_ssl_socket& client_ssl_socket = ssl_test_obj.get_client_ssl_socket();
7676 client_ssl_socket.close_call_check = false;
7678 ssl_test_obj.test_call();
7680 // unit_test [7] up_thread_all_socket_close client ssl socket close call check
7681 std::cout << "[7] up_thread_all_socket_close client ssl socket close call check" << std::endl;
7682 BOOST_CHECK(client_ssl_socket.close_call_check);
7684 BOOST_MESSAGE( "----- down_thread_all_socket_close test end -----" );
7687 // up_thread_client_disconnect test
7688 // up_thread_client_disconnect test class
7689 class up_thread_client_disconnect : public l7vs::tcp_session{
7691 // up_thread_client_disconnect(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){
7693 up_thread_client_disconnect(
7694 l7vs::virtualservice_tcp& vs,
7695 boost::asio::io_service& session_io,
7696 l7vs::tcp_socket_option_info& set_socket_option,
7697 boost::asio::ip::tcp::endpoint listen_endpoint,
7699 boost::asio::ssl::context& set_ssl_context,
7700 bool set_ssl_cache_flag,
7701 int set_ssl_handshake_time_out,
7702 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
7709 set_ssl_handshake_time_out,
7710 set_access_logger){};
7712 ~up_thread_client_disconnect(){};
7715 l7vs::tcp_session::up_thread_client_disconnect(LOCAL_PROC);
7718 l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_up_thread_message_que(){
7719 return up_thread_message_que;
7722 l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_down_thread_message_que(){
7723 return down_thread_message_que;
7726 void up_thread_function_array_clear(){
7727 for(int i = 0;i <= UP_FUNC_EXIT;i++){
7728 up_thread_function_array[i].second = NULL;
7731 void up_thread_message_down_thread_function_map_clear(){
7732 up_thread_message_down_thread_function_map.clear();
7735 void up_thread_client_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){
7736 up_thread_client_disconnect_event_call_chek = true;
7738 bool up_thread_client_disconnect_event_call_chek;
7740 void down_thread_client_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){
7741 down_thread_client_disconnect_event_call_chek = true;
7743 bool down_thread_client_disconnect_event_call_chek;
7745 void up_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
7746 up_thread_exit_call_chek = true;
7748 bool up_thread_exit_call_chek;
7750 l7vs::tcp_socket& get_client_socket(){
7751 return client_socket;
7753 l7vs::tcp_ssl_socket& get_client_ssl_socket(){
7754 return client_ssl_socket;
7758 void up_thread_client_disconnect_test(){
7759 BOOST_MESSAGE( "----- up_thread_client_disconnect test start -----" );
7760 // boost::asio::io_service io;
7761 // l7vs::virtualservice_tcp vs;
7762 // up_thread_client_disconnect test_obj(vs,io);
7763 l7vs::virtualservice_tcp vs;
7764 boost::asio::io_service io;
7765 l7vs::tcp_socket_option_info set_option;
7766 //! TCP_NODELAY (false:not set,true:set option)
7767 set_option.nodelay_opt = false;
7768 //! TCP_NODELAY option value (false:off,true:on)
7769 set_option.nodelay_val = false;
7770 //! TCP_CORK (false:not set,true:set option)
7771 set_option.cork_opt = false;
7772 //! TCP_CORK option value (false:off,true:on)
7773 set_option.cork_val = false;
7774 //! TCP_QUICKACK (false:not set,true:set option)
7775 set_option.quickack_opt = false;
7776 //! TCP_QUICKACK option value (false:off,true:on)
7777 set_option.quickack_val = false;
7779 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
7780 bool set_mode(false);
7781 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
7782 bool set_ssl_cache_flag(false);
7783 int set_ssl_handshake_time_out = 0;
7784 //std::string access_log_file_name = "test";
7785 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
7787 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);
7790 l7vs::lockfree_queue<l7vs::tcp_thread_message>& up_thread_message_que = test_obj.get_up_thread_message_que();
7791 l7vs::lockfree_queue<l7vs::tcp_thread_message>& down_thread_message_que = test_obj.get_down_thread_message_que();
7793 BOOST_CHECK(up_thread_message_que.empty());
7794 BOOST_CHECK(down_thread_message_que.empty());
7795 l7vs::tcp_socket& client_socket = test_obj.get_client_socket();
7796 client_socket.close_res = true;
7797 client_socket.close_call_check = false;
7799 test_obj.test_call();
7801 // unit_test [1] up_thread_client_disconnect client socket close call check
7802 std::cout << "[1] up_thread_client_disconnect client socket close call check" << std::endl;
7803 BOOST_CHECK(client_socket.close_call_check);
7805 // unit_test [2] up_thread_client_disconnect up thread message set check
7806 std::cout << "[2] up_thread_client_disconnect up thread message set check" << std::endl;
7807 BOOST_CHECK(!up_thread_message_que.empty());
7808 l7vs::tcp_thread_message* up_msg = up_thread_message_que.pop();
7809 BOOST_CHECK(up_thread_message_que.empty());
7810 test_obj.up_thread_client_disconnect_event_call_chek = false;
7811 up_msg->message(l7vs::tcp_session::MESSAGE_PROC);
7812 BOOST_CHECK(test_obj.up_thread_client_disconnect_event_call_chek);
7815 // unit_test [3] up_thread_client_disconnect down thread message set check
7816 std::cout << "[3] up_thread_client_disconnect down thread message set check" << std::endl;
7817 BOOST_CHECK(!down_thread_message_que.empty());
7818 l7vs::tcp_thread_message* down_msg = down_thread_message_que.pop();
7819 BOOST_CHECK(down_thread_message_que.empty());
7820 test_obj.down_thread_client_disconnect_event_call_chek = false;
7821 down_msg->message(l7vs::tcp_session::MESSAGE_PROC);
7822 BOOST_CHECK(test_obj.down_thread_client_disconnect_event_call_chek);
7825 // unit_test [4] up_thread_client_disconnect closed client socket not set message check
7826 std::cout << "[4] up_thread_client_disconnect closed client socket not set message check" << std::endl;
7827 client_socket.close_res = false;
7828 test_obj.test_call();
7829 BOOST_CHECK(up_thread_message_que.empty());
7830 BOOST_CHECK(down_thread_message_que.empty());
7832 client_socket.close_res = true;
7834 // unit_test [5] up_thread_client_disconnect not fond down_thread_client_disconnect_event function error check
7835 std::cout << "[5] up_thread_client_disconnect not fond down_thread_client_disconnect_event function error check" << std::endl;
7836 test_obj.up_thread_message_down_thread_function_map_clear();
7837 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
7838 l7vs::Logger::putLogError_id = 0;
7839 test_obj.up_thread_exit_call_chek = false;
7840 test_obj.test_call();
7841 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
7842 BOOST_CHECK_EQUAL(27,l7vs::Logger::putLogError_id);
7843 std::cout << l7vs::Logger::putLogError_message << std::endl;
7844 BOOST_CHECK(test_obj.up_thread_exit_call_chek);
7846 // unit_test [6] up_thread_client_disconnect not fond up_thread_client_disconnect_event function error check
7847 std::cout << "[6] up_thread_client_disconnect not fond up_thread_client_disconnect_event function error check" << std::endl;
7848 test_obj.up_thread_function_array_clear();
7849 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
7850 l7vs::Logger::putLogError_id = 0;
7851 test_obj.up_thread_exit_call_chek = false;
7852 test_obj.test_call();
7853 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
7854 BOOST_CHECK_EQUAL(26,l7vs::Logger::putLogError_id);
7855 std::cout << l7vs::Logger::putLogError_message << std::endl;
7856 BOOST_CHECK(test_obj.up_thread_exit_call_chek);
7858 // ----SSL Mode Test
7859 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);
7861 l7vs::tcp_ssl_socket& client_ssl_socket = ssl_test_obj.get_client_ssl_socket();
7862 client_ssl_socket.close_res = true;
7863 client_ssl_socket.close_call_check = false;
7865 ssl_test_obj.test_call();
7867 // unit_test [7] up_thread_client_disconnect client ssl socket close call check
7868 std::cout << "[7] up_thread_client_disconnect client ssl socket close call check" << std::endl;
7869 BOOST_CHECK(client_ssl_socket.close_call_check);
7872 BOOST_MESSAGE( "----- up_thread_client_disconnect test end -----" );
7877 // down_thread_client_disconnect test
7878 // down_thread_client_disconnect test class
7879 class down_thread_client_disconnect_test_class : public l7vs::tcp_session{
7881 // down_thread_client_disconnect_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){
7883 down_thread_client_disconnect_test_class(
7884 l7vs::virtualservice_tcp& vs,
7885 boost::asio::io_service& session_io,
7886 l7vs::tcp_socket_option_info& set_socket_option,
7887 boost::asio::ip::tcp::endpoint listen_endpoint,
7889 boost::asio::ssl::context& set_ssl_context,
7890 bool set_ssl_cache_flag,
7891 int set_ssl_handshake_time_out,
7892 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
7899 set_ssl_handshake_time_out,
7900 set_access_logger){};
7902 ~down_thread_client_disconnect_test_class(){};
7905 l7vs::tcp_session::down_thread_client_disconnect(LOCAL_PROC);
7908 l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_up_thread_message_que(){
7909 return up_thread_message_que;
7912 l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_down_thread_message_que(){
7913 return down_thread_message_que;
7916 void down_thread_function_array_clear(){
7917 for(int i = 0; i <= DOWN_FUNC_EXIT; i++){
7918 down_thread_function_array[i].second = NULL;
7921 void down_thread_message_up_thread_function_map_clear(){
7922 down_thread_message_up_thread_function_map.clear();
7925 void up_thread_client_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){
7926 up_thread_client_disconnect_event_call_chek = true;
7928 bool up_thread_client_disconnect_event_call_chek;
7930 void down_thread_client_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){
7931 down_thread_client_disconnect_event_call_chek = true;
7933 bool down_thread_client_disconnect_event_call_chek;
7935 void down_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
7936 down_thread_exit_call_chek = true;
7938 bool down_thread_exit_call_chek;
7940 l7vs::tcp_socket& get_client_socket(){
7941 return client_socket;
7943 l7vs::tcp_ssl_socket& get_client_ssl_socket(){
7944 return client_ssl_socket;
7947 void down_thread_client_disconnect_test(){
7948 BOOST_MESSAGE( "----- down_thread_client_disconnect test start -----" );
7949 // boost::asio::io_service io;
7950 // l7vs::virtualservice_tcp vs;
7951 // down_thread_client_disconnect_test_class test_obj(vs,io);
7952 l7vs::virtualservice_tcp vs;
7953 boost::asio::io_service io;
7954 l7vs::tcp_socket_option_info set_option;
7955 //! TCP_NODELAY (false:not set,true:set option)
7956 set_option.nodelay_opt = false;
7957 //! TCP_NODELAY option value (false:off,true:on)
7958 set_option.nodelay_val = false;
7959 //! TCP_CORK (false:not set,true:set option)
7960 set_option.cork_opt = false;
7961 //! TCP_CORK option value (false:off,true:on)
7962 set_option.cork_val = false;
7963 //! TCP_QUICKACK (false:not set,true:set option)
7964 set_option.quickack_opt = false;
7965 //! TCP_QUICKACK option value (false:off,true:on)
7966 set_option.quickack_val = false;
7968 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
7969 bool set_mode(false);
7970 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
7971 bool set_ssl_cache_flag(false);
7972 int set_ssl_handshake_time_out = 0;
7973 //std::string access_log_file_name = "test";
7974 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
7976 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);
7978 l7vs::lockfree_queue<l7vs::tcp_thread_message>& up_thread_message_que = test_obj.get_up_thread_message_que();
7979 l7vs::lockfree_queue<l7vs::tcp_thread_message>& down_thread_message_que = test_obj.get_down_thread_message_que();
7981 BOOST_CHECK(up_thread_message_que.empty());
7982 BOOST_CHECK(down_thread_message_que.empty());
7983 l7vs::tcp_socket& client_socket = test_obj.get_client_socket();
7984 client_socket.close_res = true;
7985 client_socket.close_call_check = false;
7987 test_obj.test_call();
7989 // unit_test [1] down_thread_client_disconnect client socket close call check
7990 std::cout << "[1] down_thread_client_disconnect client socket close call check" << std::endl;
7991 BOOST_CHECK(client_socket.close_call_check);
7993 // unit_test [2] down_thread_client_disconnect up thread message set check
7994 std::cout << "[2] down_thread_client_disconnect up thread message set check" << std::endl;
7995 BOOST_CHECK(!up_thread_message_que.empty());
7996 l7vs::tcp_thread_message* up_msg = up_thread_message_que.pop();
7997 BOOST_CHECK(up_thread_message_que.empty());
7998 test_obj.up_thread_client_disconnect_event_call_chek = false;
7999 up_msg->message(l7vs::tcp_session::MESSAGE_PROC);
8000 BOOST_CHECK(test_obj.up_thread_client_disconnect_event_call_chek);
8003 // unit_test [3] down_thread_client_disconnect down thread message set check
8004 std::cout << "[3] down_thread_client_disconnect down thread message set check" << std::endl;
8005 BOOST_CHECK(!down_thread_message_que.empty());
8006 l7vs::tcp_thread_message* down_msg = down_thread_message_que.pop();
8007 BOOST_CHECK(down_thread_message_que.empty());
8008 test_obj.down_thread_client_disconnect_event_call_chek = false;
8009 down_msg->message(l7vs::tcp_session::MESSAGE_PROC);
8010 BOOST_CHECK(test_obj.down_thread_client_disconnect_event_call_chek);
8013 // unit_test [4] down_thread_client_disconnect closed client socket not set message check
8014 std::cout << "[4] down_thread_client_disconnect closed client socket not set message check" << std::endl;
8015 client_socket.close_res = false;
8016 test_obj.test_call();
8017 BOOST_CHECK(up_thread_message_que.empty());
8018 BOOST_CHECK(down_thread_message_que.empty());
8020 client_socket.close_res = true;
8022 // unit_test [5] down_thread_client_disconnect not fond up_thread_client_disconnect_event function error check
8023 std::cout << "[5] down_thread_client_disconnect not fond up_thread_client_disconnect_event function error check" << std::endl;
8024 test_obj.down_thread_message_up_thread_function_map_clear();
8025 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
8026 l7vs::Logger::putLogError_id = 0;
8027 test_obj.down_thread_exit_call_chek = false;
8028 test_obj.test_call();
8029 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
8030 BOOST_CHECK_EQUAL(85,l7vs::Logger::putLogError_id);
8031 std::cout << l7vs::Logger::putLogError_message << std::endl;
8032 BOOST_CHECK(test_obj.down_thread_exit_call_chek);
8034 // unit_test [6] down_thread_client_disconnect not fond down_thread_client_disconnect_event function error check
8035 std::cout << "[6] down_thread_client_disconnect not fond down_thread_client_disconnect_event function error check" << std::endl;
8036 test_obj.down_thread_function_array_clear();
8037 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
8038 l7vs::Logger::putLogError_id = 0;
8039 test_obj.down_thread_exit_call_chek = false;
8040 test_obj.test_call();
8041 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
8042 BOOST_CHECK_EQUAL(84,l7vs::Logger::putLogError_id);
8043 std::cout << l7vs::Logger::putLogError_message << std::endl;
8044 BOOST_CHECK(test_obj.down_thread_exit_call_chek);
8047 // ----SSL Mode Test
8048 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);
8050 l7vs::tcp_ssl_socket& client_ssl_socket = ssl_test_obj.get_client_ssl_socket();
8051 client_ssl_socket.close_res = true;
8052 client_ssl_socket.close_call_check = false;
8054 ssl_test_obj.test_call();
8056 // unit_test [7] down_thread_client_disconnect client ssl socket close call check
8057 std::cout << "[7] down_thread_client_disconnect client ssl socket close call check" << std::endl;
8058 BOOST_CHECK(client_ssl_socket.close_call_check);
8061 BOOST_MESSAGE( "----- down_thread_client_disconnect test end -----" );
8065 // up_thread_sorryserver_disconnect test
8066 // up_thread_sorryserver_disconnect test class
8067 class up_thread_sorryserver_disconnect_test_class : public l7vs::tcp_session{
8069 // up_thread_sorryserver_disconnect_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){
8071 up_thread_sorryserver_disconnect_test_class(
8072 l7vs::virtualservice_tcp& vs,
8073 boost::asio::io_service& session_io,
8074 l7vs::tcp_socket_option_info& set_socket_option,
8075 boost::asio::ip::tcp::endpoint listen_endpoint,
8077 boost::asio::ssl::context& set_ssl_context,
8078 bool set_ssl_cache_flag,
8079 int set_ssl_handshake_time_out,
8080 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
8087 set_ssl_handshake_time_out,
8088 set_access_logger){};
8090 ~up_thread_sorryserver_disconnect_test_class(){};
8093 l7vs::tcp_session::up_thread_sorryserver_disconnect(LOCAL_PROC);
8096 l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_up_thread_message_que(){
8097 return up_thread_message_que;
8100 l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_down_thread_message_que(){
8101 return down_thread_message_que;
8104 void up_thread_function_array_clear(){
8105 for(int i = 0;i <= UP_FUNC_EXIT;i++){
8106 up_thread_function_array[i].second = NULL;
8109 void up_thread_message_down_thread_function_map_clear(){
8110 up_thread_message_down_thread_function_map.clear();
8113 void up_thread_sorryserver_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){
8114 up_thread_sorryserver_disconnect_event_call_chek = true;
8116 bool up_thread_sorryserver_disconnect_event_call_chek;
8118 void down_thread_sorryserver_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){
8119 down_thread_sorryserver_disconnect_event_call_chek = true;
8121 bool down_thread_sorryserver_disconnect_event_call_chek;
8123 void up_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
8124 up_thread_exit_call_chek = true;
8126 bool up_thread_exit_call_chek;
8128 boost::shared_ptr< l7vs::tcp_socket > get_sorry_socket(){
8129 return sorryserver_socket.second;
8131 void set_sorry_endpoint(endpoint set_end){
8132 sorryserver_socket.first = set_end;
8135 void up_thread_sorryserver_disconnect_test(){
8136 BOOST_MESSAGE( "----- up_thread_sorryserver_disconnect test start -----" );
8137 // boost::asio::io_service io;
8138 // l7vs::virtualservice_tcp vs;
8139 // up_thread_sorryserver_disconnect_test_class test_obj(vs,io);
8140 l7vs::virtualservice_tcp vs;
8141 boost::asio::io_service io;
8142 l7vs::tcp_socket_option_info set_option;
8143 //! TCP_NODELAY (false:not set,true:set option)
8144 set_option.nodelay_opt = false;
8145 //! TCP_NODELAY option value (false:off,true:on)
8146 set_option.nodelay_val = false;
8147 //! TCP_CORK (false:not set,true:set option)
8148 set_option.cork_opt = false;
8149 //! TCP_CORK option value (false:off,true:on)
8150 set_option.cork_val = false;
8151 //! TCP_QUICKACK (false:not set,true:set option)
8152 set_option.quickack_opt = false;
8153 //! TCP_QUICKACK option value (false:off,true:on)
8154 set_option.quickack_val = false;
8156 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
8157 bool set_mode(false);
8158 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
8159 bool set_ssl_cache_flag(false);
8160 int set_ssl_handshake_time_out = 0;
8161 //std::string access_log_file_name = "test";
8162 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
8164 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);
8168 l7vs::lockfree_queue<l7vs::tcp_thread_message>& up_thread_message_que = test_obj.get_up_thread_message_que();
8169 l7vs::lockfree_queue<l7vs::tcp_thread_message>& down_thread_message_que = test_obj.get_down_thread_message_que();
8171 BOOST_CHECK(up_thread_message_que.empty());
8172 BOOST_CHECK(down_thread_message_que.empty());
8173 l7vs::tcp_socket& sorry_socket = *(test_obj.get_sorry_socket());
8174 sorry_socket.close_res = true;
8175 sorry_socket.close_call_check = false;
8176 boost::asio::ip::tcp::endpoint sorry_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
8177 test_obj.set_sorry_endpoint(sorry_end);
8179 test_obj.test_call();
8181 // unit_test [1] up_thread_sorryserver_disconnect client socket close call check
8182 std::cout << "[1] up_thread_sorryserver_disconnect client socket close call check" << std::endl;
8183 BOOST_CHECK(sorry_socket.close_call_check);
8185 // unit_test [2] up_thread_sorryserver_disconnect up thread message set check
8186 std::cout << "[2] up_thread_sorryserver_disconnect up thread message set check" << std::endl;
8187 BOOST_CHECK(!up_thread_message_que.empty());
8188 l7vs::tcp_thread_message* up_msg = up_thread_message_que.pop();
8189 BOOST_CHECK(up_thread_message_que.empty());
8190 BOOST_CHECK(up_msg->endpoint_info == sorry_end);
8191 test_obj.up_thread_sorryserver_disconnect_event_call_chek = false;
8192 up_msg->message(l7vs::tcp_session::MESSAGE_PROC);
8193 BOOST_CHECK(test_obj.up_thread_sorryserver_disconnect_event_call_chek);
8196 // unit_test [3] up_thread_sorryserver_disconnect down thread message set check
8197 std::cout << "[3] up_thread_sorryserver_disconnect down thread message set check" << std::endl;
8198 BOOST_CHECK(!down_thread_message_que.empty());
8199 l7vs::tcp_thread_message* down_msg = down_thread_message_que.pop();
8200 BOOST_CHECK(down_thread_message_que.empty());
8201 BOOST_CHECK(down_msg->endpoint_info == sorry_end);
8202 test_obj.down_thread_sorryserver_disconnect_event_call_chek = false;
8203 down_msg->message(l7vs::tcp_session::MESSAGE_PROC);
8204 BOOST_CHECK(test_obj.down_thread_sorryserver_disconnect_event_call_chek);
8207 // unit_test [4] up_thread_sorryserver_disconnect closed client socket not set message check
8208 std::cout << "[4] up_thread_sorryserver_disconnect closed client socket not set message check" << std::endl;
8209 sorry_socket.close_res = false;
8210 test_obj.test_call();
8211 BOOST_CHECK(up_thread_message_que.empty());
8212 BOOST_CHECK(down_thread_message_que.empty());
8214 sorry_socket.close_res = true;
8216 // unit_test [5] up_thread_sorryserver_disconnect not fond down_thread_sorryserver_disconnect_event function error check
8217 std::cout << "[5] up_thread_sorryserver_disconnect not fond down_thread_sorryserver_disconnect_event function error check" << std::endl;
8218 test_obj.up_thread_message_down_thread_function_map_clear();
8219 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
8220 l7vs::Logger::putLogError_id = 0;
8221 test_obj.up_thread_exit_call_chek = false;
8222 test_obj.test_call();
8223 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
8224 BOOST_CHECK_EQUAL(61,l7vs::Logger::putLogError_id);
8225 std::cout << l7vs::Logger::putLogError_message << std::endl;
8226 BOOST_CHECK(test_obj.up_thread_exit_call_chek);
8228 // unit_test [6] up_thread_sorryserver_disconnect not fond up_thread_sorryserver_disconnect_event function error check
8229 std::cout << "[6] up_thread_sorryserver_disconnect not fond up_thread_sorryserver_disconnect_event function error check" << std::endl;
8230 test_obj.up_thread_function_array_clear();
8231 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
8232 l7vs::Logger::putLogError_id = 0;
8233 test_obj.up_thread_exit_call_chek = false;
8234 test_obj.test_call();
8235 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
8236 BOOST_CHECK_EQUAL(60,l7vs::Logger::putLogError_id);
8237 std::cout << l7vs::Logger::putLogError_message << std::endl;
8238 BOOST_CHECK(test_obj.up_thread_exit_call_chek);
8240 BOOST_MESSAGE( "----- up_thread_sorryserver_disconnect test end -----" );
8244 // down_thread_sorryserver_disconnect test
8245 // down_thread_sorryserver_disconnect test class
8246 class down_thread_sorryserver_disconnect_test_class : public l7vs::tcp_session{
8248 // down_thread_sorryserver_disconnect_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){
8250 down_thread_sorryserver_disconnect_test_class(
8251 l7vs::virtualservice_tcp& vs,
8252 boost::asio::io_service& session_io,
8253 l7vs::tcp_socket_option_info& set_socket_option,
8254 boost::asio::ip::tcp::endpoint listen_endpoint,
8256 boost::asio::ssl::context& set_ssl_context,
8257 bool set_ssl_cache_flag,
8258 int set_ssl_handshake_time_out,
8259 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
8266 set_ssl_handshake_time_out,
8267 set_access_logger){};
8269 ~down_thread_sorryserver_disconnect_test_class(){};
8272 l7vs::tcp_session::down_thread_sorryserver_disconnect(LOCAL_PROC);
8275 l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_up_thread_message_que(){
8276 return up_thread_message_que;
8279 l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_down_thread_message_que(){
8280 return down_thread_message_que;
8283 void down_thread_function_array_clear(){
8284 for(int i = 0; i <= DOWN_FUNC_EXIT;i++){
8285 down_thread_function_array[i].second = NULL;
8288 void down_thread_message_up_thread_function_map_clear(){
8289 down_thread_message_up_thread_function_map.clear();
8292 void up_thread_sorryserver_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){
8293 up_thread_sorryserver_disconnect_event_call_chek = true;
8295 bool up_thread_sorryserver_disconnect_event_call_chek;
8297 void down_thread_sorryserver_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){
8298 down_thread_sorryserver_disconnect_event_call_chek = true;
8300 bool down_thread_sorryserver_disconnect_event_call_chek;
8302 void down_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
8303 down_thread_exit_call_chek = true;
8305 bool down_thread_exit_call_chek;
8307 boost::shared_ptr< l7vs::tcp_socket > get_sorry_socket(){
8308 return sorryserver_socket.second;
8310 void set_sorry_endpoint(endpoint set_end){
8311 sorryserver_socket.first = set_end;
8314 void down_thread_sorryserver_disconnect_test(){
8315 BOOST_MESSAGE( "----- down_thread_sorryserver_disconnect test start -----" );
8316 // boost::asio::io_service io;
8317 // l7vs::virtualservice_tcp vs;
8318 // down_thread_sorryserver_disconnect_test_class test_obj(vs,io);
8319 l7vs::virtualservice_tcp vs;
8320 boost::asio::io_service io;
8321 l7vs::tcp_socket_option_info set_option;
8322 //! TCP_NODELAY (false:not set,true:set option)
8323 set_option.nodelay_opt = false;
8324 //! TCP_NODELAY option value (false:off,true:on)
8325 set_option.nodelay_val = false;
8326 //! TCP_CORK (false:not set,true:set option)
8327 set_option.cork_opt = false;
8328 //! TCP_CORK option value (false:off,true:on)
8329 set_option.cork_val = false;
8330 //! TCP_QUICKACK (false:not set,true:set option)
8331 set_option.quickack_opt = false;
8332 //! TCP_QUICKACK option value (false:off,true:on)
8333 set_option.quickack_val = false;
8335 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
8336 bool set_mode(false);
8337 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
8338 bool set_ssl_cache_flag(false);
8339 int set_ssl_handshake_time_out = 0;
8340 //std::string access_log_file_name = "test";
8341 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
8343 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);
8345 l7vs::lockfree_queue<l7vs::tcp_thread_message>& up_thread_message_que = test_obj.get_up_thread_message_que();
8346 l7vs::lockfree_queue<l7vs::tcp_thread_message>& down_thread_message_que = test_obj.get_down_thread_message_que();
8348 BOOST_CHECK(up_thread_message_que.empty());
8349 BOOST_CHECK(down_thread_message_que.empty());
8350 l7vs::tcp_socket& sorry_socket = *(test_obj.get_sorry_socket());
8351 sorry_socket.close_res = true;
8352 sorry_socket.close_call_check = false;
8353 boost::asio::ip::tcp::endpoint sorry_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
8354 test_obj.set_sorry_endpoint(sorry_end);
8356 test_obj.test_call();
8358 // unit_test [1] down_thread_sorryserver_disconnect client socket close call check
8359 std::cout << "[1] down_thread_sorryserver_disconnect client socket close call check" << std::endl;
8360 BOOST_CHECK(sorry_socket.close_call_check);
8362 // unit_test [2] down_thread_sorryserver_disconnect up thread message set check
8363 std::cout << "[2] down_thread_sorryserver_disconnect up thread message set check" << std::endl;
8364 BOOST_CHECK(!up_thread_message_que.empty());
8365 l7vs::tcp_thread_message* up_msg = up_thread_message_que.pop();
8366 BOOST_CHECK(up_thread_message_que.empty());
8367 BOOST_CHECK(up_msg->endpoint_info == sorry_end);
8368 test_obj.up_thread_sorryserver_disconnect_event_call_chek = false;
8369 up_msg->message(l7vs::tcp_session::MESSAGE_PROC);
8370 BOOST_CHECK(test_obj.up_thread_sorryserver_disconnect_event_call_chek);
8373 // unit_test [3] down_thread_sorryserver_disconnect down thread message set check
8374 std::cout << "[3] down_thread_sorryserver_disconnect down thread message set check" << std::endl;
8375 BOOST_CHECK(!down_thread_message_que.empty());
8376 l7vs::tcp_thread_message* down_msg = down_thread_message_que.pop();
8377 BOOST_CHECK(down_thread_message_que.empty());
8378 BOOST_CHECK(down_msg->endpoint_info == sorry_end);
8379 test_obj.down_thread_sorryserver_disconnect_event_call_chek = false;
8380 down_msg->message(l7vs::tcp_session::MESSAGE_PROC);
8381 BOOST_CHECK(test_obj.down_thread_sorryserver_disconnect_event_call_chek);
8384 // unit_test [4] down_thread_sorryserver_disconnect closed client socket not set message check
8385 std::cout << "[4] down_thread_sorryserver_disconnect closed client socket not set message check" << std::endl;
8386 sorry_socket.close_res = false;
8387 test_obj.test_call();
8388 BOOST_CHECK(up_thread_message_que.empty());
8389 BOOST_CHECK(down_thread_message_que.empty());
8391 sorry_socket.close_res = true;
8393 // unit_test [5] down_thread_sorryserver_disconnect not fond up_thread_sorryserver_disconnect_event function error check
8394 std::cout << "[5] down_thread_sorryserver_disconnect not fond up_thread_sorryserver_disconnect_event function error check" << std::endl;
8395 test_obj.down_thread_message_up_thread_function_map_clear();
8396 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
8397 l7vs::Logger::putLogError_id = 0;
8398 test_obj.down_thread_exit_call_chek = false;
8399 test_obj.test_call();
8400 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
8401 BOOST_CHECK_EQUAL(91,l7vs::Logger::putLogError_id);
8402 std::cout << l7vs::Logger::putLogError_message << std::endl;
8403 BOOST_CHECK(test_obj.down_thread_exit_call_chek);
8405 // unit_test [6] down_thread_sorryserver_disconnect not fond down_thread_sorryserver_disconnect_event function error check
8406 std::cout << "[6] down_thread_sorryserver_disconnect not fond down_thread_sorryserver_disconnect_event function error check" << std::endl;
8407 test_obj.down_thread_function_array_clear();
8408 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
8409 l7vs::Logger::putLogError_id = 0;
8410 test_obj.down_thread_exit_call_chek = false;
8411 test_obj.test_call();
8412 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
8413 BOOST_CHECK_EQUAL(90,l7vs::Logger::putLogError_id);
8414 std::cout << l7vs::Logger::putLogError_message << std::endl;
8415 BOOST_CHECK(test_obj.down_thread_exit_call_chek);
8417 BOOST_MESSAGE( "----- down_thread_sorryserver_disconnect test end -----" );
8420 // up_thread_realserver_connect_event test
8421 // up_thread_realserver_connect_event test class
8422 class up_thread_realserver_connect_event_test_class : public module_event_map_test_base_class{
8424 // 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){
8426 up_thread_realserver_connect_event_test_class(
8427 l7vs::virtualservice_tcp& vs,
8428 boost::asio::io_service& session_io,
8429 l7vs::tcp_socket_option_info& set_socket_option,
8430 boost::asio::ip::tcp::endpoint listen_endpoint,
8432 boost::asio::ssl::context& set_ssl_context,
8433 bool set_ssl_cache_flag,
8434 int set_ssl_handshake_time_out,
8435 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
8442 set_ssl_handshake_time_out,
8443 set_access_logger){};
8445 ~up_thread_realserver_connect_event_test_class(){};
8448 l7vs::tcp_session::up_thread_realserver_connect_event(LOCAL_PROC);
8452 void up_thread_realserver_connect_event_test(){
8453 BOOST_MESSAGE( "----- up_thread_realserver_connect_event test start -----" );
8454 // boost::asio::io_service io;
8455 // l7vs::virtualservice_tcp vs;
8456 // up_thread_realserver_connect_event_test_class test_obj(vs,io);
8457 l7vs::virtualservice_tcp vs;
8458 boost::asio::io_service io;
8459 l7vs::tcp_socket_option_info set_option;
8460 //! TCP_NODELAY (false:not set,true:set option)
8461 set_option.nodelay_opt = false;
8462 //! TCP_NODELAY option value (false:off,true:on)
8463 set_option.nodelay_val = false;
8464 //! TCP_CORK (false:not set,true:set option)
8465 set_option.cork_opt = false;
8466 //! TCP_CORK option value (false:off,true:on)
8467 set_option.cork_val = false;
8468 //! TCP_QUICKACK (false:not set,true:set option)
8469 set_option.quickack_opt = false;
8470 //! TCP_QUICKACK option value (false:off,true:on)
8471 set_option.quickack_val = false;
8473 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
8474 bool set_mode(false);
8475 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
8476 bool set_ssl_cache_flag(false);
8477 int set_ssl_handshake_time_out = 0;
8478 //std::string access_log_file_name = "test";
8479 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
8481 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);
8484 std::string test_protocol_name("test protocol");
8485 l7vs::test_protocol_module proto_test(test_protocol_name);
8487 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
8489 l7vs::protocol_module_base::EVENT_TAG chek_event[13];
8490 chek_event[0] = l7vs::protocol_module_base::ACCEPT;
8491 chek_event[1] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
8492 chek_event[2] = l7vs::protocol_module_base::CLIENT_RECV;
8493 chek_event[3] = l7vs::protocol_module_base::CLIENT_RESPONSE_SEND;
8494 chek_event[4] = l7vs::protocol_module_base::REALSERVER_SELECT;
8495 chek_event[5] = l7vs::protocol_module_base::REALSERVER_CONNECT;
8496 chek_event[6] = l7vs::protocol_module_base::REALSERVER_SEND;
8497 chek_event[7] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
8498 chek_event[8] = l7vs::protocol_module_base::SORRYSERVER_SELECT;
8499 chek_event[9] = l7vs::protocol_module_base::SORRYSERVER_CONNECT;
8500 chek_event[10] = l7vs::protocol_module_base::SORRYSERVER_SEND;
8501 chek_event[11] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
8502 chek_event[12] = l7vs::protocol_module_base::FINALIZE;
8504 // unit_test [1] up_thread_realserver_connect_event up_thread_next_call_function update check
8505 std::cout << "[1] up_thread_realserver_connect_event up_thread_next_call_function update check" << std::endl;
8506 for(int i = 0; i < 13;i++){
8507 proto_test.handle_realserver_connect_res_tag = chek_event[i];
8508 test_obj.test_call();
8509 BOOST_CHECK(test_obj.chk_up_thread_next_call_function(chek_event[i]));
8512 // unit_test [2] up_thread_realserver_connect_event module parameter check
8513 std::cout << "[2] up_thread_realserver_connect_event module parameter check" << std::endl;
8514 boost::thread::id def_id;
8515 boost::thread::id proc_id = boost::this_thread::get_id();
8516 test_obj.set_up_thread_id(proc_id);
8517 proto_test.handle_realserver_connect_thread_id = def_id;
8518 proto_test.handle_realserver_connect_res_tag = l7vs::protocol_module_base::FINALIZE;
8519 BOOST_CHECK(proto_test.handle_realserver_connect_thread_id != proc_id);
8520 char set_char = CHAR_MIN;
8521 for(int i = 0;i < MAX_BUFFER_SIZE;i++){
8522 proto_test.handle_realserver_connect_sendbuffer[i] = set_char;
8523 if(set_char == CHAR_MAX){
8524 set_char = CHAR_MIN;
8529 proto_test.handle_realserver_connect_datalen = MAX_BUFFER_SIZE;
8530 l7vs::tcp_data& test_data = test_obj.get_up_thread_data_dest_side();
8531 test_data.initialize();
8532 boost::asio::ip::tcp::endpoint server_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
8533 test_data.set_endpoint(server_end);
8535 test_obj.test_call();
8537 BOOST_CHECK(proto_test.handle_realserver_connect_thread_id == proc_id);
8538 BOOST_CHECK(proto_test.handle_realserver_connect_sendbuffer == test_data.get_data());
8539 BOOST_CHECK(proto_test.handle_realserver_connect_datalen == test_data.get_size());
8540 BOOST_CHECK(server_end == test_data.get_endpoint());
8542 // unit_test [3] up_thread_realserver_connect_event not fond function error check
8543 std::cout << "[3] up_thread_realserver_connect_event not fond function error check" << std::endl;
8544 test_obj.up_thread_function_array_clear();
8545 proto_test.handle_realserver_connect_res_tag = l7vs::protocol_module_base::FINALIZE;
8546 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
8547 l7vs::Logger::putLogError_id = 0;
8548 test_obj.test_call();
8549 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
8550 BOOST_CHECK_EQUAL(40,l7vs::Logger::putLogError_id);
8551 std::cout << l7vs::Logger::putLogError_message << std::endl;
8553 // unit_test [4] up_thread_realserver_connect_event returnd illegal EVENT_TAG error check
8554 std::cout << "[4] up_thread_realserver_connect_event returnd illegal EVENT_TAG error check" << std::endl;
8555 test_obj.up_thread_module_event_map_clear();
8556 proto_test.handle_realserver_connect_res_tag = l7vs::protocol_module_base::FINALIZE;
8557 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
8558 l7vs::Logger::putLogError_id = 0;
8559 test_obj.test_call();
8560 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
8561 BOOST_CHECK_EQUAL(39,l7vs::Logger::putLogError_id);
8562 std::cout << l7vs::Logger::putLogError_message << std::endl;
8564 BOOST_MESSAGE( "----- up_thread_realserver_connect_event test end -----" );
8567 // up_thread_sorryserver_connect_event test
8568 // up_thread_sorryserver_connect_event test class
8569 class up_thread_sorryserver_connect_event_test_class : public module_event_map_test_base_class{
8571 // 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){
8573 up_thread_sorryserver_connect_event_test_class(
8574 l7vs::virtualservice_tcp& vs,
8575 boost::asio::io_service& session_io,
8576 l7vs::tcp_socket_option_info& set_socket_option,
8577 boost::asio::ip::tcp::endpoint listen_endpoint,
8579 boost::asio::ssl::context& set_ssl_context,
8580 bool set_ssl_cache_flag,
8581 int set_ssl_handshake_time_out,
8582 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
8589 set_ssl_handshake_time_out,
8590 set_access_logger){};
8592 ~up_thread_sorryserver_connect_event_test_class(){};
8595 l7vs::tcp_session::up_thread_sorryserver_connect_event(LOCAL_PROC);
8599 void up_thread_sorryserver_connect_event_test(){
8600 BOOST_MESSAGE( "----- up_thread_sorryserver_connect_event test start -----" );
8601 // boost::asio::io_service io;
8602 // l7vs::virtualservice_tcp vs;
8603 // up_thread_sorryserver_connect_event_test_class test_obj(vs,io);
8604 l7vs::virtualservice_tcp vs;
8605 boost::asio::io_service io;
8606 l7vs::tcp_socket_option_info set_option;
8607 //! TCP_NODELAY (false:not set,true:set option)
8608 set_option.nodelay_opt = false;
8609 //! TCP_NODELAY option value (false:off,true:on)
8610 set_option.nodelay_val = false;
8611 //! TCP_CORK (false:not set,true:set option)
8612 set_option.cork_opt = false;
8613 //! TCP_CORK option value (false:off,true:on)
8614 set_option.cork_val = false;
8615 //! TCP_QUICKACK (false:not set,true:set option)
8616 set_option.quickack_opt = false;
8617 //! TCP_QUICKACK option value (false:off,true:on)
8618 set_option.quickack_val = false;
8620 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
8621 bool set_mode(false);
8622 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
8623 bool set_ssl_cache_flag(false);
8624 int set_ssl_handshake_time_out = 0;
8625 //std::string access_log_file_name = "test";
8626 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
8628 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);
8631 std::string test_protocol_name("test protocol");
8632 l7vs::test_protocol_module proto_test(test_protocol_name);
8634 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
8636 l7vs::protocol_module_base::EVENT_TAG chek_event[13];
8637 chek_event[0] = l7vs::protocol_module_base::ACCEPT;
8638 chek_event[1] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
8639 chek_event[2] = l7vs::protocol_module_base::CLIENT_RECV;
8640 chek_event[3] = l7vs::protocol_module_base::CLIENT_RESPONSE_SEND;
8641 chek_event[4] = l7vs::protocol_module_base::REALSERVER_SELECT;
8642 chek_event[5] = l7vs::protocol_module_base::REALSERVER_CONNECT;
8643 chek_event[6] = l7vs::protocol_module_base::REALSERVER_SEND;
8644 chek_event[7] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
8645 chek_event[8] = l7vs::protocol_module_base::SORRYSERVER_SELECT;
8646 chek_event[9] = l7vs::protocol_module_base::SORRYSERVER_CONNECT;
8647 chek_event[10] = l7vs::protocol_module_base::SORRYSERVER_SEND;
8648 chek_event[11] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
8649 chek_event[12] = l7vs::protocol_module_base::FINALIZE;
8651 // unit_test [1] up_thread_sorryserver_connect_event up_thread_next_call_function update check
8652 std::cout << "[1] up_thread_sorryserver_connect_event up_thread_next_call_function update check" << std::endl;
8653 for(int i = 0; i < 13;i++){
8654 proto_test.handle_sorryserver_connect_res_tag = chek_event[i];
8655 test_obj.test_call();
8656 BOOST_CHECK(test_obj.chk_up_thread_next_call_function(chek_event[i]));
8659 // unit_test [2] up_thread_sorryserver_connect_event module parameter check
8660 std::cout << "[2] up_thread_sorryserver_connect_event module parameter check" << std::endl;
8661 boost::thread::id def_id;
8662 boost::thread::id proc_id = boost::this_thread::get_id();
8663 test_obj.set_up_thread_id(proc_id);
8664 proto_test.handle_sorryserver_connect_thread_id = def_id;
8665 proto_test.handle_sorryserver_connect_res_tag = l7vs::protocol_module_base::FINALIZE;
8666 BOOST_CHECK(proto_test.handle_sorryserver_connect_thread_id != proc_id);
8667 char set_char = CHAR_MIN;
8668 for(int i = 0;i < MAX_BUFFER_SIZE;i++){
8669 proto_test.handle_sorryserver_connect_sendbuffer[i] = set_char;
8670 if(set_char == CHAR_MAX){
8671 set_char = CHAR_MIN;
8676 proto_test.handle_sorryserver_connect_datalen = MAX_BUFFER_SIZE;
8677 l7vs::tcp_data& test_data = test_obj.get_up_thread_data_dest_side();
8678 test_data.initialize();
8679 boost::asio::ip::tcp::endpoint server_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
8680 test_data.set_endpoint(server_end);
8682 test_obj.test_call();
8684 BOOST_CHECK(proto_test.handle_sorryserver_connect_thread_id == proc_id);
8685 BOOST_CHECK(proto_test.handle_sorryserver_connect_sendbuffer == test_data.get_data());
8686 BOOST_CHECK(proto_test.handle_sorryserver_connect_datalen == test_data.get_size());
8687 BOOST_CHECK(server_end == test_data.get_endpoint());
8689 // unit_test [3] up_thread_sorryserver_connect_event not fond function error check
8690 std::cout << "[3] up_thread_sorryserver_connect_event not fond function error check" << std::endl;
8691 test_obj.up_thread_function_array_clear();
8692 proto_test.handle_sorryserver_connect_res_tag = l7vs::protocol_module_base::FINALIZE;
8693 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
8694 l7vs::Logger::putLogError_id = 0;
8695 test_obj.test_call();
8696 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
8697 BOOST_CHECK_EQUAL(57,l7vs::Logger::putLogError_id);
8698 std::cout << l7vs::Logger::putLogError_message << std::endl;
8700 // unit_test [4] up_thread_sorryserver_connect_event returnd illegal EVENT_TAG error check
8701 std::cout << "[4] up_thread_sorryserver_connect_event returnd illegal EVENT_TAG error check" << std::endl;
8702 test_obj.up_thread_module_event_map_clear();
8703 proto_test.handle_sorryserver_connect_res_tag = l7vs::protocol_module_base::FINALIZE;
8704 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
8705 l7vs::Logger::putLogError_id = 0;
8706 test_obj.test_call();
8707 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
8708 BOOST_CHECK_EQUAL(56,l7vs::Logger::putLogError_id);
8709 std::cout << l7vs::Logger::putLogError_message << std::endl;
8711 BOOST_MESSAGE( "----- up_thread_sorryserver_connect_event test end -----" );
8713 // down_thread_client_connection_chk_event test
8714 // down_thread_client_connection_chk_event test class
8715 class down_thread_client_connection_chk_event_test_class : public module_event_map_test_base_class{
8717 // 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){
8719 down_thread_client_connection_chk_event_test_class(
8720 l7vs::virtualservice_tcp& vs,
8721 boost::asio::io_service& session_io,
8722 l7vs::tcp_socket_option_info& set_socket_option,
8723 boost::asio::ip::tcp::endpoint listen_endpoint,
8725 boost::asio::ssl::context& set_ssl_context,
8726 bool set_ssl_cache_flag,
8727 int set_ssl_handshake_time_out,
8728 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
8735 set_ssl_handshake_time_out,
8736 set_access_logger){};
8738 ~down_thread_client_connection_chk_event_test_class(){};
8741 l7vs::tcp_session::down_thread_client_connection_chk_event(LOCAL_PROC);
8745 void down_thread_client_connection_chk_event_test(){
8746 BOOST_MESSAGE( "----- down_thread_client_connection_chk_event test start -----" );
8747 // boost::asio::io_service io;
8748 // l7vs::virtualservice_tcp vs;
8749 // down_thread_client_connection_chk_event_test_class test_obj(vs,io);
8750 l7vs::virtualservice_tcp vs;
8751 boost::asio::io_service io;
8752 l7vs::tcp_socket_option_info set_option;
8753 //! TCP_NODELAY (false:not set,true:set option)
8754 set_option.nodelay_opt = false;
8755 //! TCP_NODELAY option value (false:off,true:on)
8756 set_option.nodelay_val = false;
8757 //! TCP_CORK (false:not set,true:set option)
8758 set_option.cork_opt = false;
8759 //! TCP_CORK option value (false:off,true:on)
8760 set_option.cork_val = false;
8761 //! TCP_QUICKACK (false:not set,true:set option)
8762 set_option.quickack_opt = false;
8763 //! TCP_QUICKACK option value (false:off,true:on)
8764 set_option.quickack_val = false;
8766 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
8767 bool set_mode(false);
8768 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
8769 bool set_ssl_cache_flag(false);
8770 int set_ssl_handshake_time_out = 0;
8771 //std::string access_log_file_name = "test";
8772 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
8774 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);
8777 std::string test_protocol_name("test protocol");
8778 l7vs::test_protocol_module proto_test(test_protocol_name);
8780 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
8782 l7vs::protocol_module_base::EVENT_TAG chek_event[7];
8783 chek_event[0] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
8784 chek_event[1] = l7vs::protocol_module_base::CLIENT_CONNECTION_CHECK;
8785 chek_event[2] = l7vs::protocol_module_base::REALSERVER_RECV;
8786 chek_event[3] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
8787 chek_event[4] = l7vs::protocol_module_base::SORRYSERVER_RECV;
8788 chek_event[5] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
8789 chek_event[6] = l7vs::protocol_module_base::FINALIZE;
8791 // unit_test [1] down_thread_client_connection_chk_event down_thread_next_call_function update check
8792 std::cout << "[1] down_thread_client_connection_chk_event down_thread_next_call_function update check" << std::endl;
8793 for(int i = 0; i < 7;i++){
8794 proto_test.handle_client_connection_check_res_tag = chek_event[i];
8795 test_obj.test_call();
8796 BOOST_CHECK(test_obj.chk_down_thread_next_call_function(chek_event[i]));
8799 // unit_test [2] down_thread_client_connection_chk_event module parameter check
8800 std::cout << "[2] down_thread_client_connection_chk_event module parameter check" << std::endl;
8801 boost::thread::id def_id;
8802 boost::thread::id proc_id = boost::this_thread::get_id();
8803 test_obj.set_down_thread_id(proc_id);
8804 proto_test.handle_client_connection_check_thread_id = def_id;
8805 proto_test.handle_client_connection_check_res_tag = l7vs::protocol_module_base::FINALIZE;
8806 BOOST_CHECK(proto_test.handle_client_connection_check_thread_id != proc_id);
8807 char set_char = CHAR_MIN;
8808 for(int i = 0;i < MAX_BUFFER_SIZE;i++){
8809 proto_test.handle_client_connection_check_sendbuffer[i] = set_char;
8810 if(set_char == CHAR_MAX){
8811 set_char = CHAR_MIN;
8816 proto_test.handle_client_connection_check_datalen = MAX_BUFFER_SIZE;
8817 l7vs::tcp_data& test_data = test_obj.get_down_thread_data_client_side();
8818 test_data.initialize();
8820 test_obj.test_call();
8822 BOOST_CHECK(proto_test.handle_client_connection_check_thread_id == proc_id);
8823 BOOST_CHECK(proto_test.handle_client_connection_check_sendbuffer == test_data.get_data());
8824 BOOST_CHECK(proto_test.handle_client_connection_check_datalen == test_data.get_size());
8826 // unit_test [3] down_thread_client_connection_chk_event not fond function error check
8827 std::cout << "[3] down_thread_client_connection_chk_event not fond function error check" << std::endl;
8828 test_obj.down_thread_function_array_clear();
8829 proto_test.handle_client_connection_check_res_tag = l7vs::protocol_module_base::FINALIZE;
8830 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
8831 l7vs::Logger::putLogError_id = 0;
8832 test_obj.test_call();
8833 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
8834 BOOST_CHECK_EQUAL(79,l7vs::Logger::putLogError_id);
8835 std::cout << l7vs::Logger::putLogError_message << std::endl;
8837 // unit_test [4] down_thread_client_connection_chk_event returnd illegal EVENT_TAG error check
8838 std::cout << "[4] down_thread_client_connection_chk_event returnd illegal EVENT_TAG error check" << std::endl;
8839 test_obj.down_thread_module_event_map_clear();
8840 proto_test.handle_client_connection_check_res_tag = l7vs::protocol_module_base::FINALIZE;
8841 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
8842 l7vs::Logger::putLogError_id = 0;
8843 test_obj.test_call();
8844 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
8845 BOOST_CHECK_EQUAL(78,l7vs::Logger::putLogError_id);
8846 std::cout << l7vs::Logger::putLogError_message << std::endl;
8848 BOOST_MESSAGE( "----- down_thread_client_connection_chk_event test end -----" );
8850 // up_thread_realserver_connection_fail_event test
8851 // up_thread_realserver_connection_fail_event test class
8852 class up_thread_realserver_connection_fail_event_test_class : public module_event_map_test_base_class{
8854 // 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){
8856 up_thread_realserver_connection_fail_event_test_class(
8857 l7vs::virtualservice_tcp& vs,
8858 boost::asio::io_service& session_io,
8859 l7vs::tcp_socket_option_info& set_socket_option,
8860 boost::asio::ip::tcp::endpoint listen_endpoint,
8862 boost::asio::ssl::context& set_ssl_context,
8863 bool set_ssl_cache_flag,
8864 int set_ssl_handshake_time_out,
8865 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
8872 set_ssl_handshake_time_out,
8873 set_access_logger){};
8875 ~up_thread_realserver_connection_fail_event_test_class(){};
8878 l7vs::tcp_session::up_thread_realserver_connection_fail_event(LOCAL_PROC);
8882 void up_thread_realserver_connection_fail_event_test(){
8883 BOOST_MESSAGE( "----- up_thread_realserver_connection_fail_event test start -----" );
8884 // boost::asio::io_service io;
8885 // l7vs::virtualservice_tcp vs;
8886 // up_thread_realserver_connection_fail_event_test_class test_obj(vs,io);
8887 l7vs::virtualservice_tcp vs;
8888 boost::asio::io_service io;
8889 l7vs::tcp_socket_option_info set_option;
8890 //! TCP_NODELAY (false:not set,true:set option)
8891 set_option.nodelay_opt = false;
8892 //! TCP_NODELAY option value (false:off,true:on)
8893 set_option.nodelay_val = false;
8894 //! TCP_CORK (false:not set,true:set option)
8895 set_option.cork_opt = false;
8896 //! TCP_CORK option value (false:off,true:on)
8897 set_option.cork_val = false;
8898 //! TCP_QUICKACK (false:not set,true:set option)
8899 set_option.quickack_opt = false;
8900 //! TCP_QUICKACK option value (false:off,true:on)
8901 set_option.quickack_val = false;
8903 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
8904 bool set_mode(false);
8905 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
8906 bool set_ssl_cache_flag(false);
8907 int set_ssl_handshake_time_out = 0;
8908 //std::string access_log_file_name = "test";
8909 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
8911 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);
8915 std::string test_protocol_name("test protocol");
8916 l7vs::test_protocol_module proto_test(test_protocol_name);
8918 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
8920 l7vs::protocol_module_base::EVENT_TAG chek_event[13];
8921 chek_event[0] = l7vs::protocol_module_base::ACCEPT;
8922 chek_event[1] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
8923 chek_event[2] = l7vs::protocol_module_base::CLIENT_RECV;
8924 chek_event[3] = l7vs::protocol_module_base::CLIENT_RESPONSE_SEND;
8925 chek_event[4] = l7vs::protocol_module_base::REALSERVER_SELECT;
8926 chek_event[5] = l7vs::protocol_module_base::REALSERVER_CONNECT;
8927 chek_event[6] = l7vs::protocol_module_base::REALSERVER_SEND;
8928 chek_event[7] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
8929 chek_event[8] = l7vs::protocol_module_base::SORRYSERVER_SELECT;
8930 chek_event[9] = l7vs::protocol_module_base::SORRYSERVER_CONNECT;
8931 chek_event[10] = l7vs::protocol_module_base::SORRYSERVER_SEND;
8932 chek_event[11] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
8933 chek_event[12] = l7vs::protocol_module_base::FINALIZE;
8935 // unit_test [1] up_thread_realserver_connection_fail_event up_thread_next_call_function update check
8936 std::cout << "[1] up_thread_realserver_connection_fail_event up_thread_next_call_function update check" << std::endl;
8937 for(int i = 0; i < 13;i++){
8938 proto_test.handle_realserver_connection_fail_res_tag = chek_event[i];
8939 test_obj.test_call();
8940 BOOST_CHECK(test_obj.chk_up_thread_next_call_function(chek_event[i]));
8943 // unit_test [2] up_thread_realserver_connection_fail_event module parameter check
8944 std::cout << "[2] up_thread_realserver_connection_fail_event module parameter check" << std::endl;
8945 boost::thread::id def_id;
8946 boost::thread::id proc_id = boost::this_thread::get_id();
8947 test_obj.set_up_thread_id(proc_id);
8948 proto_test.handle_realserver_connection_fail_thread_id = def_id;
8949 proto_test.handle_realserver_connection_fail_res_tag = l7vs::protocol_module_base::FINALIZE;
8950 BOOST_CHECK(proto_test.handle_realserver_connection_fail_thread_id != proc_id);
8951 boost::asio::ip::tcp::endpoint server_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
8952 l7vs::tcp_data& test_data = test_obj.get_up_thread_data_dest_side();
8953 test_data.set_endpoint(server_end);
8955 test_obj.test_call();
8957 BOOST_CHECK(proto_test.handle_realserver_connection_fail_thread_id == proc_id);
8958 BOOST_CHECK(server_end == test_data.get_endpoint());
8960 // unit_test [3] up_thread_realserver_connection_fail_event not fond function error check
8961 std::cout << "[3] up_thread_realserver_connection_fail_event not fond function error check" << std::endl;
8962 test_obj.up_thread_function_array_clear();
8963 proto_test.handle_realserver_connection_fail_res_tag = l7vs::protocol_module_base::FINALIZE;
8964 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
8965 l7vs::Logger::putLogError_id = 0;
8966 test_obj.test_call();
8967 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
8968 BOOST_CHECK_EQUAL(42,l7vs::Logger::putLogError_id);
8969 std::cout << l7vs::Logger::putLogError_message << std::endl;
8971 // unit_test [4] up_thread_realserver_connection_fail_event returnd illegal EVENT_TAG error check
8972 std::cout << "[4] up_thread_realserver_connection_fail_event returnd illegal EVENT_TAG error check" << std::endl;
8973 test_obj.up_thread_module_event_map_clear();
8974 proto_test.handle_realserver_connection_fail_res_tag = l7vs::protocol_module_base::FINALIZE;
8975 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
8976 l7vs::Logger::putLogError_id = 0;
8977 test_obj.test_call();
8978 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
8979 BOOST_CHECK_EQUAL(41,l7vs::Logger::putLogError_id);
8980 std::cout << l7vs::Logger::putLogError_message << std::endl;
8982 BOOST_MESSAGE( "----- up_thread_realserver_connection_fail_event test end -----" );
8985 // up_thread_sorryserver_connection_fail_event test
8986 // up_thread_sorryserver_connection_fail_event test class
8987 class up_thread_sorryserver_connection_fail_event_test_class : public module_event_map_test_base_class{
8989 // 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){
8991 up_thread_sorryserver_connection_fail_event_test_class(
8992 l7vs::virtualservice_tcp& vs,
8993 boost::asio::io_service& session_io,
8994 l7vs::tcp_socket_option_info& set_socket_option,
8995 boost::asio::ip::tcp::endpoint listen_endpoint,
8997 boost::asio::ssl::context& set_ssl_context,
8998 bool set_ssl_cache_flag,
8999 int set_ssl_handshake_time_out,
9000 l7vs::logger_implement_access* set_access_logger) : module_event_map_test_base_class( vs,
9007 set_ssl_handshake_time_out,
9008 set_access_logger){};
9010 ~up_thread_sorryserver_connection_fail_event_test_class(){};
9013 l7vs::tcp_session::up_thread_sorryserver_connection_fail_event(LOCAL_PROC);
9017 void up_thread_sorryserver_connection_fail_event_test(){
9018 BOOST_MESSAGE( "----- up_thread_sorryserver_connection_fail_event test start -----" );
9019 // boost::asio::io_service io;
9020 // l7vs::virtualservice_tcp vs;
9021 // up_thread_sorryserver_connection_fail_event_test_class test_obj(vs,io);
9022 l7vs::virtualservice_tcp vs;
9023 boost::asio::io_service io;
9024 l7vs::tcp_socket_option_info set_option;
9025 //! TCP_NODELAY (false:not set,true:set option)
9026 set_option.nodelay_opt = false;
9027 //! TCP_NODELAY option value (false:off,true:on)
9028 set_option.nodelay_val = false;
9029 //! TCP_CORK (false:not set,true:set option)
9030 set_option.cork_opt = false;
9031 //! TCP_CORK option value (false:off,true:on)
9032 set_option.cork_val = false;
9033 //! TCP_QUICKACK (false:not set,true:set option)
9034 set_option.quickack_opt = false;
9035 //! TCP_QUICKACK option value (false:off,true:on)
9036 set_option.quickack_val = false;
9038 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
9039 bool set_mode(false);
9040 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
9041 bool set_ssl_cache_flag(false);
9042 int set_ssl_handshake_time_out = 0;
9043 //std::string access_log_file_name = "test";
9044 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
9046 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);
9049 std::string test_protocol_name("test protocol");
9050 l7vs::test_protocol_module proto_test(test_protocol_name);
9052 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
9054 l7vs::protocol_module_base::EVENT_TAG chek_event[13];
9055 chek_event[0] = l7vs::protocol_module_base::ACCEPT;
9056 chek_event[1] = l7vs::protocol_module_base::CLIENT_DISCONNECT;
9057 chek_event[2] = l7vs::protocol_module_base::CLIENT_RECV;
9058 chek_event[3] = l7vs::protocol_module_base::CLIENT_RESPONSE_SEND;
9059 chek_event[4] = l7vs::protocol_module_base::REALSERVER_SELECT;
9060 chek_event[5] = l7vs::protocol_module_base::REALSERVER_CONNECT;
9061 chek_event[6] = l7vs::protocol_module_base::REALSERVER_SEND;
9062 chek_event[7] = l7vs::protocol_module_base::REALSERVER_DISCONNECT;
9063 chek_event[8] = l7vs::protocol_module_base::SORRYSERVER_SELECT;
9064 chek_event[9] = l7vs::protocol_module_base::SORRYSERVER_CONNECT;
9065 chek_event[10] = l7vs::protocol_module_base::SORRYSERVER_SEND;
9066 chek_event[11] = l7vs::protocol_module_base::SORRYSERVER_DISCONNECT;
9067 chek_event[12] = l7vs::protocol_module_base::FINALIZE;
9069 // unit_test [1] up_thread_sorryserver_connection_fail_event up_thread_next_call_function update check
9070 std::cout << "[1] up_thread_sorryserver_connection_fail_event up_thread_next_call_function update check" << std::endl;
9071 for(int i = 0; i < 13;i++){
9072 proto_test.handle_sorryserver_connection_fail_res_tag = chek_event[i];
9073 test_obj.test_call();
9074 BOOST_CHECK(test_obj.chk_up_thread_next_call_function(chek_event[i]));
9077 // unit_test [2] up_thread_sorryserver_connection_fail_event module parameter check
9078 std::cout << "[2] up_thread_sorryserver_connection_fail_event module parameter check" << std::endl;
9079 boost::thread::id def_id;
9080 boost::thread::id proc_id = boost::this_thread::get_id();
9081 test_obj.set_up_thread_id(proc_id);
9082 proto_test.handle_sorryserver_connection_fail_thread_id = def_id;
9083 proto_test.handle_sorryserver_connection_fail_res_tag = l7vs::protocol_module_base::FINALIZE;
9084 BOOST_CHECK(proto_test.handle_sorryserver_connection_fail_thread_id != proc_id);
9085 boost::asio::ip::tcp::endpoint server_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
9086 l7vs::tcp_data& test_data = test_obj.get_up_thread_data_dest_side();
9087 test_data.set_endpoint(server_end);
9089 test_obj.test_call();
9091 BOOST_CHECK(proto_test.handle_sorryserver_connection_fail_thread_id == proc_id);
9092 BOOST_CHECK(server_end == test_data.get_endpoint());
9094 // unit_test [3] up_thread_sorryserver_connection_fail_event not fond function error check
9095 std::cout << "[3] up_thread_sorryserver_connection_fail_event not fond function error check" << std::endl;
9096 test_obj.up_thread_function_array_clear();
9097 proto_test.handle_sorryserver_connection_fail_res_tag = l7vs::protocol_module_base::FINALIZE;
9098 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
9099 l7vs::Logger::putLogError_id = 0;
9100 test_obj.test_call();
9101 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
9102 BOOST_CHECK_EQUAL(59,l7vs::Logger::putLogError_id);
9103 std::cout << l7vs::Logger::putLogError_message << std::endl;
9105 // unit_test [4] up_thread_sorryserver_connection_fail_event returnd illegal EVENT_TAG error check
9106 std::cout << "[4] up_thread_sorryserver_connection_fail_event returnd illegal EVENT_TAG error check" << std::endl;
9107 test_obj.up_thread_module_event_map_clear();
9108 proto_test.handle_sorryserver_connection_fail_res_tag = l7vs::protocol_module_base::FINALIZE;
9109 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
9110 l7vs::Logger::putLogError_id = 0;
9111 test_obj.test_call();
9112 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
9113 BOOST_CHECK_EQUAL(58,l7vs::Logger::putLogError_id);
9114 std::cout << l7vs::Logger::putLogError_message << std::endl;
9116 BOOST_MESSAGE( "----- up_thread_sorryserver_connection_fail_event test end -----" );
9119 // receive & send test class
9120 class receive_send_test_class : public l7vs::tcp_session{
9122 // receive_send_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){
9124 receive_send_test_class(
9125 l7vs::virtualservice_tcp& vs,
9126 boost::asio::io_service& session_io,
9127 l7vs::tcp_socket_option_info& set_socket_option,
9128 boost::asio::ip::tcp::endpoint listen_endpoint,
9130 boost::asio::ssl::context& set_ssl_context,
9131 bool set_ssl_cache_flag,
9132 int set_ssl_handshake_time_out,
9133 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
9140 set_ssl_handshake_time_out,
9141 set_access_logger){};
9143 ~receive_send_test_class(){};
9145 void test_call_client_receive(){
9146 l7vs::tcp_session::up_thread_client_receive(LOCAL_PROC);
9148 void test_call_client_send(){
9149 l7vs::tcp_session::down_thread_client_send(LOCAL_PROC);
9151 void test_call_realserver_receive(){
9152 l7vs::tcp_session::down_thread_realserver_receive(LOCAL_PROC);
9154 void test_call_realserver_send(){
9155 l7vs::tcp_session::up_thread_realserver_send(LOCAL_PROC);
9157 void test_call_sorryserver_receive(){
9158 l7vs::tcp_session::down_thread_sorryserver_receive(LOCAL_PROC);
9160 void test_call_sorryserver_send(){
9161 l7vs::tcp_session::up_thread_sorryserver_send(LOCAL_PROC);
9163 void set_protocol_module(l7vs::protocol_module_base* set_prot){
9164 protocol_module = set_prot;
9166 l7vs::tcp_data& get_up_thread_data_client_side(){
9167 return up_thread_data_client_side;
9169 l7vs::tcp_data& get_up_thread_data_dest_side(){
9170 return up_thread_data_dest_side;
9172 l7vs::tcp_data& get_down_thread_data_client_side(){
9173 return down_thread_data_client_side;
9175 l7vs::tcp_data& get_down_thread_data_dest_side(){
9176 return down_thread_data_dest_side;
9178 l7vs::tcp_socket& get_client_socket(){
9179 return client_socket;
9181 l7vs::tcp_ssl_socket& get_client_ssl_socket(){
9182 return client_ssl_socket;
9184 socket_element& get_sorryserver_socket(){
9185 return sorryserver_socket;
9187 std::list<socket_element>& get_down_thread_receive_realserver_socket_list(){
9188 return down_thread_receive_realserver_socket_list;
9190 std::map<endpoint,tcp_socket_ptr>& get_up_thread_send_realserver_socket_map(){
9191 return up_thread_send_realserver_socket_map;
9193 std::list<socket_element>::iterator& get_down_thread_current_receive_realserver_socket(){
9194 return down_thread_current_receive_realserver_socket;
9197 void set_up_thread_id(boost::thread::id set_id){
9198 up_thread_id = set_id;
9200 void set_down_thread_id(boost::thread::id set_id){
9201 down_thread_id = set_id;
9204 void next_up_function_call(){
9205 up_thread_next_call_function.second(LOCAL_PROC);
9207 void next_down_function_call(){
9208 down_thread_next_call_function.second(LOCAL_PROC);
9211 void set_up_thread_next_function_call_exit(){
9212 up_thread_function_pair fun_it = up_thread_function_array[UP_FUNC_EXIT];
9213 up_thread_next_call_function = fun_it;
9216 void set_down_thread_next_function_call_exit(){
9217 down_thread_function_pair fun_it = down_thread_function_array[DOWN_FUNC_EXIT];
9218 down_thread_next_call_function = fun_it;
9221 // next call function check
9222 void up_thread_realserver_get_destination_event(const TCP_PROCESS_TYPE_TAG process_type){
9223 up_thread_realserver_get_destination_event_call_check = true;
9225 bool up_thread_realserver_get_destination_event_call_check;
9226 void up_thread_sorryserver_get_destination_event(const TCP_PROCESS_TYPE_TAG process_type){
9227 up_thread_sorryserver_get_destination_event_call_check = true;
9229 bool up_thread_sorryserver_get_destination_event_call_check;
9231 void up_thread_client_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
9232 up_thread_client_disconnect_call_check = true;
9234 bool up_thread_client_disconnect_call_check;
9237 void down_thread_client_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
9238 down_thread_client_disconnect_call_check = true;
9240 bool down_thread_client_disconnect_call_check;
9242 void up_thread_realserver_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
9243 up_thread_realserver_disconnect_call_check = true;
9245 bool up_thread_realserver_disconnect_call_check;
9247 void up_thread_sorryserver_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
9248 up_thread_sorryserver_disconnect_call_check = true;
9250 bool up_thread_sorryserver_disconnect_call_check;
9252 void down_thread_realserver_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
9253 down_thread_realserver_disconnect_call_check = true;
9255 bool down_thread_realserver_disconnect_call_check;
9257 void down_thread_sorryserver_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
9258 down_thread_sorryserver_disconnect_call_check = true;
9260 bool down_thread_sorryserver_disconnect_call_check;
9262 void up_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
9263 up_thread_exit_call_check = true;
9265 bool up_thread_exit_call_check;
9267 void down_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
9268 down_thread_exit_call_check = true;
9270 bool down_thread_exit_call_check;
9272 void up_thread_client_receive(const TCP_PROCESS_TYPE_TAG process_type){
9273 up_thread_client_receive_call_check = true;
9274 tcp_session::up_thread_client_receive(process_type);
9276 bool up_thread_client_receive_call_check;
9278 void down_thread_realserver_receive(const TCP_PROCESS_TYPE_TAG process_type){
9279 down_thread_realserver_receive_call_check = true;
9280 tcp_session::down_thread_realserver_receive(process_type);
9282 bool down_thread_realserver_receive_call_check;
9284 void down_thread_sorryserver_receive(const TCP_PROCESS_TYPE_TAG process_type){
9285 down_thread_sorryserver_receive_call_check = true;
9286 tcp_session::down_thread_sorryserver_receive(process_type);
9288 bool down_thread_sorryserver_receive_call_check;
9290 void down_thread_client_send(const TCP_PROCESS_TYPE_TAG process_type){
9291 down_thread_client_send_call_check = true;
9293 bool down_thread_client_send_call_check;
9295 void up_thread_realserver_send(const TCP_PROCESS_TYPE_TAG process_type){
9296 up_thread_realserver_send_call_check = true;
9298 bool up_thread_realserver_send_call_check;
9300 void up_thread_sorryserver_send(const TCP_PROCESS_TYPE_TAG process_type){
9301 up_thread_sorryserver_send_call_check = true;
9303 bool up_thread_sorryserver_send_call_check;
9305 void down_thread_client_connection_chk_event(const TCP_PROCESS_TYPE_TAG process_type){
9306 down_thread_client_connection_chk_event_call_check = true;;
9308 bool down_thread_client_connection_chk_event_call_check;
9311 void up_thread_function_array_clear(){
9312 for(int i = 0;i <= UP_FUNC_EXIT;i++){
9313 up_thread_function_array[i].second = NULL;
9316 void down_thread_function_array_clear(){
9317 for(int i = 0; i <= DOWN_FUNC_EXIT;i++){
9318 down_thread_function_array[i].second = NULL;
9322 void up_thread_module_event_map_clear(){
9323 up_thread_module_event_map.clear();
9326 void down_thread_module_event_map_clear(){
9327 down_thread_module_event_map.clear();
9331 // up_thread_client_receive test
9332 void up_thread_client_receive_test(){
9333 BOOST_MESSAGE( "----- up_thread_client_receive test end -----" );
9335 l7vs::virtualservice_tcp vs;
9336 boost::asio::io_service io;
9337 l7vs::tcp_socket_option_info set_option;
9338 //! TCP_NODELAY (false:not set,true:set option)
9339 set_option.nodelay_opt = false;
9340 //! TCP_NODELAY option value (false:off,true:on)
9341 set_option.nodelay_val = false;
9342 //! TCP_CORK (false:not set,true:set option)
9343 set_option.cork_opt = false;
9344 //! TCP_CORK option value (false:off,true:on)
9345 set_option.cork_val = false;
9346 //! TCP_QUICKACK (false:not set,true:set option)
9347 set_option.quickack_opt = false;
9348 //! TCP_QUICKACK option value (false:off,true:on)
9349 set_option.quickack_val = false;
9351 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
9352 bool set_mode(false);
9353 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
9354 bool set_ssl_cache_flag(false);
9355 int set_ssl_handshake_time_out = 0;
9356 //std::string access_log_file_name = "test";
9357 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
9359 std::string test_protocol_name("test protocol");
9360 l7vs::test_protocol_module proto_test(test_protocol_name);
9361 // up_thread_client_receive
9362 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);
9364 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
9365 boost::thread::id proc_id = boost::this_thread::get_id();
9367 l7vs::tcp_data& up_thread_data_client_side = test_obj.get_up_thread_data_client_side();
9370 // get client socket
9371 l7vs::tcp_socket& socket = test_obj.get_client_socket();
9372 // dummy server client socket connect
9373 boost::system::error_code ec;
9374 test_mirror_server test_server;
9376 test_server.breq_acc_flag = true;
9378 test_server.breq_close_wait_flag = true;
9380 test_server.req_recv_cnt = 0;
9381 // test server start
9382 boost::thread server_thread(boost::bind(&test_mirror_server::run,&test_server));
9383 while( !test_server.brun_flag ){
9388 boost::asio::ip::tcp::endpoint connect_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
9389 socket.get_socket().connect(connect_end,ec);
9391 socket.is_open_res = true;
9393 while(!test_server.bconnect_flag){
9396 boost::asio::ip::tcp::endpoint local_endpoint = socket.get_socket().local_endpoint(ec);
9400 up_thread_data_client_side.initialize();
9401 test_obj.set_up_thread_id(proc_id);
9402 test_obj.set_down_thread_id(boost::thread::id());
9403 test_obj.up_thread_realserver_get_destination_event_call_check = false;
9404 test_obj.up_thread_client_disconnect_call_check = false;
9405 test_obj.up_thread_exit_call_check = false;
9406 test_obj.up_thread_client_receive_call_check = false;
9408 vs.get_wait_upstream_res = 0;
9409 vs.update_up_recv_size_in = 0;
9411 socket.read_some_res = MAX_BUFFER_SIZE;
9412 socket.read_some_ec.clear();
9413 char set_char = CHAR_MIN;
9414 for(int i = 0;i < MAX_BUFFER_SIZE;i++){
9415 socket.read_some_buffers_out[i] = set_char;
9416 if(set_char == CHAR_MAX)
9417 set_char = CHAR_MIN;
9421 socket.read_some_buffers_size_in = 0;
9422 socket.read_some_call_check = false;
9423 // protocol module set
9424 proto_test.handle_client_recv_res_tag = l7vs::protocol_module_base::REALSERVER_SELECT;
9425 proto_test.handle_client_recv_in_thread_id = boost::thread::id();
9426 for(int i = 0;i < MAX_BUFFER_SIZE;i++){
9427 proto_test.handle_client_recv_in_recvbuffer[i] = '\0';
9429 proto_test.handle_client_recv_in_recvlen = 0;
9431 l7vs::Logger::test_loglevel = l7vs::LOG_LV_DEBUG;
9432 l7vs::Logger::putLogDebug_category = l7vs::LOG_CAT_NONE;
9433 l7vs::Logger::putLogDebug_id = 0;
9435 test_obj.test_call_client_receive();
9437 // unit_test [1] up_thread_client_receive client_socket read_some call check
9438 std::cout << "[1] up_thread_client_receive client_socket read_some call check" << std::endl;
9439 BOOST_CHECK(socket.read_some_call_check);
9440 BOOST_CHECK(socket.read_some_buffers_out == up_thread_data_client_side.get_data());
9441 BOOST_CHECK(socket.read_some_buffers_size_in == MAX_BUFFER_SIZE);
9442 BOOST_CHECK(socket.read_some_res == up_thread_data_client_side.get_size());
9444 // unit_test [2] up_thread_client_receive virtualservice update_up_recv_size_in call check
9445 std::cout << "[2] up_thread_client_receive virtualservice update_up_recv_size_in call check" << std::endl;
9446 BOOST_CHECK(vs.update_up_recv_size_in == MAX_BUFFER_SIZE);
9448 // unit_test [3] up_thread_client_receive protocol module handle_client_recv call check
9449 std::cout << "[3] up_thread_client_receive protocol module handle_client_recv call check" << std::endl;
9450 BOOST_CHECK(proto_test.handle_client_recv_in_thread_id == proc_id);
9451 BOOST_CHECK(proto_test.handle_client_recv_in_recvlen == socket.read_some_res);
9452 BOOST_CHECK(proto_test.handle_client_recv_in_recvbuffer == socket.read_some_buffers_out);
9454 // unit_test [4] up_thread_client_receive up_thread_next_call_function update check
9455 std::cout << "[4] up_thread_client_receive up_thread_next_call_function update check" << std::endl;
9456 test_obj.next_up_function_call();
9457 BOOST_CHECK(test_obj.up_thread_realserver_get_destination_event_call_check);
9459 // unit_test [5] up_thread_client_receive qos check
9460 std::cout << "[5] up_thread_client_receive qos check" << std::endl;
9461 socket.read_some_res = 0;
9462 vs.get_wait_upstream_res = 1;
9464 // wait = 0 >> receive
9465 socket.read_some_call_check = false;
9466 vs.get_wait_upstream_res = 0;
9467 test_obj.test_call_client_receive();
9468 BOOST_CHECK(socket.read_some_call_check);
9470 // wait = 1 >> not receive
9471 socket.read_some_call_check = false;
9472 vs.get_wait_upstream_res = 1;
9473 test_obj.test_call_client_receive();
9474 BOOST_CHECK(!socket.read_some_call_check);
9475 std::cout << l7vs::Logger::putLogDebug_message << std::endl;
9477 socket.read_some_res = MAX_BUFFER_SIZE;
9478 vs.get_throughput_upstream_res = 0;
9479 vs.get_wait_upstream_res = 0;
9481 // unit_test [6] up_thread_client_receive receive size 0 check
9482 std::cout << "[6] up_thread_client_receive receive size 0 check" << std::endl;
9483 test_obj.set_up_thread_next_function_call_exit();
9484 socket.read_some_res = 0;
9485 test_obj.test_call_client_receive();
9486 test_obj.up_thread_client_receive_call_check = false;
9487 test_obj.next_up_function_call();
9488 BOOST_CHECK(test_obj.up_thread_client_receive_call_check);
9489 socket.read_some_res = MAX_BUFFER_SIZE;
9491 // unit_test [7] up_thread_client_receive socket error (try_again) check
9492 std::cout << "[7] up_thread_client_receive socket error (try_again) check" << std::endl;
9493 test_obj.set_up_thread_next_function_call_exit();
9494 socket.read_some_ec = boost::asio::error::try_again;
9495 test_obj.test_call_client_receive();
9496 test_obj.up_thread_client_receive_call_check = false;
9497 test_obj.next_up_function_call();
9498 BOOST_CHECK(test_obj.up_thread_client_receive_call_check);
9499 socket.read_some_ec.clear();
9501 // unit_test [8] up_thread_client_receive socket error (eof) check
9502 std::cout << "[8] up_thread_client_receive socket error (eof) check" << std::endl;
9503 test_obj.set_up_thread_next_function_call_exit();
9504 socket.read_some_ec = boost::asio::error::eof;
9505 test_obj.test_call_client_receive();
9506 test_obj.up_thread_client_disconnect_call_check = false;
9507 test_obj.next_up_function_call();
9508 BOOST_CHECK(test_obj.up_thread_client_disconnect_call_check);
9509 socket.read_some_ec.clear();
9511 // unit_test [9] up_thread_client_receive socket error (connection_reset) check
9512 std::cout << "[9] up_thread_client_receive socket error (connection_reset) check" << std::endl;
9513 test_obj.set_up_thread_next_function_call_exit();
9514 socket.read_some_ec = boost::asio::error::connection_reset;
9515 test_obj.test_call_client_receive();
9516 test_obj.up_thread_client_disconnect_call_check = false;
9517 test_obj.next_up_function_call();
9518 BOOST_CHECK(test_obj.up_thread_client_disconnect_call_check);
9519 socket.read_some_ec.clear();
9521 // unit_test [10] up_thread_client_receive socket error (bad_descriptor) check
9522 std::cout << "[10] up_thread_client_receive socket error (bad_descriptor) check" << std::endl;
9523 test_obj.set_up_thread_next_function_call_exit();
9524 socket.read_some_ec = boost::asio::error::bad_descriptor;
9525 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
9526 l7vs::Logger::putLogError_id = 0;
9527 test_obj.test_call_client_receive();
9528 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_NONE,l7vs::Logger::putLogError_category);
9529 BOOST_CHECK_EQUAL(0,l7vs::Logger::putLogError_id);
9530 test_obj.up_thread_client_disconnect_call_check = false;
9531 test_obj.next_up_function_call();
9532 BOOST_CHECK(test_obj.up_thread_client_disconnect_call_check);
9533 socket.read_some_ec.clear();
9535 // unit_test [11] up_thread_client_receive closed socket error (bad_descriptor) check
9536 std::cout << "[11] up_thread_client_receive closed socket error (bad_descriptor) check" << std::endl;
9537 test_obj.set_up_thread_next_function_call_exit();
9538 socket.read_some_ec = boost::asio::error::bad_descriptor;
9539 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
9540 l7vs::Logger::putLogError_id = 0;
9541 socket.is_open_res = false;
9542 test_obj.test_call_client_receive();
9543 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_NONE,l7vs::Logger::putLogError_category);
9544 BOOST_CHECK_EQUAL(0,l7vs::Logger::putLogError_id);
9545 test_obj.up_thread_client_disconnect_call_check = false;
9546 test_obj.next_up_function_call();
9547 BOOST_CHECK(test_obj.up_thread_client_disconnect_call_check);
9548 socket.read_some_ec.clear();
9550 // unit_test [12] up_thread_client_receive not fond function error check
9551 std::cout << "[12] up_thread_client_receive not fond function error check" << std::endl;
9552 test_obj.up_thread_function_array_clear();
9553 test_obj.up_thread_exit_call_check = false;
9554 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
9555 l7vs::Logger::putLogError_id = 0;
9556 test_obj.test_call_client_receive();
9557 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
9558 BOOST_CHECK_EQUAL(21,l7vs::Logger::putLogError_id);
9559 std::cout << l7vs::Logger::putLogError_message << std::endl;
9560 BOOST_CHECK(test_obj.up_thread_exit_call_check);
9562 // unit_test [13] up_thread_client_receive returnd illegal EVENT_TAG error check
9563 std::cout << "[13] up_thread_client_receive returnd illegal EVENT_TAG error check" << std::endl;
9564 test_obj.up_thread_module_event_map_clear();
9565 test_obj.up_thread_exit_call_check = false;
9566 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
9567 l7vs::Logger::putLogError_id = 0;
9568 test_obj.test_call_client_receive();
9569 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
9570 BOOST_CHECK_EQUAL(20,l7vs::Logger::putLogError_id);
9571 std::cout << l7vs::Logger::putLogError_message << std::endl;
9572 BOOST_CHECK(test_obj.up_thread_exit_call_check);
9574 // dummy server stop
9575 test_server.breq_close_wait_flag = false;
9576 test_server.bstop_flag = true;
9577 server_thread.join();
9581 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);
9582 test_ssl_mode_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
9583 l7vs::tcp_ssl_socket& ssl_socket = test_ssl_mode_obj.get_client_ssl_socket();
9584 l7vs::tcp_data& up_thread_data_ssl_client_side = test_ssl_mode_obj.get_up_thread_data_client_side();
9587 up_thread_data_ssl_client_side.initialize();
9588 test_ssl_mode_obj.set_up_thread_id(proc_id);
9589 test_ssl_mode_obj.set_down_thread_id(boost::thread::id());
9590 test_ssl_mode_obj.up_thread_realserver_get_destination_event_call_check = false;
9591 test_ssl_mode_obj.up_thread_client_disconnect_call_check = false;
9592 test_ssl_mode_obj.up_thread_exit_call_check = false;
9593 test_ssl_mode_obj.up_thread_client_receive_call_check = false;
9596 vs.get_wait_upstream_res = 0;
9597 vs.update_up_recv_size_in = 0;
9600 ssl_socket.read_some_res = MAX_BUFFER_SIZE;
9601 ssl_socket.read_some_ec.clear();
9602 set_char = CHAR_MIN;
9603 for(int i = 0;i < MAX_BUFFER_SIZE;i++){
9604 ssl_socket.read_some_buffers_out[i] = set_char;
9605 if(set_char == CHAR_MAX)
9606 set_char = CHAR_MIN;
9610 ssl_socket.read_some_buffers_size_in = 0;
9611 ssl_socket.read_some_call_check = false;
9613 // protocol module set
9614 proto_test.handle_client_recv_res_tag = l7vs::protocol_module_base::REALSERVER_SELECT;
9615 proto_test.handle_client_recv_in_thread_id = boost::thread::id();
9616 for(int i = 0;i < MAX_BUFFER_SIZE;i++){
9617 proto_test.handle_client_recv_in_recvbuffer[i] = '\0';
9619 proto_test.handle_client_recv_in_recvlen = 0;
9621 l7vs::Logger::test_loglevel = l7vs::LOG_LV_DEBUG;
9622 l7vs::Logger::putLogDebug_category = l7vs::LOG_CAT_NONE;
9623 l7vs::Logger::putLogDebug_id = 0;
9625 test_ssl_mode_obj.test_call_client_receive();
9627 // unit_test [14] up_thread_client_receive ssl mode client_ssl_socket read_some call check
9628 std::cout << "[14] up_thread_client_receive ssl mode client_ssl_socket read_some call check" << std::endl;
9629 BOOST_CHECK(ssl_socket.read_some_call_check);
9630 BOOST_CHECK(ssl_socket.read_some_buffers_out == up_thread_data_ssl_client_side.get_data());
9631 BOOST_CHECK(ssl_socket.read_some_buffers_size_in == MAX_BUFFER_SIZE);
9632 BOOST_CHECK(ssl_socket.read_some_res == up_thread_data_ssl_client_side.get_size());
9634 BOOST_MESSAGE( "----- up_thread_client_receive test end -----" );
9638 // down_thread_realserver_receive test
9639 void down_thread_realserver_receive_test(){
9640 BOOST_MESSAGE( "----- down_thread_realserver_receive test start -----" );
9641 // boost::asio::io_service io;
9642 // l7vs::virtualservice_tcp vs;
9643 l7vs::virtualservice_tcp vs;
9644 boost::asio::io_service io;
9645 l7vs::tcp_socket_option_info set_option;
9646 //! TCP_NODELAY (false:not set,true:set option)
9647 set_option.nodelay_opt = false;
9648 //! TCP_NODELAY option value (false:off,true:on)
9649 set_option.nodelay_val = false;
9650 //! TCP_CORK (false:not set,true:set option)
9651 set_option.cork_opt = false;
9652 //! TCP_CORK option value (false:off,true:on)
9653 set_option.cork_val = false;
9654 //! TCP_QUICKACK (false:not set,true:set option)
9655 set_option.quickack_opt = false;
9656 //! TCP_QUICKACK option value (false:off,true:on)
9657 set_option.quickack_val = false;
9659 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
9660 bool set_mode(false);
9661 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
9662 bool set_ssl_cache_flag(false);
9663 int set_ssl_handshake_time_out = 0;
9664 //std::string access_log_file_name = "test";
9665 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
9667 std::string test_protocol_name("test protocol");
9668 l7vs::test_protocol_module proto_test(test_protocol_name);
9669 // receive_send_test_class test_obj(vs,io);
9670 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);
9673 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
9674 boost::thread::id proc_id = boost::this_thread::get_id();
9676 l7vs::tcp_data& down_thread_data_dest_side = test_obj.get_down_thread_data_dest_side();
9678 // set realserver socket
9679 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();
9680 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();
9681 std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > push_pair;
9683 for(int i = 0 ; i < 3 ;i++){
9684 boost::shared_ptr< l7vs::tcp_socket > new_socket(new l7vs::tcp_socket(io));
9685 push_pair.first.address(boost::asio::ip::address::from_string(DUMMI_SERVER_IP));
9686 push_pair.first.port(7000+i);
9687 push_pair.second = new_socket;
9689 new_socket->read_some_res = MAX_BUFFER_SIZE;
9690 new_socket->read_some_ec.clear();
9691 new_socket->is_open_res = true;
9692 char set_char = CHAR_MIN;
9693 for(int j = 0;j < MAX_BUFFER_SIZE;j++){
9694 new_socket->read_some_buffers_out[j] = set_char;
9695 if(set_char == CHAR_MAX)
9696 set_char = CHAR_MIN;
9700 new_socket->read_some_buffers_size_in = 0;
9701 new_socket->read_some_call_check = false;
9702 rs_list.push_back(push_pair);
9704 rs_cur = rs_list.begin();
9707 down_thread_data_dest_side.initialize();
9708 test_obj.set_down_thread_id(proc_id);
9709 test_obj.set_up_thread_id(boost::thread::id());
9710 test_obj.down_thread_client_connection_chk_event_call_check = false;
9711 test_obj.down_thread_realserver_disconnect_call_check = false;
9712 test_obj.down_thread_exit_call_check = false;
9713 test_obj.down_thread_realserver_receive_call_check = false;
9715 // vs.get_qos_downstream_res = 104857600;
9716 // vs.get_throughput_downstream_res = 0;
9717 vs.get_wait_downstream_res = 0;
9718 vs.update_down_recv_size_in = 0;
9719 // protocol module set
9720 proto_test.handle_realserver_recv_tcp_res_tag = l7vs::protocol_module_base::CLIENT_CONNECTION_CHECK;
9721 proto_test.handle_realserver_recv_tcp_in_thread_id = boost::thread::id();
9722 for(int i = 0;i < MAX_BUFFER_SIZE;i++){
9723 proto_test.handle_realserver_recv_tcp_in_recvbuffer[i] = '\0';
9725 proto_test.handle_realserver_recv_tcp_in_recvlen = 0;
9726 proto_test.handle_realserver_recv_tcp_in_rs_endpoint = boost::asio::ip::tcp::endpoint();
9728 boost::asio::ip::tcp::endpoint rs_end = rs_cur->first;
9729 l7vs::tcp_socket& socket = *(rs_cur->second);
9730 l7vs::Logger::test_loglevel = l7vs::LOG_LV_DEBUG;
9731 l7vs::Logger::putLogDebug_category = l7vs::LOG_CAT_NONE;
9732 l7vs::Logger::putLogDebug_id = 0;
9734 test_obj.test_call_realserver_receive();
9736 // unit_test [1] down_thread_realserver_receive realserver read_some call check
9737 std::cout << "[1] down_thread_realserver_receive realserver read_some call check" << std::endl;
9738 BOOST_CHECK(socket.read_some_call_check);
9739 BOOST_CHECK(socket.read_some_buffers_out == down_thread_data_dest_side.get_data());
9740 BOOST_CHECK(socket.read_some_buffers_size_in == MAX_BUFFER_SIZE);
9741 BOOST_CHECK(socket.read_some_res == down_thread_data_dest_side.get_size());
9742 BOOST_CHECK(rs_end == down_thread_data_dest_side.get_endpoint());
9744 // unit_test [2] down_thread_realserver_receive virtualservice update_down_recv_size_in call check
9745 std::cout << "[2] down_thread_realserver_receive virtualservice update_down_recv_size_in call check" << std::endl;
9746 BOOST_CHECK(vs.update_down_recv_size_in == MAX_BUFFER_SIZE);
9748 // unit_test [3] down_thread_realserver_receive protocol module handle_realserver_recv call check
9749 std::cout << "[3] down_thread_realserver_receive protocol module handle_realserver_recv call check" << std::endl;
9750 BOOST_CHECK(proto_test.handle_realserver_recv_tcp_in_thread_id == proc_id);
9751 BOOST_CHECK(proto_test.handle_realserver_recv_tcp_in_recvlen == socket.read_some_res);
9752 BOOST_CHECK(proto_test.handle_realserver_recv_tcp_in_recvbuffer == socket.read_some_buffers_out);
9753 BOOST_CHECK(proto_test.handle_realserver_recv_tcp_in_rs_endpoint == rs_end);
9755 // unit_test [4] down_thread_realserver_receive down_thread_next_call_function update check
9756 std::cout << "[4] down_thread_realserver_receive down_thread_next_call_function update check" << std::endl;
9757 test_obj.next_down_function_call();
9758 BOOST_CHECK(test_obj.down_thread_client_connection_chk_event_call_check);
9760 // unit_test [5] down_thread_realserver_receive realserver_recv down_thread_current_receive_realserver_socket inclement & cyclic check
9761 std::cout << "[5] down_thread_realserver_receive realserver_recv down_thread_current_receive_realserver_socket inclement & cyclic check" << std::endl;
9762 std::list< std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > >::iterator check_it;
9763 rs_cur = rs_list.begin();
9764 check_it = rs_list.begin();
9765 test_obj.test_call_realserver_receive();
9767 BOOST_CHECK(check_it == rs_cur);
9768 test_obj.test_call_realserver_receive();
9770 BOOST_CHECK(check_it == rs_cur);
9771 test_obj.test_call_realserver_receive();
9772 check_it = rs_list.begin();
9773 BOOST_CHECK(check_it == rs_cur);
9775 // unit_test [6] down_thread_realserver_receive qos check
9776 std::cout << "[6] down_thread_realserver_receive qos check" << std::endl;
9777 socket.read_some_res = 0;
9779 // wait = 0 >> receive
9780 rs_cur = rs_list.begin();
9781 socket.read_some_call_check = false;
9782 vs.get_wait_downstream_res = 0;
9783 test_obj.test_call_realserver_receive();
9784 BOOST_CHECK(socket.read_some_call_check);
9786 // wait = 1 >> not receive
9787 rs_cur = rs_list.begin();
9788 socket.read_some_call_check = false;
9789 vs.get_wait_downstream_res = 1;
9790 test_obj.test_call_realserver_receive();
9791 BOOST_CHECK(!socket.read_some_call_check);
9793 socket.read_some_res = MAX_BUFFER_SIZE;
9794 vs.get_throughput_downstream_res = 0;
9795 vs.get_wait_downstream_res = 0;
9797 // unit_test [7] down_thread_realserver_receive receive size 0 check
9798 std::cout << "[7] down_thread_realserver_receive receive size 0 check" << std::endl;
9799 rs_cur = rs_list.begin();
9800 test_obj.set_down_thread_next_function_call_exit();
9801 socket.read_some_res = 0;
9802 test_obj.test_call_realserver_receive();
9803 test_obj.down_thread_realserver_receive_call_check = false;
9804 test_obj.next_down_function_call();
9805 BOOST_CHECK(test_obj.down_thread_realserver_receive_call_check);
9806 socket.read_some_res = MAX_BUFFER_SIZE;
9808 // unit_test [8] down_thread_realserver_receive socket error (try_again) check
9809 std::cout << "[8] down_thread_realserver_receive socket error (try_again) check" << std::endl;
9810 rs_cur = rs_list.begin();
9811 test_obj.set_down_thread_next_function_call_exit();
9812 socket.read_some_ec = boost::asio::error::try_again;
9813 test_obj.test_call_realserver_receive();
9814 test_obj.down_thread_realserver_receive_call_check = false;
9815 test_obj.next_down_function_call();
9816 BOOST_CHECK(test_obj.down_thread_realserver_receive_call_check);
9817 socket.read_some_ec.clear();
9819 // unit_test [9] down_thread_realserver_receive socket error (eof) check
9820 std::cout << "[9] down_thread_realserver_receive socket error (eof) check" << std::endl;
9821 rs_cur = rs_list.begin();
9822 test_obj.set_down_thread_next_function_call_exit();
9823 socket.read_some_ec = boost::asio::error::eof;
9824 test_obj.test_call_realserver_receive();
9825 test_obj.down_thread_realserver_disconnect_call_check = false;
9826 test_obj.next_down_function_call();
9827 BOOST_CHECK(test_obj.down_thread_realserver_disconnect_call_check);
9828 socket.read_some_ec.clear();
9830 // unit_test [10] down_thread_realserver_receive socket error (connection_reset) check
9831 std::cout << "[10] down_thread_realserver_receive socket error (connection_reset) check" << std::endl;
9832 rs_cur = rs_list.begin();
9833 test_obj.set_down_thread_next_function_call_exit();
9834 socket.read_some_ec = boost::asio::error::connection_reset;
9835 test_obj.test_call_realserver_receive();
9836 test_obj.down_thread_realserver_disconnect_call_check = false;
9837 test_obj.next_down_function_call();
9838 BOOST_CHECK(test_obj.down_thread_realserver_disconnect_call_check);
9839 socket.read_some_ec.clear();
9841 // unit_test [11] down_thread_realserver_receive socket error (bad_descriptor) check
9842 std::cout << "[11] down_thread_realserver_receive socket error (bad_descriptor) check" << std::endl;
9843 rs_cur = rs_list.begin();
9844 test_obj.set_down_thread_next_function_call_exit();
9845 socket.read_some_ec = boost::asio::error::bad_descriptor;
9846 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
9847 l7vs::Logger::putLogError_id = 0;
9848 test_obj.test_call_realserver_receive();
9849 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_NONE,l7vs::Logger::putLogError_category);
9850 BOOST_CHECK_EQUAL(0,l7vs::Logger::putLogError_id);
9851 std::cout << l7vs::Logger::putLogError_message << std::endl;
9852 test_obj.down_thread_realserver_disconnect_call_check = false;
9853 test_obj.next_down_function_call();
9854 BOOST_CHECK(test_obj.down_thread_realserver_disconnect_call_check);
9855 socket.read_some_ec.clear();
9857 // unit_test [12] down_thread_realserver_receive closed socket error (bad_descriptor) check
9858 std::cout << "[12] down_thread_realserver_receive closed socket error (bad_descriptor) check" << std::endl;
9859 rs_cur = rs_list.begin();
9860 test_obj.set_down_thread_next_function_call_exit();
9861 socket.read_some_ec = boost::asio::error::bad_descriptor;
9862 socket.is_open_res = false;
9863 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
9864 l7vs::Logger::putLogError_id = 0;
9865 test_obj.test_call_realserver_receive();
9866 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_NONE,l7vs::Logger::putLogError_category);
9867 BOOST_CHECK_EQUAL(0,l7vs::Logger::putLogError_id);
9868 test_obj.down_thread_realserver_disconnect_call_check = false;
9869 test_obj.next_down_function_call();
9870 BOOST_CHECK(test_obj.down_thread_realserver_disconnect_call_check);
9871 socket.read_some_ec.clear();
9873 // unit_test [13] down_thread_realserver_receive not fond function error check
9874 std::cout << "[13] down_thread_realserver_receive not fond function error check" << std::endl;
9875 test_obj.down_thread_function_array_clear();
9876 test_obj.down_thread_exit_call_check = false;
9877 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
9878 l7vs::Logger::putLogError_id = 0;
9879 test_obj.test_call_realserver_receive();
9880 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
9881 BOOST_CHECK_EQUAL(71,l7vs::Logger::putLogError_id);
9882 std::cout << l7vs::Logger::putLogError_message << std::endl;
9883 BOOST_CHECK(test_obj.down_thread_exit_call_check);
9885 // unit_test [14] down_thread_realserver_receive returnd illegal EVENT_TAG error check
9886 std::cout << "[14] down_thread_realserver_receive returnd illegal EVENT_TAG error check" << std::endl;
9887 test_obj.down_thread_module_event_map_clear();
9888 test_obj.down_thread_exit_call_check = false;
9889 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
9890 l7vs::Logger::putLogError_id = 0;
9891 test_obj.test_call_realserver_receive();
9892 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
9893 BOOST_CHECK_EQUAL(70,l7vs::Logger::putLogError_id);
9894 std::cout << l7vs::Logger::putLogError_message << std::endl;
9895 BOOST_CHECK(test_obj.down_thread_exit_call_check);
9897 // unit_test [15] down_thread_realserver_receive empty down_thread_receive_realserver_socket_list check
9898 std::cout << "[15] down_thread_realserver_receive empty down_thread_receive_realserver_socket_list check" << std::endl;
9899 rs_cur = rs_list.begin();
9900 std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > sock_pair = *rs_cur;
9902 // BOOST_CHECK(*rs_cur == sock_pair);
9903 socket.read_some_call_check = false;
9904 test_obj.test_call_realserver_receive();
9905 BOOST_CHECK(!socket.read_some_call_check);
9907 BOOST_MESSAGE( "----- down_thread_realserver_receive test end -----" );
9910 // down_thread_sorryserver_receive test
9911 void down_thread_sorryserver_receive_test(){
9912 BOOST_MESSAGE( "----- down_thread_sorryserver_receive test start -----" );
9913 // boost::asio::io_service io;
9914 // l7vs::virtualservice_tcp vs;
9915 l7vs::virtualservice_tcp vs;
9916 boost::asio::io_service io;
9917 l7vs::tcp_socket_option_info set_option;
9918 //! TCP_NODELAY (false:not set,true:set option)
9919 set_option.nodelay_opt = false;
9920 //! TCP_NODELAY option value (false:off,true:on)
9921 set_option.nodelay_val = false;
9922 //! TCP_CORK (false:not set,true:set option)
9923 set_option.cork_opt = false;
9924 //! TCP_CORK option value (false:off,true:on)
9925 set_option.cork_val = false;
9926 //! TCP_QUICKACK (false:not set,true:set option)
9927 set_option.quickack_opt = false;
9928 //! TCP_QUICKACK option value (false:off,true:on)
9929 set_option.quickack_val = false;
9931 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
9932 bool set_mode(false);
9933 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
9934 bool set_ssl_cache_flag(false);
9935 int set_ssl_handshake_time_out = 0;
9936 //std::string access_log_file_name = "test";
9937 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
9939 std::string test_protocol_name("test protocol");
9940 l7vs::test_protocol_module proto_test(test_protocol_name);
9941 // receive_send_test_class test_obj(vs,io);
9942 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);
9944 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
9945 boost::thread::id proc_id = boost::this_thread::get_id();
9947 l7vs::tcp_data& down_thread_data_dest_side = test_obj.get_down_thread_data_dest_side();
9949 // set sorryserver socket
9950 std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > >& socket_pair = test_obj.get_sorryserver_socket();
9951 boost::asio::ip::tcp::endpoint& sorry_end = socket_pair.first;
9952 l7vs::tcp_socket& socket = *(socket_pair.second);
9953 sorry_end.address(boost::asio::ip::address::from_string(DUMMI_SERVER_IP));
9954 sorry_end.port(7000);
9956 socket.read_some_res = MAX_BUFFER_SIZE;
9957 socket.read_some_ec.clear();
9958 socket.is_open_res = true;
9959 char set_char = CHAR_MIN;
9960 for(int j = 0;j < MAX_BUFFER_SIZE;j++){
9961 socket.read_some_buffers_out[j] = set_char;
9962 if(set_char == CHAR_MAX)
9963 set_char = CHAR_MIN;
9967 socket.read_some_buffers_size_in = 0;
9968 socket.read_some_call_check = false;
9970 down_thread_data_dest_side.initialize();
9971 test_obj.set_down_thread_id(proc_id);
9972 test_obj.set_up_thread_id(boost::thread::id());
9973 test_obj.down_thread_client_connection_chk_event_call_check = false;
9974 test_obj.down_thread_realserver_disconnect_call_check = false;
9975 test_obj.down_thread_exit_call_check = false;
9976 test_obj.down_thread_realserver_receive_call_check = false;
9978 vs.get_qos_downstream_res = 104857600;
9979 vs.get_throughput_downstream_res = 0;
9980 vs.update_down_recv_size_in = 0;
9981 // protocol module set
9982 proto_test.handle_sorryserver_recv_res_tag = l7vs::protocol_module_base::CLIENT_CONNECTION_CHECK;
9983 proto_test.handle_sorryserver_recv_in_thread_id = boost::thread::id();
9984 for(int i = 0;i < MAX_BUFFER_SIZE;i++){
9985 proto_test.handle_sorryserver_recv_in_recvbuffer[i] = '\0';
9987 proto_test.handle_sorryserver_recv_in_recvlen = 0;
9988 proto_test.handle_sorryserver_recv_in_sorry_endpoint = boost::asio::ip::tcp::endpoint();
9990 l7vs::Logger::test_loglevel = l7vs::LOG_LV_DEBUG;
9991 l7vs::Logger::putLogDebug_category = l7vs::LOG_CAT_NONE;
9992 l7vs::Logger::putLogDebug_id = 0;
9994 test_obj.test_call_sorryserver_receive();
9996 // unit_test [1] down_thread_sorryserver_receive sorryserver read_some call check
9997 std::cout << "[1] down_thread_sorryserver_receive sorryserver read_some call check" << std::endl;
9998 BOOST_CHECK(socket.read_some_call_check);
9999 BOOST_CHECK(socket.read_some_buffers_out == down_thread_data_dest_side.get_data());
10000 BOOST_CHECK(socket.read_some_buffers_size_in == MAX_BUFFER_SIZE);
10001 BOOST_CHECK(socket.read_some_res == down_thread_data_dest_side.get_size());
10002 BOOST_CHECK(sorry_end == down_thread_data_dest_side.get_endpoint());
10004 // unit_test [2] down_thread_sorryserver_receive protocol module handle_sorryserver_recv call check
10005 std::cout << "[2] down_thread_sorryserver_receive protocol module handle_sorryserver_recv call check" << std::endl;
10006 BOOST_CHECK(proto_test.handle_sorryserver_recv_in_thread_id == proc_id);
10007 BOOST_CHECK(proto_test.handle_sorryserver_recv_in_recvlen == socket.read_some_res);
10008 BOOST_CHECK(proto_test.handle_sorryserver_recv_in_recvbuffer == socket.read_some_buffers_out);
10009 BOOST_CHECK(proto_test.handle_sorryserver_recv_in_sorry_endpoint == sorry_end);
10011 // unit_test [3] down_thread_sorryserver_receive down_thread_next_call_function update check
10012 std::cout << "[3] down_thread_sorryserver_receive down_thread_next_call_function update check" << std::endl;
10013 test_obj.next_down_function_call();
10014 BOOST_CHECK(test_obj.down_thread_client_connection_chk_event_call_check);
10016 // unit_test [4] down_thread_sorryserver_receive receive size 0 check
10017 std::cout << "[4] down_thread_sorryserver_receive receive size 0 check" << std::endl;
10018 test_obj.set_down_thread_next_function_call_exit();
10019 socket.read_some_res = 0;
10020 test_obj.test_call_sorryserver_receive();
10021 test_obj.down_thread_sorryserver_receive_call_check = false;
10022 test_obj.next_down_function_call();
10023 BOOST_CHECK(test_obj.down_thread_sorryserver_receive_call_check);
10024 socket.read_some_res = MAX_BUFFER_SIZE;
10026 // unit_test [5] down_thread_sorryserver_receive socket error (try_again) check
10027 std::cout << "[5] down_thread_sorryserver_receive socket error (try_again) check" << std::endl;
10028 test_obj.set_down_thread_next_function_call_exit();
10029 socket.read_some_ec = boost::asio::error::try_again;
10030 test_obj.test_call_sorryserver_receive();
10031 test_obj.down_thread_sorryserver_receive_call_check = false;
10032 test_obj.next_down_function_call();
10033 BOOST_CHECK(test_obj.down_thread_sorryserver_receive_call_check);
10034 socket.read_some_ec.clear();
10036 // unit_test [6] down_thread_sorryserver_receive socket error (eof) check
10037 std::cout << "[6] down_thread_sorryserver_receive socket error (eof) check" << std::endl;
10038 test_obj.set_down_thread_next_function_call_exit();
10039 socket.read_some_ec = boost::asio::error::eof;
10040 test_obj.test_call_sorryserver_receive();
10041 test_obj.down_thread_sorryserver_disconnect_call_check = false;
10042 test_obj.next_down_function_call();
10043 BOOST_CHECK(test_obj.down_thread_sorryserver_disconnect_call_check);
10044 socket.read_some_ec.clear();
10046 // unit_test [7] down_thread_sorryserver_receive socket error (connection_reset) check
10047 std::cout << "[7] down_thread_sorryserver_receive socket error (connection_reset) check" << std::endl;
10048 test_obj.set_down_thread_next_function_call_exit();
10049 socket.read_some_ec = boost::asio::error::connection_reset;
10050 test_obj.test_call_sorryserver_receive();
10051 test_obj.down_thread_sorryserver_disconnect_call_check = false;
10052 test_obj.next_down_function_call();
10053 BOOST_CHECK(test_obj.down_thread_sorryserver_disconnect_call_check);
10054 socket.read_some_ec.clear();
10056 // unit_test [8] down_thread_sorryserver_receive socket error (bad_descriptor) check
10057 std::cout << "[8] down_thread_sorryserver_receive socket error (bad_descriptor) check" << std::endl;
10058 test_obj.set_down_thread_next_function_call_exit();
10059 socket.read_some_ec = boost::asio::error::bad_descriptor;
10060 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
10061 l7vs::Logger::putLogError_id = 0;
10062 test_obj.test_call_sorryserver_receive();
10063 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_NONE,l7vs::Logger::putLogError_category);
10064 BOOST_CHECK_EQUAL(0,l7vs::Logger::putLogError_id);
10065 std::cout << l7vs::Logger::putLogError_message << std::endl;
10066 test_obj.down_thread_sorryserver_disconnect_call_check = false;
10067 test_obj.next_down_function_call();
10068 BOOST_CHECK(test_obj.down_thread_sorryserver_disconnect_call_check);
10069 socket.read_some_ec.clear();
10071 // unit_test [9] down_thread_sorryserver_receive closed socket error (bad_descriptor) check
10072 std::cout << "[9] down_thread_sorryserver_receive closed socket error (bad_descriptor) check" << std::endl;
10073 test_obj.set_down_thread_next_function_call_exit();
10074 socket.read_some_ec = boost::asio::error::bad_descriptor;
10075 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
10076 l7vs::Logger::putLogError_id = 0;
10077 socket.is_open_res = false;
10078 test_obj.test_call_sorryserver_receive();
10079 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_NONE,l7vs::Logger::putLogError_category);
10080 BOOST_CHECK_EQUAL(0,l7vs::Logger::putLogError_id);
10081 test_obj.down_thread_sorryserver_disconnect_call_check = false;
10082 test_obj.next_down_function_call();
10083 BOOST_CHECK(test_obj.down_thread_sorryserver_disconnect_call_check);
10084 socket.read_some_ec.clear();
10086 // unit_test [10] down_thread_sorryserver_receive not fond function error check
10087 std::cout << "[10] down_thread_sorryserver_receive not fond function error check" << std::endl;
10088 test_obj.down_thread_function_array_clear();
10089 test_obj.down_thread_exit_call_check = false;
10090 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
10091 l7vs::Logger::putLogError_id = 0;
10092 test_obj.test_call_sorryserver_receive();
10093 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
10094 BOOST_CHECK_EQUAL(89,l7vs::Logger::putLogError_id);
10095 std::cout << l7vs::Logger::putLogError_message << std::endl;
10096 BOOST_CHECK(test_obj.down_thread_exit_call_check);
10098 // unit_test [11] down_thread_sorryserver_receive returnd illegal EVENT_TAG error check
10099 std::cout << "[11] down_thread_sorryserver_receive returnd illegal EVENT_TAG error check" << std::endl;
10100 test_obj.down_thread_module_event_map_clear();
10101 test_obj.down_thread_exit_call_check = false;
10102 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
10103 l7vs::Logger::putLogError_id = 0;
10104 test_obj.test_call_sorryserver_receive();
10105 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
10106 BOOST_CHECK_EQUAL(88,l7vs::Logger::putLogError_id);
10107 std::cout << l7vs::Logger::putLogError_message << std::endl;
10108 BOOST_CHECK(test_obj.down_thread_exit_call_check);
10110 BOOST_MESSAGE( "----- down_thread_sorryserver_receive test end -----" );
10113 // up_thread_realserver_send test
10114 void up_thread_realserver_send_test(){
10115 BOOST_MESSAGE( "----- up_thread_realserver_send test end -----" );
10116 // boost::asio::io_service io;
10117 // l7vs::virtualservice_tcp vs;
10118 l7vs::virtualservice_tcp vs;
10119 boost::asio::io_service io;
10120 l7vs::tcp_socket_option_info set_option;
10121 //! TCP_NODELAY (false:not set,true:set option)
10122 set_option.nodelay_opt = false;
10123 //! TCP_NODELAY option value (false:off,true:on)
10124 set_option.nodelay_val = false;
10125 //! TCP_CORK (false:not set,true:set option)
10126 set_option.cork_opt = false;
10127 //! TCP_CORK option value (false:off,true:on)
10128 set_option.cork_val = false;
10129 //! TCP_QUICKACK (false:not set,true:set option)
10130 set_option.quickack_opt = false;
10131 //! TCP_QUICKACK option value (false:off,true:on)
10132 set_option.quickack_val = false;
10134 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
10135 bool set_mode(false);
10136 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
10137 bool set_ssl_cache_flag(false);
10138 int set_ssl_handshake_time_out = 0;
10139 //std::string access_log_file_name = "test";
10140 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
10142 std::string test_protocol_name("test protocol");
10143 l7vs::test_protocol_module proto_test(test_protocol_name);
10144 // up_thread_realserver_send
10145 // receive_send_test_class test_obj(vs,io);
10146 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);
10148 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
10149 boost::thread::id proc_id = boost::this_thread::get_id();
10151 l7vs::tcp_data& send_data = test_obj.get_up_thread_data_dest_side();
10153 // set realserver socket
10154 std::map<boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > >& rs_map = test_obj.get_up_thread_send_realserver_socket_map();
10155 std::map<boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > >::iterator rs_it;
10156 std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > push_pair;
10157 for(int i = 0 ; i < 3 ;i++){
10158 boost::shared_ptr< l7vs::tcp_socket > new_socket(new l7vs::tcp_socket(io));
10159 push_pair.first.address(boost::asio::ip::address::from_string(DUMMI_SERVER_IP));
10160 push_pair.first.port(7000+i);
10161 push_pair.second = new_socket;
10162 new_socket->write_some_res = MAX_BUFFER_SIZE;
10163 new_socket->write_some_ec.clear();
10164 new_socket->write_some_buffers_in = NULL;
10165 new_socket->write_some_buffers_size_in = 0;
10166 new_socket->write_some_call_check = false;
10167 rs_map.insert(push_pair);
10171 send_data.initialize();
10172 send_data.set_size(MAX_BUFFER_SIZE);
10173 boost::asio::ip::tcp::endpoint send_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP),7002);
10174 send_data.set_endpoint(send_end);
10175 test_obj.set_up_thread_id(proc_id);
10176 test_obj.set_down_thread_id(boost::thread::id());
10177 test_obj.up_thread_client_receive_call_check = false;
10178 test_obj.up_thread_realserver_disconnect_call_check = false;
10179 test_obj.up_thread_exit_call_check = false;
10180 test_obj.up_thread_realserver_get_destination_event_call_check = false;
10182 vs.update_up_send_size_in = 0;
10183 // protocol module set
10184 proto_test.handle_realserver_send_res_tag = l7vs::protocol_module_base::CLIENT_RECV;
10185 proto_test.handle_realserver_send_in_thread_id = boost::thread::id();
10187 rs_it = rs_map.find(send_end);
10188 l7vs::tcp_socket& socket = *(rs_it->second);
10190 l7vs::Logger::test_loglevel = l7vs::LOG_LV_DEBUG;
10191 l7vs::Logger::putLogDebug_category = l7vs::LOG_CAT_NONE;
10192 l7vs::Logger::putLogDebug_id = 0;
10194 test_obj.test_call_realserver_send();
10196 // unit_test [1] up_thread_realserver_send realserver_socket write_some call check
10197 std::cout << "[1] up_thread_realserver_send realserver_socket write_some call check" << std::endl;
10198 BOOST_CHECK(socket.write_some_call_check);
10199 BOOST_CHECK(socket.write_some_buffers_in == (void*)&(send_data.get_data()));
10200 BOOST_CHECK(socket.write_some_buffers_size_in == MAX_BUFFER_SIZE);
10201 BOOST_CHECK(socket.write_some_res == send_data.get_send_size());
10203 // unit_test [2] up_thread_realserver_send virtualservice update_up_send_size_in call check
10204 std::cout << "[2] up_thread_realserver_send virtualservice update_up_send_size_in call check" << std::endl;
10205 BOOST_CHECK(vs.update_up_send_size_in == MAX_BUFFER_SIZE);
10207 // unit_test [3] up_thread_realserver_send protocol module handle_realserver_send call check
10208 std::cout << "[3] up_thread_realserver_send protocol module handle_realserver_send call check" << std::endl;
10209 BOOST_CHECK(proto_test.handle_realserver_send_in_thread_id == proc_id);
10211 // unit_test [4] up_thread_realserver_send up_thread_next_call_function update check
10212 std::cout << "[4] up_thread_realserver_send up_thread_next_call_function update check" << std::endl;
10213 test_obj.next_up_function_call();
10214 BOOST_CHECK(test_obj.up_thread_client_receive_call_check);
10216 // unit_test [5] up_thread_realserver_send send size check
10217 std::cout << "[5] up_thread_realserver_send send size check" << std::endl;
10218 send_data.set_send_size(0);
10219 socket.write_some_res = 0;
10220 test_obj.set_up_thread_next_function_call_exit();
10221 socket.write_some_buffers_in = NULL;
10222 test_obj.test_call_realserver_send();
10223 // BOOST_CHECK((char*)socket.write_some_buffers_in == (char*)&(send_data.get_data()) + 0);
10224 BOOST_CHECK((char*)socket.write_some_buffers_in == (send_data.get_data().data() + 0));
10225 test_obj.up_thread_realserver_send_call_check = false;
10226 test_obj.next_up_function_call();
10227 BOOST_CHECK(test_obj.up_thread_realserver_send_call_check);
10229 socket.write_some_res = MAX_BUFFER_SIZE / 3;
10230 test_obj.set_up_thread_next_function_call_exit();
10231 socket.write_some_buffers_in = NULL;
10232 test_obj.test_call_realserver_send();
10233 // BOOST_CHECK((char*)socket.write_some_buffers_in == (char*)&(send_data.get_data()) + 0);
10234 BOOST_CHECK((char*)socket.write_some_buffers_in == (send_data.get_data().data() + 0));
10235 test_obj.up_thread_realserver_send_call_check = false;
10236 test_obj.next_up_function_call();
10237 BOOST_CHECK(test_obj.up_thread_realserver_send_call_check);
10239 socket.write_some_res = MAX_BUFFER_SIZE / 3;
10240 test_obj.set_up_thread_next_function_call_exit();
10241 socket.write_some_buffers_in = NULL;
10242 test_obj.test_call_realserver_send();
10243 // BOOST_CHECK((char*)socket.write_some_buffers_in == (char*)(&(send_data.get_data()) + (MAX_BUFFER_SIZE / 3)));
10244 BOOST_CHECK((char*)socket.write_some_buffers_in == (send_data.get_data().data() + (MAX_BUFFER_SIZE / 3)));
10245 test_obj.up_thread_realserver_send_call_check = false;
10246 test_obj.next_up_function_call();
10247 BOOST_CHECK(test_obj.up_thread_realserver_send_call_check);
10249 socket.write_some_res = MAX_BUFFER_SIZE - send_data.get_send_size();
10250 test_obj.set_up_thread_next_function_call_exit();
10251 socket.write_some_buffers_in = NULL;
10252 test_obj.test_call_realserver_send();
10253 // BOOST_CHECK((char*)socket.write_some_buffers_in == (char*)(&(send_data.get_data()) + (MAX_BUFFER_SIZE / 3) * 2));
10254 BOOST_CHECK((char*)socket.write_some_buffers_in == (send_data.get_data().data() + (MAX_BUFFER_SIZE / 3) * 2));
10255 test_obj.up_thread_client_receive_call_check = false;
10256 test_obj.next_up_function_call();
10257 BOOST_CHECK(test_obj.up_thread_client_receive_call_check);
10259 socket.write_some_res = MAX_BUFFER_SIZE;
10261 // unit_test [6] up_thread_realserver_send socket error (try_again) check
10262 std::cout << "[6] up_thread_realserver_send socket error (try_again) check" << std::endl;
10263 send_data.set_send_size(0);
10264 test_obj.set_up_thread_next_function_call_exit();
10265 socket.write_some_ec = boost::asio::error::try_again;
10266 test_obj.test_call_realserver_send();
10267 test_obj.up_thread_realserver_send_call_check = false;
10268 test_obj.next_up_function_call();
10269 BOOST_CHECK(test_obj.up_thread_realserver_send_call_check);
10270 socket.read_some_ec.clear();
10272 // unit_test [7] up_thread_realserver_send socket error (eof) check
10273 std::cout << "[7] up_thread_realserver_send socket error (eof) check" << std::endl;
10274 send_data.set_send_size(0);
10275 test_obj.set_up_thread_next_function_call_exit();
10276 socket.write_some_ec = boost::asio::error::eof;
10277 test_obj.test_call_realserver_send();
10278 test_obj.up_thread_realserver_disconnect_call_check = false;
10279 test_obj.next_up_function_call();
10280 BOOST_CHECK(test_obj.up_thread_realserver_disconnect_call_check);
10281 socket.read_some_ec.clear();
10283 // unit_test [8] up_thread_realserver_send socket error (connection_reset) check
10284 std::cout << "[8] up_thread_realserver_send socket error (connection_reset) check" << std::endl;
10285 send_data.set_send_size(0);
10286 test_obj.set_up_thread_next_function_call_exit();
10287 socket.write_some_ec = boost::asio::error::connection_reset;
10288 test_obj.test_call_realserver_send();
10289 test_obj.up_thread_realserver_disconnect_call_check = false;
10290 test_obj.next_up_function_call();
10291 BOOST_CHECK(test_obj.up_thread_realserver_disconnect_call_check);
10292 socket.read_some_ec.clear();
10294 // unit_test [9] up_thread_realserver_send socket error (bad_descriptor) check
10295 std::cout << "[9] up_thread_realserver_send socket error (bad_descriptor) check" << std::endl;
10296 send_data.set_send_size(0);
10297 test_obj.set_up_thread_next_function_call_exit();
10298 socket.write_some_ec = boost::asio::error::bad_descriptor;
10299 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
10300 l7vs::Logger::putLogError_id = 0;
10301 test_obj.test_call_realserver_send();
10302 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_NONE,l7vs::Logger::putLogError_category);
10303 BOOST_CHECK_EQUAL(0,l7vs::Logger::putLogError_id);
10304 test_obj.up_thread_realserver_disconnect_call_check = false;
10305 test_obj.next_up_function_call();
10306 BOOST_CHECK(test_obj.up_thread_realserver_disconnect_call_check);
10307 socket.read_some_ec.clear();
10309 // unit_test [10] up_thread_realserver_send not fond function error check
10310 std::cout << "[10] up_thread_realserver_send not fond function error check" << std::endl;
10311 send_data.set_send_size(0);
10312 test_obj.up_thread_function_array_clear();
10313 test_obj.up_thread_exit_call_check = false;
10314 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
10315 l7vs::Logger::putLogError_id = 0;
10316 test_obj.test_call_realserver_send();
10317 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
10318 BOOST_CHECK_EQUAL(31,l7vs::Logger::putLogError_id);
10319 std::cout << l7vs::Logger::putLogError_message << std::endl;
10320 BOOST_CHECK(test_obj.up_thread_exit_call_check);
10322 // unit_test [11] up_thread_realserver_send returnd illegal EVENT_TAG error check
10323 std::cout << "[11] up_thread_realserver_send returnd illegal EVENT_TAG error check" << std::endl;
10324 send_data.set_send_size(0);
10325 send_data.set_size(MAX_BUFFER_SIZE);
10326 socket.write_some_ec.clear();
10327 test_obj.up_thread_module_event_map_clear();
10328 test_obj.up_thread_exit_call_check = false;
10329 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
10330 l7vs::Logger::putLogError_id = 0;
10331 test_obj.test_call_realserver_send();
10332 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
10333 BOOST_CHECK_EQUAL(30,l7vs::Logger::putLogError_id);
10334 std::cout << l7vs::Logger::putLogError_message << std::endl;
10335 BOOST_CHECK(test_obj.up_thread_exit_call_check);
10337 BOOST_MESSAGE( "----- up_thread_realserver_send test end -----" );
10340 // up_thread_sorryserver_send test
10341 void up_thread_sorryserver_send_test(){
10342 BOOST_MESSAGE( "----- up_thread_sorryserver_send test end -----" );
10343 // boost::asio::io_service io;
10344 // l7vs::virtualservice_tcp vs;
10345 l7vs::virtualservice_tcp vs;
10346 boost::asio::io_service io;
10347 l7vs::tcp_socket_option_info set_option;
10348 //! TCP_NODELAY (false:not set,true:set option)
10349 set_option.nodelay_opt = false;
10350 //! TCP_NODELAY option value (false:off,true:on)
10351 set_option.nodelay_val = false;
10352 //! TCP_CORK (false:not set,true:set option)
10353 set_option.cork_opt = false;
10354 //! TCP_CORK option value (false:off,true:on)
10355 set_option.cork_val = false;
10356 //! TCP_QUICKACK (false:not set,true:set option)
10357 set_option.quickack_opt = false;
10358 //! TCP_QUICKACK option value (false:off,true:on)
10359 set_option.quickack_val = false;
10361 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
10362 bool set_mode(false);
10363 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
10364 bool set_ssl_cache_flag(false);
10365 int set_ssl_handshake_time_out = 0;
10366 //std::string access_log_file_name = "test";
10367 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
10369 std::string test_protocol_name("test protocol");
10370 l7vs::test_protocol_module proto_test(test_protocol_name);
10371 // up_thread_sorryserver_send
10372 // receive_send_test_class test_obj(vs,io);
10373 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);
10375 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
10376 boost::thread::id proc_id = boost::this_thread::get_id();
10378 l7vs::tcp_data& send_data = test_obj.get_up_thread_data_dest_side();
10380 // set sorryserver socket
10381 std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > >& sorry_pair = test_obj.get_sorryserver_socket();
10382 sorry_pair.first = boost::asio::ip::tcp::endpoint();
10385 send_data.initialize();
10386 send_data.set_size(MAX_BUFFER_SIZE);
10387 boost::asio::ip::tcp::endpoint send_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP),7000);
10388 send_data.set_endpoint(send_end);
10389 test_obj.set_up_thread_id(proc_id);
10390 test_obj.set_down_thread_id(boost::thread::id());
10391 test_obj.up_thread_client_receive_call_check = false;
10392 test_obj.up_thread_sorryserver_disconnect_call_check = false;
10393 test_obj.up_thread_exit_call_check = false;
10394 test_obj.up_thread_sorryserver_get_destination_event_call_check = false;
10396 vs.update_up_send_size_in = 0;
10397 // protocol module set
10398 proto_test.handle_sorryserver_send_res_tag = l7vs::protocol_module_base::CLIENT_RECV;
10399 proto_test.handle_sorryserver_send_in_thread_id = boost::thread::id();
10401 l7vs::tcp_socket& socket = *(sorry_pair.second);
10402 socket.write_some_res = MAX_BUFFER_SIZE;
10403 socket.write_some_ec.clear();
10404 socket.write_some_buffers_in = NULL;
10405 socket.write_some_buffers_size_in = 0;
10406 socket.write_some_call_check = false;
10408 l7vs::Logger::test_loglevel = l7vs::LOG_LV_DEBUG;
10409 l7vs::Logger::putLogDebug_category = l7vs::LOG_CAT_NONE;
10410 l7vs::Logger::putLogDebug_id = 0;
10412 test_obj.test_call_sorryserver_send();
10414 // unit_test [1] up_thread_sorryserver_send realserver_socket write_some call check
10415 std::cout << "[1] up_thread_sorryserver_send realserver_socket write_some call check" << std::endl;
10416 BOOST_CHECK(socket.write_some_call_check);
10417 BOOST_CHECK(socket.write_some_buffers_in == (void*)&(send_data.get_data()));
10418 BOOST_CHECK(socket.write_some_buffers_size_in == MAX_BUFFER_SIZE);
10419 BOOST_CHECK(socket.write_some_res == send_data.get_send_size());
10421 // unit_test [2] up_thread_sorryserver_send protocol module handle_realserver_send call check
10422 std::cout << "[2] up_thread_sorryserver_send protocol module handle_realserver_send call check" << std::endl;
10423 BOOST_CHECK(proto_test.handle_sorryserver_send_in_thread_id == proc_id);
10425 // unit_test [3] up_thread_sorryserver_send up_thread_next_call_function update check
10426 std::cout << "[3] up_thread_sorryserver_send up_thread_next_call_function update check" << std::endl;
10427 test_obj.next_up_function_call();
10428 BOOST_CHECK(test_obj.up_thread_client_receive_call_check);
10430 // unit_test [4] up_thread_sorryserver_send send size check
10431 std::cout << "[4] up_thread_sorryserver_send send size check" << std::endl;
10432 send_data.set_send_size(0);
10433 socket.write_some_res = 0;
10434 test_obj.set_up_thread_next_function_call_exit();
10435 socket.write_some_buffers_in = NULL;
10436 test_obj.test_call_sorryserver_send();
10437 // BOOST_CHECK((char*)socket.write_some_buffers_in == (char*)&(send_data.get_data()) + 0);
10438 BOOST_CHECK((char*)socket.write_some_buffers_in == (send_data.get_data().data() + 0));
10439 test_obj.up_thread_sorryserver_send_call_check = false;
10440 test_obj.next_up_function_call();
10441 BOOST_CHECK(test_obj.up_thread_sorryserver_send_call_check);
10443 socket.write_some_res = MAX_BUFFER_SIZE / 3;
10444 test_obj.set_up_thread_next_function_call_exit();
10445 socket.write_some_buffers_in = NULL;
10446 test_obj.test_call_sorryserver_send();
10447 // BOOST_CHECK((char*)socket.write_some_buffers_in == (char*)&(send_data.get_data()) + 0);
10448 BOOST_CHECK((char*)socket.write_some_buffers_in == (send_data.get_data().data() + 0));
10449 test_obj.up_thread_sorryserver_send_call_check = false;
10450 test_obj.next_up_function_call();
10451 BOOST_CHECK(test_obj.up_thread_sorryserver_send_call_check);
10453 socket.write_some_res = MAX_BUFFER_SIZE / 3;
10454 test_obj.set_up_thread_next_function_call_exit();
10455 socket.write_some_buffers_in = NULL;
10456 test_obj.test_call_sorryserver_send();
10457 // BOOST_CHECK((char*)socket.write_some_buffers_in == (char*)(&(send_data.get_data()) + (MAX_BUFFER_SIZE / 3)));
10458 BOOST_CHECK((char*)socket.write_some_buffers_in == (send_data.get_data().data() + (MAX_BUFFER_SIZE / 3)));
10459 test_obj.up_thread_sorryserver_send_call_check = false;
10460 test_obj.next_up_function_call();
10461 BOOST_CHECK(test_obj.up_thread_sorryserver_send_call_check);
10463 socket.write_some_res = MAX_BUFFER_SIZE - send_data.get_send_size();
10464 test_obj.set_up_thread_next_function_call_exit();
10465 socket.write_some_buffers_in = NULL;
10466 test_obj.test_call_sorryserver_send();
10467 // BOOST_CHECK((char*)socket.write_some_buffers_in == (char*)(&(send_data.get_data()) + (MAX_BUFFER_SIZE / 3) * 2));
10468 BOOST_CHECK((char*)socket.write_some_buffers_in == (send_data.get_data().data() + (MAX_BUFFER_SIZE / 3) * 2));
10469 test_obj.up_thread_client_receive_call_check = false;
10470 test_obj.next_up_function_call();
10471 BOOST_CHECK(test_obj.up_thread_client_receive_call_check);
10473 socket.write_some_res = MAX_BUFFER_SIZE;
10475 // unit_test [5] up_thread_sorryserver_send socket error (try_again) check
10476 std::cout << "[5] up_thread_sorryserver_send socket error (try_again) check" << std::endl;
10477 send_data.set_send_size(0);
10478 test_obj.set_up_thread_next_function_call_exit();
10479 socket.write_some_ec = boost::asio::error::try_again;
10480 test_obj.test_call_sorryserver_send();
10481 test_obj.up_thread_sorryserver_send_call_check = false;
10482 test_obj.next_up_function_call();
10483 BOOST_CHECK(test_obj.up_thread_sorryserver_send_call_check);
10484 socket.read_some_ec.clear();
10486 // unit_test [6] up_thread_sorryserver_send socket error (eof) check
10487 std::cout << "[6] up_thread_sorryserver_send socket error (eof) check" << std::endl;
10488 send_data.set_send_size(0);
10489 test_obj.set_up_thread_next_function_call_exit();
10490 socket.write_some_ec = boost::asio::error::eof;
10491 test_obj.test_call_sorryserver_send();
10492 test_obj.up_thread_sorryserver_disconnect_call_check = false;
10493 test_obj.next_up_function_call();
10494 BOOST_CHECK(test_obj.up_thread_sorryserver_disconnect_call_check);
10495 socket.read_some_ec.clear();
10497 // unit_test [7] up_thread_sorryserver_send socket error (connection_reset) check
10498 std::cout << "[7] up_thread_sorryserver_send socket error (connection_reset) check" << std::endl;
10499 send_data.set_send_size(0);
10500 test_obj.set_up_thread_next_function_call_exit();
10501 socket.write_some_ec = boost::asio::error::connection_reset;
10502 test_obj.test_call_sorryserver_send();
10503 test_obj.up_thread_sorryserver_disconnect_call_check = false;
10504 test_obj.next_up_function_call();
10505 BOOST_CHECK(test_obj.up_thread_sorryserver_disconnect_call_check);
10506 socket.read_some_ec.clear();
10508 // unit_test [8] up_thread_sorryserver_send socket error (bad_descriptor) check
10509 std::cout << "[8] up_thread_sorryserver_send socket error (bad_descriptor) check" << std::endl;
10510 send_data.set_send_size(0);
10511 test_obj.set_up_thread_next_function_call_exit();
10512 socket.write_some_ec = boost::asio::error::bad_descriptor;
10513 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
10514 l7vs::Logger::putLogError_id = 0;
10515 test_obj.test_call_sorryserver_send();
10516 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_NONE,l7vs::Logger::putLogError_category);
10517 BOOST_CHECK_EQUAL(0,l7vs::Logger::putLogError_id);
10518 std::cout << l7vs::Logger::putLogError_message << std::endl;
10519 test_obj.up_thread_sorryserver_disconnect_call_check = false;
10520 test_obj.next_up_function_call();
10521 BOOST_CHECK(test_obj.up_thread_sorryserver_disconnect_call_check);
10522 socket.write_some_ec.clear();
10524 // unit_test [9] up_thread_sorryserver_send not fond function error check
10525 std::cout << "[9] up_thread_sorryserver_send not fond function error check" << std::endl;
10526 send_data.set_send_size(0);
10527 test_obj.up_thread_function_array_clear();
10528 test_obj.up_thread_exit_call_check = false;
10529 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
10530 l7vs::Logger::putLogError_id = 0;
10531 test_obj.test_call_sorryserver_send();
10532 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
10533 BOOST_CHECK_EQUAL(50,l7vs::Logger::putLogError_id);
10534 std::cout << l7vs::Logger::putLogError_message << std::endl;
10535 BOOST_CHECK(test_obj.up_thread_exit_call_check);
10537 // unit_test [10] up_thread_sorryserver_send returnd illegal EVENT_TAG error check
10538 std::cout << "[10] up_thread_sorryserver_send returnd illegal EVENT_TAG error check" << std::endl;
10539 send_data.set_size(MAX_BUFFER_SIZE);
10540 send_data.set_send_size(0);
10541 test_obj.up_thread_module_event_map_clear();
10542 test_obj.up_thread_exit_call_check = false;
10543 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
10544 l7vs::Logger::putLogError_id = 0;
10545 test_obj.test_call_sorryserver_send();
10546 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
10547 BOOST_CHECK_EQUAL(49,l7vs::Logger::putLogError_id);
10548 std::cout << l7vs::Logger::putLogError_message << std::endl;
10549 BOOST_CHECK(test_obj.up_thread_exit_call_check);
10551 BOOST_MESSAGE( "----- up_thread_sorryserver_send test end -----" );
10554 // down_thread_client_send test
10555 void down_thread_client_send_test(){
10556 BOOST_MESSAGE( "----- down_thread_client_send test end -----" );
10557 // boost::asio::io_service io;
10558 // l7vs::virtualservice_tcp vs;
10559 l7vs::virtualservice_tcp vs;
10560 boost::asio::io_service io;
10561 l7vs::tcp_socket_option_info set_option;
10562 //! TCP_NODELAY (false:not set,true:set option)
10563 set_option.nodelay_opt = false;
10564 //! TCP_NODELAY option value (false:off,true:on)
10565 set_option.nodelay_val = false;
10566 //! TCP_CORK (false:not set,true:set option)
10567 set_option.cork_opt = false;
10568 //! TCP_CORK option value (false:off,true:on)
10569 set_option.cork_val = false;
10570 //! TCP_QUICKACK (false:not set,true:set option)
10571 set_option.quickack_opt = false;
10572 //! TCP_QUICKACK option value (false:off,true:on)
10573 set_option.quickack_val = false;
10575 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
10576 bool set_mode(false);
10577 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
10578 bool set_ssl_cache_flag(false);
10579 int set_ssl_handshake_time_out = 0;
10580 //std::string access_log_file_name = "test";
10581 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
10583 std::string test_protocol_name("test protocol");
10584 l7vs::test_protocol_module proto_test(test_protocol_name);
10585 // up_thread_sorryserver_send
10586 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);
10588 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
10589 boost::thread::id proc_id = boost::this_thread::get_id();
10591 l7vs::tcp_data& send_data = test_obj.get_down_thread_data_client_side();
10593 // get client socket
10594 l7vs::tcp_socket& socket = test_obj.get_client_socket();
10596 // dummy server client socket connect
10597 boost::system::error_code ec;
10598 test_mirror_server test_server;
10600 test_server.breq_acc_flag = true;
10602 test_server.breq_close_wait_flag = true;
10604 test_server.req_recv_cnt = 0;
10605 // test server start
10606 boost::thread server_thread(boost::bind(&test_mirror_server::run,&test_server));
10607 while( !test_server.brun_flag ){
10611 boost::asio::ip::tcp::endpoint connect_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
10612 socket.get_socket().connect(connect_end,ec);
10614 socket.is_open_res = true;
10616 while(!test_server.bconnect_flag){
10619 boost::asio::ip::tcp::endpoint local_endpoint = socket.get_socket().local_endpoint(ec);
10623 send_data.initialize();
10624 send_data.set_size(MAX_BUFFER_SIZE);
10625 test_obj.set_up_thread_id(boost::thread::id());
10626 test_obj.set_down_thread_id(proc_id);
10627 test_obj.down_thread_realserver_receive_call_check = false;
10628 test_obj.down_thread_client_disconnect_call_check = false;
10629 test_obj.down_thread_exit_call_check = false;
10630 test_obj.down_thread_client_connection_chk_event_call_check = false;
10633 vs.update_down_send_size_in = 0;
10634 // protocol module set
10635 proto_test.handle_client_send_res_tag = l7vs::protocol_module_base::REALSERVER_RECV;
10636 proto_test.handle_client_send_in_thread_id = boost::thread::id();
10638 socket.write_some_res = MAX_BUFFER_SIZE;
10639 socket.write_some_ec.clear();
10640 socket.write_some_buffers_in = NULL;
10641 socket.write_some_buffers_size_in = 0;
10642 socket.write_some_call_check = false;
10644 l7vs::Logger::test_loglevel = l7vs::LOG_LV_DEBUG;
10645 l7vs::Logger::putLogDebug_category = l7vs::LOG_CAT_NONE;
10646 l7vs::Logger::putLogDebug_id = 0;
10648 test_obj.test_call_client_send();
10650 // unit_test [1] down_thread_client_send socket write_some call check
10651 std::cout << "[1] down_thread_client_send socket write_some call check" << std::endl;
10652 BOOST_CHECK(socket.write_some_call_check);
10653 BOOST_CHECK(socket.write_some_buffers_in == (void*)&(send_data.get_data()));
10654 BOOST_CHECK(socket.write_some_buffers_size_in == MAX_BUFFER_SIZE);
10655 BOOST_CHECK(socket.write_some_res == send_data.get_send_size());
10657 // unit_test [2] down_thread_client_send protocol module handle_client_send call check
10658 std::cout << "[2] down_thread_client_send protocol module handle_client_send call check" << std::endl;
10659 BOOST_CHECK(proto_test.handle_client_send_in_thread_id == proc_id);
10661 // unit_test [3] down_thread_client_send up_thread_next_call_function update check
10662 std::cout << "[3] down_thread_client_send up_thread_next_call_function update check" << std::endl;
10663 test_obj.next_down_function_call();
10664 BOOST_CHECK(test_obj.down_thread_realserver_receive_call_check);
10666 // unit_test [4] down_thread_client_send send size check
10667 std::cout << "[4] down_thread_client_send send size check" << std::endl;
10668 send_data.set_send_size(0);
10669 socket.write_some_res = 0;
10670 test_obj.set_down_thread_next_function_call_exit();
10671 socket.write_some_buffers_in = NULL;
10672 test_obj.test_call_client_send();
10673 // BOOST_CHECK((char*)socket.write_some_buffers_in == (char*)&(send_data.get_data()) + 0);
10674 BOOST_CHECK((char*)socket.write_some_buffers_in == (send_data.get_data().data() + 0));
10675 test_obj.down_thread_client_send_call_check = false;
10676 test_obj.next_down_function_call();
10677 BOOST_CHECK(test_obj.down_thread_client_send_call_check);
10679 socket.write_some_res = MAX_BUFFER_SIZE / 3;
10680 test_obj.set_down_thread_next_function_call_exit();
10681 socket.write_some_buffers_in = NULL;
10682 test_obj.test_call_client_send();
10683 // BOOST_CHECK((char*)socket.write_some_buffers_in == (char*)&(send_data.get_data()) + 0);
10684 BOOST_CHECK((char*)socket.write_some_buffers_in == (send_data.get_data().data() + 0));
10685 test_obj.down_thread_client_send_call_check = false;
10686 test_obj.next_down_function_call();
10687 BOOST_CHECK(test_obj.down_thread_client_send_call_check);
10689 socket.write_some_res = MAX_BUFFER_SIZE / 3;
10690 test_obj.set_down_thread_next_function_call_exit();
10691 socket.write_some_buffers_in = NULL;
10692 test_obj.test_call_client_send();
10693 // BOOST_CHECK((char*)socket.write_some_buffers_in == (char*)(&(send_data.get_data()) + (MAX_BUFFER_SIZE / 3)));
10694 BOOST_CHECK((char*)socket.write_some_buffers_in == (send_data.get_data().data() + (MAX_BUFFER_SIZE / 3)));
10695 test_obj.down_thread_client_send_call_check = false;
10696 test_obj.next_down_function_call();
10697 BOOST_CHECK(test_obj.down_thread_client_send_call_check);
10699 socket.write_some_res = MAX_BUFFER_SIZE - send_data.get_send_size();
10700 test_obj.set_down_thread_next_function_call_exit();
10701 socket.write_some_buffers_in = NULL;
10702 test_obj.test_call_client_send();
10703 // BOOST_CHECK((char*)socket.write_some_buffers_in == (char*)(&(send_data.get_data()) + (MAX_BUFFER_SIZE / 3) * 2));
10704 BOOST_CHECK((char*)socket.write_some_buffers_in == (send_data.get_data().data() + (MAX_BUFFER_SIZE / 3) * 2));
10705 test_obj.down_thread_realserver_receive_call_check = false;
10706 test_obj.next_down_function_call();
10707 BOOST_CHECK(test_obj.down_thread_realserver_receive_call_check);
10709 socket.write_some_res = MAX_BUFFER_SIZE;
10711 // unit_test [5] down_thread_client_send socket error (try_again) check
10712 std::cout << "[5] down_thread_client_send socket error (try_again) check" << std::endl;
10713 send_data.set_send_size(0);
10714 test_obj.set_down_thread_next_function_call_exit();
10715 socket.write_some_ec = boost::asio::error::try_again;
10716 test_obj.test_call_client_send();
10717 test_obj.down_thread_client_send_call_check = false;
10718 test_obj.next_down_function_call();
10719 BOOST_CHECK(test_obj.down_thread_client_send_call_check);
10720 socket.read_some_ec.clear();
10722 // unit_test [6] down_thread_client_send socket error (eof) check
10723 std::cout << "[6] down_thread_client_send socket error (eof) check" << std::endl;
10724 send_data.set_send_size(0);
10725 test_obj.set_down_thread_next_function_call_exit();
10726 socket.write_some_ec = boost::asio::error::eof;
10727 test_obj.test_call_client_send();
10728 test_obj.down_thread_client_disconnect_call_check = false;
10729 test_obj.next_down_function_call();
10730 BOOST_CHECK(test_obj.down_thread_client_disconnect_call_check);
10731 socket.read_some_ec.clear();
10733 // unit_test [7] down_thread_client_send socket error (connection_reset) check
10734 std::cout << "[7] down_thread_client_send socket error (connection_reset) check" << std::endl;
10735 send_data.set_send_size(0);
10736 test_obj.set_down_thread_next_function_call_exit();
10737 socket.write_some_ec = boost::asio::error::connection_reset;
10738 test_obj.test_call_client_send();
10739 test_obj.down_thread_client_disconnect_call_check = false;
10740 test_obj.next_down_function_call();
10741 BOOST_CHECK(test_obj.down_thread_client_disconnect_call_check);
10742 socket.read_some_ec.clear();
10744 // unit_test [8] down_thread_client_send socket error (bad_descriptor) check
10745 std::cout << "[8] down_thread_client_send socket error (bad_descriptor) check" << std::endl;
10746 send_data.set_send_size(0);
10747 test_obj.set_down_thread_next_function_call_exit();
10748 socket.write_some_ec = boost::asio::error::bad_descriptor;
10749 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
10750 l7vs::Logger::putLogError_id = 0;
10751 test_obj.test_call_client_send();
10752 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_NONE,l7vs::Logger::putLogError_category);
10753 BOOST_CHECK_EQUAL(0,l7vs::Logger::putLogError_id);
10754 std::cout << l7vs::Logger::putLogError_message << std::endl;
10755 test_obj.down_thread_client_disconnect_call_check = false;
10756 test_obj.next_down_function_call();
10757 BOOST_CHECK(test_obj.down_thread_client_disconnect_call_check);
10758 socket.write_some_ec.clear();
10760 // unit_test [9] down_thread_client_send not fond function error check
10761 std::cout << "[9] down_thread_client_send not fond function error check" << std::endl;
10762 send_data.set_send_size(0);
10763 test_obj.down_thread_function_array_clear();
10764 test_obj.down_thread_exit_call_check = false;
10765 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
10766 l7vs::Logger::putLogError_id = 0;
10767 test_obj.test_call_client_send();
10768 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
10769 BOOST_CHECK_EQUAL(83,l7vs::Logger::putLogError_id);
10770 std::cout << l7vs::Logger::putLogError_message << std::endl;
10771 BOOST_CHECK(test_obj.down_thread_exit_call_check);
10773 // unit_test [10] down_thread_client_send returnd illegal EVENT_TAG error check
10774 std::cout << "[10] down_thread_client_send returnd illegal EVENT_TAG error check" << std::endl;
10775 send_data.set_send_size(0);
10776 test_obj.down_thread_module_event_map_clear();
10777 test_obj.down_thread_exit_call_check = false;
10778 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
10779 l7vs::Logger::putLogError_id = 0;
10780 test_obj.test_call_client_send();
10781 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
10782 BOOST_CHECK_EQUAL(82,l7vs::Logger::putLogError_id);
10783 std::cout << l7vs::Logger::putLogError_message << std::endl;
10784 BOOST_CHECK(test_obj.down_thread_exit_call_check);
10786 // dummy server stop
10787 test_server.breq_close_wait_flag = false;
10788 test_server.bstop_flag = true;
10789 server_thread.join();
10793 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);
10795 ssl_test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
10797 l7vs::tcp_data& ssl_send_data = ssl_test_obj.get_down_thread_data_client_side();
10799 // get client socket
10800 l7vs::tcp_ssl_socket& ssl_socket = ssl_test_obj.get_client_ssl_socket();
10803 ssl_send_data.initialize();
10804 ssl_send_data.set_size(MAX_BUFFER_SIZE);
10805 ssl_test_obj.set_up_thread_id(boost::thread::id());
10806 ssl_test_obj.set_down_thread_id(proc_id);
10807 ssl_test_obj.down_thread_realserver_receive_call_check = false;
10808 ssl_test_obj.down_thread_client_disconnect_call_check = false;
10809 ssl_test_obj.down_thread_exit_call_check = false;
10810 ssl_test_obj.down_thread_client_connection_chk_event_call_check = false;
10813 vs.update_down_send_size_in = 0;
10814 // protocol module set
10815 proto_test.handle_client_send_res_tag = l7vs::protocol_module_base::REALSERVER_RECV;
10816 proto_test.handle_client_send_in_thread_id = boost::thread::id();
10818 ssl_socket.write_some_res = MAX_BUFFER_SIZE;
10819 ssl_socket.write_some_ec.clear();
10820 ssl_socket.write_some_buffers_in = NULL;
10821 ssl_socket.write_some_buffers_size_in = 0;
10822 ssl_socket.write_some_call_check = false;
10824 ssl_test_obj.test_call_client_send();
10826 // unit_test [11] down_thread_client_send ssl mode socket write_some call check
10827 std::cout << "[11] down_thread_client_send ssl mode socket write_some call check" << std::endl;
10828 BOOST_CHECK(ssl_socket.write_some_call_check);
10829 BOOST_CHECK(ssl_socket.write_some_buffers_in == (void*)&(ssl_send_data.get_data()));
10830 BOOST_CHECK(ssl_socket.write_some_buffers_size_in == MAX_BUFFER_SIZE);
10831 BOOST_CHECK(ssl_socket.write_some_res == ssl_send_data.get_send_size());
10834 BOOST_MESSAGE( "----- down_thread_client_send test end -----" );
10838 //up_thread_realserver_connect test
10839 //up_thread_realserver_connect test class
10840 class up_thread_realserver_connect_test_class : public l7vs::tcp_session{
10842 // up_thread_realserver_connect_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io,const l7vs::tcp_socket::tcp_socket_option_info set_option) : l7vs::tcp_session(vs,session_io,set_option){
10844 up_thread_realserver_connect_test_class(
10845 l7vs::virtualservice_tcp& vs,
10846 boost::asio::io_service& session_io,
10847 l7vs::tcp_socket_option_info& set_socket_option,
10848 boost::asio::ip::tcp::endpoint listen_endpoint,
10850 boost::asio::ssl::context& set_ssl_context,
10851 bool set_ssl_cache_flag,
10852 int set_ssl_handshake_time_out,
10853 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
10859 set_ssl_cache_flag,
10860 set_ssl_handshake_time_out,
10861 set_access_logger){};
10863 ~up_thread_realserver_connect_test_class(){};
10866 l7vs::tcp_session::up_thread_realserver_connect(LOCAL_PROC);
10869 void set_protocol_module(l7vs::protocol_module_base* set_prot){
10870 protocol_module = set_prot;
10872 l7vs::tcp_data& get_up_thread_data_client_side(){
10873 return up_thread_data_client_side;
10875 l7vs::tcp_data& get_up_thread_data_dest_side(){
10876 return up_thread_data_dest_side;
10878 l7vs::tcp_data& get_down_thread_data_client_side(){
10879 return down_thread_data_client_side;
10881 l7vs::tcp_data& get_down_thread_data_dest_side(){
10882 return down_thread_data_dest_side;
10884 l7vs::tcp_socket& get_client_socket(){
10885 return client_socket;
10887 socket_element& get_sorryserver_socket(){
10888 return sorryserver_socket;
10890 std::list<socket_element>& get_down_thread_receive_realserver_socket_list(){
10891 return down_thread_receive_realserver_socket_list;
10893 std::map<endpoint,tcp_socket_ptr>& get_up_thread_send_realserver_socket_map(){
10894 return up_thread_send_realserver_socket_map;
10896 std::list<socket_element>::iterator& get_down_thread_current_receive_realserver_socket(){
10897 return down_thread_current_receive_realserver_socket;
10899 l7vs::tcp_realserver_connect_socket_list& get_down_thread_connect_socket_list(){
10900 return down_thread_connect_socket_list;
10904 void set_up_thread_id(boost::thread::id set_id){
10905 up_thread_id = set_id;
10907 void set_down_thread_id(boost::thread::id set_id){
10908 down_thread_id = set_id;
10911 void next_up_function_call(){
10912 up_thread_next_call_function.second(LOCAL_PROC);
10914 void next_down_function_call(){
10915 down_thread_next_call_function.second(LOCAL_PROC);
10918 void set_up_thread_next_function_call_exit(){
10919 up_thread_function_pair fun_it = up_thread_function_array[UP_FUNC_EXIT];
10920 up_thread_next_call_function = fun_it;
10923 void set_down_thread_next_function_call_exit(){
10924 down_thread_function_pair fun_it = down_thread_function_array[DOWN_FUNC_EXIT];
10925 down_thread_next_call_function = fun_it;
10928 // next call function check
10929 void up_thread_realserver_connect_event(const TCP_PROCESS_TYPE_TAG process_type){
10930 up_thread_realserver_connect_event_call_check = true;
10932 bool up_thread_realserver_connect_event_call_check;
10933 void up_thread_realserver_connection_fail_event(const TCP_PROCESS_TYPE_TAG process_type){
10934 up_thread_realserver_connection_fail_event_check = true;
10936 bool up_thread_realserver_connection_fail_event_check;
10938 void up_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
10939 up_thread_exit_call_check = true;
10941 bool up_thread_exit_call_check;
10943 void down_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
10944 down_thread_exit_call_check = true;
10946 bool down_thread_exit_call_check;
10949 void up_thread_function_array_clear(){
10950 for(int i = 0;i <= UP_FUNC_EXIT;i++){
10951 up_thread_function_array[i].second = NULL;
10954 void down_thread_function_array_clear(){
10955 for(int i = 0;i <= DOWN_FUNC_EXIT;i++){
10956 down_thread_function_array[i].second = NULL;
10960 void up_thread_module_event_map_clear(){
10961 up_thread_module_event_map.clear();
10964 void down_thread_module_event_map_clear(){
10965 down_thread_module_event_map.clear();
10969 void up_thread_realserver_connect_test(){
10970 BOOST_MESSAGE( "----- up_thread_realserver_connect test start -----" );
10972 boost::asio::io_service io;
10973 l7vs::virtualservice_tcp vs;
10976 std::string test_protocol_name("test protocol");
10977 l7vs::test_protocol_module proto_test(test_protocol_name);
10979 l7vs::tcp_socket_option_info set_option;
10980 //! TCP_NODELAY (false:not set,true:set option)
10981 set_option.nodelay_opt = true;
10982 //! TCP_NODELAY option value (false:off,true:on)
10983 set_option.nodelay_val = true;
10984 //! TCP_CORK (false:not set,true:set option)
10985 set_option.cork_opt = true;
10986 //! TCP_CORK option value (false:off,true:on)
10987 set_option.cork_val = true;
10988 //! TCP_QUICKACK (false:not set,true:set option)
10989 set_option.quickack_opt = true;
10990 //! TCP_QUICKACK option value (false:off,true:on)
10991 set_option.quickack_val = true;
10993 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
10994 bool set_mode(false);
10995 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
10996 bool set_ssl_cache_flag(false);
10997 int set_ssl_handshake_time_out = 0;
10998 //std::string access_log_file_name = "test";
10999 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
11001 // up_thread_realserver_connect_test_class test_obj(vs,io);
11002 // up_thread_realserver_connect_test_class test_obj(vs,io,set_option);
11003 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);
11005 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
11006 boost::thread::id proc_id = boost::this_thread::get_id();
11008 l7vs::tcp_data& con_data = test_obj.get_up_thread_data_dest_side();
11009 boost::asio::ip::tcp::endpoint con_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP),DUMMI_SERVER_PORT);
11011 //up_thread_data_dest_side set
11012 con_data.initialize();
11013 con_data.set_endpoint(con_end);
11015 test_obj.set_up_thread_id(boost::thread::id());
11016 test_obj.set_down_thread_id(proc_id);
11018 l7vs::tcp_socket::connect_res = true;
11019 l7vs::tcp_socket::connect_connect_endpoint = boost::asio::ip::tcp::endpoint();
11020 l7vs::tcp_socket::connect_ec = NULL;
11021 l7vs::tcp_socket::connect_call_check = false;
11022 l7vs::tcp_socket::is_connect = true;
11024 vs.connection_active_list.clear();
11026 std::map< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > >& rs_map = test_obj.get_up_thread_send_realserver_socket_map();
11028 // connection list set
11029 l7vs::tcp_realserver_connect_socket_list& con_list = test_obj.get_down_thread_connect_socket_list();
11032 test_obj.set_up_thread_next_function_call_exit();
11033 test_obj.up_thread_realserver_connect_event_call_check = false;
11036 test_mirror_server test_server;
11038 test_server.breq_acc_flag = true;
11040 test_server.breq_close_wait_flag = true;
11042 test_server.req_recv_cnt = 0;
11043 // test server start
11044 boost::thread server_thread(boost::bind(&test_mirror_server::run,&test_server));
11045 while( !test_server.brun_flag ){
11049 test_obj.test_call();
11051 // unit_test [1] up_thread_realserver_connect socket connect call check
11052 std::cout << "[1] up_thread_realserver_connect socket connect call check" << std::endl;
11053 BOOST_CHECK(con_end == l7vs::tcp_socket::connect_connect_endpoint);
11054 BOOST_CHECK(l7vs::tcp_socket::connect_ec != NULL);
11055 BOOST_CHECK(l7vs::tcp_socket::connect_call_check);
11057 // unit_test [2] up_thread_realserver_connect virtualservice connection_active call check
11058 std::cout << "[2] up_thread_realserver_connect virtualservice connection_active call check" << std::endl;
11059 BOOST_CHECK(!vs.connection_active_list.empty());
11060 BOOST_CHECK(*(vs.connection_active_list.begin()) == con_end);
11062 // unit_test [3] up_thread_realserver_connect up_thread_send_realserver_socket_map insert check
11063 std::cout << "[3] up_thread_realserver_connect up_thread_send_realserver_socket_map insert check" << std::endl;
11064 BOOST_CHECK(!rs_map.empty());
11065 BOOST_CHECK(rs_map.begin()->first == con_end);
11066 BOOST_CHECK(rs_map.begin()->second != NULL);
11067 std::cout << l7vs::Logger::putLogError_message << std::endl;
11069 // unit_test [4] up_thread_realserver_connect down_thread_connect_socket_list push check
11070 std::cout << "[4] up_thread_realserver_connect down_thread_connect_socket_list push check" << std::endl;
11071 BOOST_CHECK(!con_list.empty());
11072 std::pair<boost::asio::ip::tcp::endpoint,boost::shared_ptr<l7vs::tcp_socket> > set_socket = con_list.get_socket();
11073 BOOST_CHECK(set_socket.first == con_end);
11074 BOOST_CHECK(set_socket.second == rs_map.begin()->second);
11077 // unit_test [5] constructer realserver socket set socket option check
11078 std::cout << "[5] constructer realserver socket set socket option check" << std::endl;
11080 BOOST_CHECK_EQUAL(rs_map.begin()->second->opt_info.nodelay_opt , set_option.nodelay_opt);
11081 BOOST_CHECK_EQUAL(rs_map.begin()->second->opt_info.nodelay_val , set_option.nodelay_val);
11083 BOOST_CHECK_EQUAL(rs_map.begin()->second->opt_info.cork_opt , set_option.cork_opt);
11084 BOOST_CHECK_EQUAL(rs_map.begin()->second->opt_info.cork_val , set_option.cork_val);
11086 BOOST_CHECK_EQUAL(rs_map.begin()->second->opt_info.quickack_opt , set_option.quickack_opt);
11087 BOOST_CHECK_EQUAL(rs_map.begin()->second->opt_info.quickack_val , set_option.quickack_val);
11091 // unit_test [6] up_thread_realserver_connect up_thread_next_call_function update check
11092 std::cout << "[6] up_thread_realserver_connect up_thread_next_call_function update check" << std::endl;
11093 test_obj.next_up_function_call();
11094 BOOST_CHECK(test_obj.up_thread_realserver_connect_event_call_check);
11096 l7vs::tcp_socket::is_connect = false;
11098 // unit_test [7] up_thread_realserver_connect duplication check
11099 std::cout << "[7] up_thread_realserver_connect duplication check" << std::endl;
11100 l7vs::tcp_socket::connect_call_check = false;
11101 test_obj.test_call();
11102 BOOST_CHECK(!l7vs::tcp_socket::connect_call_check);
11103 test_obj.up_thread_realserver_connect_event_call_check = false;
11104 test_obj.next_up_function_call();
11105 BOOST_CHECK(test_obj.up_thread_realserver_connect_event_call_check);
11107 // unit_test [8] up_thread_realserver_connect connect fail check
11108 std::cout << "[8] up_thread_realserver_connect connect fail check" << std::endl;
11111 l7vs::tcp_socket::connect_res = false;
11112 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
11113 l7vs::Logger::putLogError_id = 0;
11114 test_obj.test_call();
11115 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
11116 BOOST_CHECK_EQUAL(37,l7vs::Logger::putLogError_id);
11117 std::cout << l7vs::Logger::putLogError_message << std::endl;
11118 BOOST_CHECK(rs_map.empty());
11119 BOOST_CHECK(con_list.empty());
11120 test_obj.up_thread_realserver_connection_fail_event_check = false;
11121 test_obj.next_up_function_call();
11122 BOOST_CHECK(test_obj.up_thread_realserver_connection_fail_event_check);
11124 l7vs::tcp_socket::connect_res = true;
11126 // unit_test [9] up_thread_realserver_connect set non blocking fail check
11127 std::cout << "[9] up_thread_realserver_connect set non blocking fail check" << std::endl;
11130 l7vs::tcp_socket::set_non_blocking_mode_res = false;
11131 l7vs::tcp_socket::set_non_blocking_mode_ec = boost::asio::error::bad_descriptor;
11132 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
11133 l7vs::Logger::putLogError_id = 0;
11134 test_obj.up_thread_exit_call_check = false;
11135 test_obj.test_call();
11136 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
11137 BOOST_CHECK_EQUAL(34,l7vs::Logger::putLogError_id);
11138 std::cout << l7vs::Logger::putLogError_message << std::endl;
11139 BOOST_CHECK(test_obj.up_thread_exit_call_check);
11140 l7vs::tcp_socket::set_non_blocking_mode_res = true;
11141 l7vs::tcp_socket::set_non_blocking_mode_ec.clear();
11143 // unit_test [10] up_thread_realserver_connect not fond function error check
11144 std::cout << "[10] up_thread_realserver_connect not fond function error check" << std::endl;
11147 test_obj.up_thread_function_array_clear();
11148 test_obj.up_thread_exit_call_check = false;
11149 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
11150 l7vs::Logger::putLogError_id = 0;
11151 test_obj.test_call();
11152 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
11153 BOOST_CHECK_EQUAL(35,l7vs::Logger::putLogError_id);
11154 std::cout << l7vs::Logger::putLogError_message << std::endl;
11155 BOOST_CHECK(test_obj.up_thread_exit_call_check);
11158 set_socket.second->get_socket().close();
11160 // dummy server stop
11161 test_server.breq_close_wait_flag = false;
11162 test_server.bstop_flag = true;
11163 server_thread.join();
11165 BOOST_MESSAGE( "----- up_thread_realserver_connect test end -----" );
11169 //up_thread_sorryserver_connect test
11170 //up_thread_sorryserver_connect test class
11171 class up_thread_sorryserver_connect_test_class : public l7vs::tcp_session{
11173 // up_thread_sorryserver_connect_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){
11175 up_thread_sorryserver_connect_test_class(
11176 l7vs::virtualservice_tcp& vs,
11177 boost::asio::io_service& session_io,
11178 l7vs::tcp_socket_option_info& set_socket_option,
11179 boost::asio::ip::tcp::endpoint listen_endpoint,
11181 boost::asio::ssl::context& set_ssl_context,
11182 bool set_ssl_cache_flag,
11183 int set_ssl_handshake_time_out,
11184 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
11190 set_ssl_cache_flag,
11191 set_ssl_handshake_time_out,
11192 set_access_logger){};
11194 ~up_thread_sorryserver_connect_test_class(){};
11197 l7vs::tcp_session::up_thread_sorryserver_connect(LOCAL_PROC);
11200 void set_protocol_module(l7vs::protocol_module_base* set_prot){
11201 protocol_module = set_prot;
11203 l7vs::tcp_data& get_up_thread_data_client_side(){
11204 return up_thread_data_client_side;
11206 l7vs::tcp_data& get_up_thread_data_dest_side(){
11207 return up_thread_data_dest_side;
11209 l7vs::tcp_data& get_down_thread_data_client_side(){
11210 return down_thread_data_client_side;
11212 l7vs::tcp_data& get_down_thread_data_dest_side(){
11213 return down_thread_data_dest_side;
11215 l7vs::tcp_socket& get_client_socket(){
11216 return client_socket;
11218 socket_element& get_sorryserver_socket(){
11219 return sorryserver_socket;
11221 std::list<socket_element>& get_down_thread_receive_realserver_socket_list(){
11222 return down_thread_receive_realserver_socket_list;
11224 std::map<endpoint,tcp_socket_ptr>& get_up_thread_send_realserver_socket_map(){
11225 return up_thread_send_realserver_socket_map;
11227 std::list<socket_element>::iterator& get_down_thread_current_receive_realserver_socket(){
11228 return down_thread_current_receive_realserver_socket;
11230 l7vs::tcp_realserver_connect_socket_list& get_down_thread_connect_socket_list(){
11231 return down_thread_connect_socket_list;
11235 void set_up_thread_id(boost::thread::id set_id){
11236 up_thread_id = set_id;
11238 void set_down_thread_id(boost::thread::id set_id){
11239 down_thread_id = set_id;
11242 void next_up_function_call(){
11243 up_thread_next_call_function.second(LOCAL_PROC);
11245 void next_down_function_call(){
11246 down_thread_next_call_function.second(LOCAL_PROC);
11249 void set_up_thread_next_function_call_exit(){
11250 up_thread_function_pair fun_it = up_thread_function_array[UP_FUNC_EXIT];
11251 up_thread_next_call_function = fun_it;
11254 void set_down_thread_next_function_call_exit(){
11255 down_thread_function_pair fun_it = down_thread_function_array[DOWN_FUNC_EXIT];
11256 down_thread_next_call_function = fun_it;
11259 // next call function check
11260 void up_thread_sorryserver_connect_event(const TCP_PROCESS_TYPE_TAG process_type){
11261 up_thread_sorryserver_connect_event_call_check = true;
11263 bool up_thread_sorryserver_connect_event_call_check;
11265 void up_thread_sorryserver_connection_fail_event(const TCP_PROCESS_TYPE_TAG process_type){
11266 up_thread_sorryserver_connection_fail_event_check = true;
11268 bool up_thread_sorryserver_connection_fail_event_check;
11270 void up_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
11271 up_thread_exit_call_check = true;
11273 bool up_thread_exit_call_check;
11275 void down_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
11276 down_thread_exit_call_check = true;
11278 bool down_thread_exit_call_check;
11281 void up_thread_function_array_clear(){
11282 for(int i = 0;i <= UP_FUNC_EXIT;i++){
11283 up_thread_function_array[i].second = NULL;
11286 void down_thread_function_map_clear(){
11287 for(int i = 0;i <= DOWN_FUNC_EXIT;i++){
11288 down_thread_function_array[i].second = NULL;
11292 void up_thread_module_event_map_clear(){
11293 up_thread_module_event_map.clear();
11296 void down_thread_module_event_map_clear(){
11297 down_thread_module_event_map.clear();
11301 void up_thread_sorryserver_connect_test(){
11302 BOOST_MESSAGE( "----- up_thread_sorryserver_connect test start -----" );
11303 l7vs::virtualservice_tcp vs;
11304 boost::asio::io_service io;
11305 l7vs::tcp_socket_option_info set_option;
11306 //! TCP_NODELAY (false:not set,true:set option)
11307 set_option.nodelay_opt = false;
11308 //! TCP_NODELAY option value (false:off,true:on)
11309 set_option.nodelay_val = false;
11310 //! TCP_CORK (false:not set,true:set option)
11311 set_option.cork_opt = false;
11312 //! TCP_CORK option value (false:off,true:on)
11313 set_option.cork_val = false;
11314 //! TCP_QUICKACK (false:not set,true:set option)
11315 set_option.quickack_opt = false;
11316 //! TCP_QUICKACK option value (false:off,true:on)
11317 set_option.quickack_val = false;
11319 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
11320 bool set_mode(false);
11321 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
11322 bool set_ssl_cache_flag(false);
11323 int set_ssl_handshake_time_out = 0;
11324 //std::string access_log_file_name = "test";
11325 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
11327 std::string test_protocol_name("test protocol");
11328 l7vs::test_protocol_module proto_test(test_protocol_name);
11329 // up_thread_sorryserver_send
11330 // up_thread_sorryserver_connect_test_class test_obj(vs,io);
11331 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);
11333 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
11334 boost::thread::id proc_id = boost::this_thread::get_id();
11336 l7vs::tcp_data& con_data = test_obj.get_up_thread_data_dest_side();
11337 boost::asio::ip::tcp::endpoint con_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP),7000);
11339 //up_thread_data_dest_side set
11340 con_data.initialize();
11341 con_data.set_endpoint(con_end);
11343 test_obj.set_up_thread_id(boost::thread::id());
11344 test_obj.set_down_thread_id(proc_id);
11346 l7vs::tcp_socket::connect_res = true;
11347 l7vs::tcp_socket::connect_connect_endpoint = boost::asio::ip::tcp::endpoint();
11348 l7vs::tcp_socket::connect_ec = NULL;
11349 l7vs::tcp_socket::connect_call_check = false;
11351 test_obj.set_up_thread_next_function_call_exit();
11352 test_obj.up_thread_sorryserver_connect_event_call_check = false;
11354 test_obj.test_call();
11356 // unit_test [1] up_thread_sorryserver_connect socket connect call check
11357 std::cout << "[1] up_thread_sorryserver_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_sorryserver_connect up_thread_next_call_function update check
11363 std::cout << "[2] up_thread_sorryserver_connect up_thread_next_call_function update check" << std::endl;
11364 test_obj.next_up_function_call();
11365 BOOST_CHECK(test_obj.up_thread_sorryserver_connect_event_call_check);
11367 // unit_test [3] up_thread_sorryserver_connect connect fail check
11368 std::cout << "[3] up_thread_sorryserver_connect connect fail check" << std::endl;
11369 l7vs::tcp_socket::connect_res = false;
11370 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
11371 l7vs::Logger::putLogError_id = 0;
11372 test_obj.test_call();
11373 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
11374 BOOST_CHECK_EQUAL(54,l7vs::Logger::putLogError_id);
11375 std::cout << l7vs::Logger::putLogError_message << std::endl;
11376 test_obj.up_thread_sorryserver_connection_fail_event_check = false;
11377 test_obj.next_up_function_call();
11378 BOOST_CHECK(test_obj.up_thread_sorryserver_connection_fail_event_check);
11380 l7vs::tcp_socket::connect_res = true;
11382 // unit_test [4] up_thread_realserver_connect set non blocking fail check
11383 std::cout << "[4] up_thread_realserver_connect set non blocking fail check" << std::endl;
11384 l7vs::tcp_socket::set_non_blocking_mode_res = false;
11385 l7vs::tcp_socket::set_non_blocking_mode_ec = boost::asio::error::bad_descriptor;
11386 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
11387 l7vs::Logger::putLogError_id = 0;
11388 test_obj.up_thread_exit_call_check = false;
11389 test_obj.test_call();
11390 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
11391 BOOST_CHECK_EQUAL(53,l7vs::Logger::putLogError_id);
11392 std::cout << l7vs::Logger::putLogError_message << std::endl;
11393 BOOST_CHECK(test_obj.up_thread_exit_call_check);
11394 l7vs::tcp_socket::set_non_blocking_mode_res = true;
11395 l7vs::tcp_socket::set_non_blocking_mode_ec.clear();
11397 // unit_test [5] up_thread_sorryserver_connect not fond function error check
11398 std::cout << "[5] up_thread_sorryserver_connect not fond function error check" << std::endl;
11399 test_obj.up_thread_function_array_clear();
11400 test_obj.up_thread_exit_call_check = false;
11401 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
11402 l7vs::Logger::putLogError_id = 0;
11403 test_obj.test_call();
11404 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
11405 BOOST_CHECK_EQUAL(55,l7vs::Logger::putLogError_id);
11406 std::cout << l7vs::Logger::putLogError_message << std::endl;
11407 BOOST_CHECK(test_obj.up_thread_exit_call_check);
11409 BOOST_MESSAGE( "----- up_thread_sorryserver_connect test end -----" );
11412 //realserver_disconnect test class
11413 class realserver_disconnect_test_class : public l7vs::tcp_session{
11415 // realserver_disconnect_test_class(l7vs::virtualservice_tcp& vs,boost::asio::io_service& session_io) : l7vs::tcp_session(vs,session_io){
11417 realserver_disconnect_test_class(
11418 l7vs::virtualservice_tcp& vs,
11419 boost::asio::io_service& session_io,
11420 l7vs::tcp_socket_option_info& set_socket_option,
11421 boost::asio::ip::tcp::endpoint listen_endpoint,
11423 boost::asio::ssl::context& set_ssl_context,
11424 bool set_ssl_cache_flag,
11425 int set_ssl_handshake_time_out,
11426 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
11432 set_ssl_cache_flag,
11433 set_ssl_handshake_time_out,
11434 set_access_logger){};
11436 ~realserver_disconnect_test_class(){};
11439 void test_up_call(){
11440 l7vs::tcp_session::up_thread_realserver_disconnect(LOCAL_PROC);
11442 void test_down_call(){
11443 l7vs::tcp_session::down_thread_realserver_disconnect(LOCAL_PROC);
11446 void test_up_all_call(){
11447 l7vs::tcp_session::up_thread_all_realserver_disconnect(LOCAL_PROC);
11449 void test_down_all_call(){
11450 l7vs::tcp_session::down_thread_all_realserver_disconnect(LOCAL_PROC);
11453 module_function_realserver_disconnect_mutex.wrlock();
11455 void mutex_unlock(){
11456 module_function_realserver_disconnect_mutex.unlock();
11458 // bool mutex_trylock(){
11459 // return module_function_realserver_disconnect_mutex.try_lock();
11462 void set_protocol_module(l7vs::protocol_module_base* set_prot){
11463 protocol_module = set_prot;
11465 l7vs::tcp_data& get_up_thread_data_client_side(){
11466 return up_thread_data_client_side;
11468 l7vs::tcp_data& get_up_thread_data_dest_side(){
11469 return up_thread_data_dest_side;
11471 l7vs::tcp_data& get_down_thread_data_client_side(){
11472 return down_thread_data_client_side;
11474 l7vs::tcp_data& get_down_thread_data_dest_side(){
11475 return down_thread_data_dest_side;
11477 l7vs::tcp_socket& get_client_socket(){
11478 return client_socket;
11480 socket_element& get_sorryserver_socket(){
11481 return sorryserver_socket;
11483 std::list<socket_element>& get_down_thread_receive_realserver_socket_list(){
11484 return down_thread_receive_realserver_socket_list;
11486 std::map<endpoint,tcp_socket_ptr>& get_up_thread_send_realserver_socket_map(){
11487 return up_thread_send_realserver_socket_map;
11489 std::list<socket_element>::iterator& get_down_thread_current_receive_realserver_socket(){
11490 return down_thread_current_receive_realserver_socket;
11492 l7vs::tcp_realserver_connect_socket_list& get_down_thread_connect_socket_list(){
11493 return down_thread_connect_socket_list;
11495 l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_down_thread_message_que(){
11496 return down_thread_message_que;
11498 l7vs::lockfree_queue<l7vs::tcp_thread_message>& get_up_thread_message_que(){
11499 return up_thread_message_que;
11502 void set_up_thread_id(boost::thread::id set_id){
11503 up_thread_id = set_id;
11505 void set_down_thread_id(boost::thread::id set_id){
11506 down_thread_id = set_id;
11509 void next_up_function_call(){
11510 up_thread_next_call_function.second(LOCAL_PROC);
11512 void next_down_function_call(){
11513 down_thread_next_call_function.second(LOCAL_PROC);
11516 void set_up_thread_next_function_call_exit(){
11517 up_thread_function_pair fun_it = up_thread_function_array[UP_FUNC_EXIT];
11518 up_thread_next_call_function = fun_it;
11521 void set_down_thread_next_function_call_exit(){
11522 down_thread_function_pair fun_it = down_thread_function_array[DOWN_FUNC_EXIT];
11523 down_thread_next_call_function = fun_it;
11526 // next call function check
11527 void up_thread_realserver_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){
11528 up_thread_realserver_disconnect_event_call_check = true;
11530 bool up_thread_realserver_disconnect_event_call_check;
11532 void down_thread_realserver_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){
11533 down_thread_realserver_disconnect_event_call_check = true;
11535 bool down_thread_realserver_disconnect_event_call_check;
11537 void up_thread_client_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
11538 up_thread_client_disconnect_call_check = true;
11540 bool up_thread_client_disconnect_call_check;
11542 void down_thread_client_disconnect(const TCP_PROCESS_TYPE_TAG process_type){
11543 down_thread_client_disconnect_call_check = true;
11545 bool down_thread_client_disconnect_call_check;
11547 void up_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
11548 up_thread_exit_call_check = true;
11550 bool up_thread_exit_call_check;
11552 void down_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){
11553 down_thread_exit_call_check = true;
11555 bool down_thread_exit_call_check;
11558 void up_thread_function_array_clear(){
11559 for(int i = 0;i <= UP_FUNC_EXIT;i++){
11560 up_thread_function_array[i].second = NULL;
11563 void down_thread_function_array_clear(){
11564 for(int i = 0;i <= DOWN_FUNC_EXIT;i++){
11565 down_thread_function_array[i].second = NULL;
11569 void up_thread_module_event_map_clear(){
11570 up_thread_module_event_map.clear();
11573 void down_thread_module_event_map_clear(){
11574 down_thread_module_event_map.clear();
11577 void up_thread_message_down_thread_function_map_clear(){
11578 up_thread_message_down_thread_function_map.clear();
11581 void down_thread_message_up_thread_function_map_clear(){
11582 down_thread_message_up_thread_function_map.clear();
11586 //up_thread_realserver_disconnect test
11587 void up_thread_realserver_disconnect_test(){
11588 BOOST_MESSAGE( "----- up_thread_realserver_disconnect test start -----" );
11590 boost::asio::io_service io;
11591 l7vs::virtualservice_tcp vs;
11592 l7vs::tcp_socket_option_info set_option;
11593 //! TCP_NODELAY (false:not set,true:set option)
11594 set_option.nodelay_opt = false;
11595 //! TCP_NODELAY option value (false:off,true:on)
11596 set_option.nodelay_val = false;
11597 //! TCP_CORK (false:not set,true:set option)
11598 set_option.cork_opt = false;
11599 //! TCP_CORK option value (false:off,true:on)
11600 set_option.cork_val = false;
11601 //! TCP_QUICKACK (false:not set,true:set option)
11602 set_option.quickack_opt = false;
11603 //! TCP_QUICKACK option value (false:off,true:on)
11604 set_option.quickack_val = false;
11606 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
11607 bool set_mode(false);
11608 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
11609 bool set_ssl_cache_flag(false);
11610 int set_ssl_handshake_time_out = 0;
11611 //std::string access_log_file_name = "test";
11612 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
11614 std::string test_protocol_name("test protocol");
11615 l7vs::test_protocol_module proto_test(test_protocol_name);
11616 // realserver_disconnect_test_class test_obj(vs,io);
11617 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);
11619 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
11620 boost::thread::id proc_id = boost::this_thread::get_id();
11622 l7vs::tcp_data& discon_data = test_obj.get_up_thread_data_dest_side();
11624 //up_thread_data_dest_side set
11625 boost::asio::ip::tcp::endpoint discon_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP),7001);
11626 discon_data.initialize();
11627 discon_data.set_endpoint(discon_end);
11629 test_obj.set_down_thread_id(boost::thread::id());
11630 test_obj.set_up_thread_id(proc_id);
11632 vs.connection_inactive_list.clear();
11634 // set realserver socket
11635 std::map<boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > >& rs_map = test_obj.get_up_thread_send_realserver_socket_map();
11636 std::map<boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > >::iterator rs_it;
11637 std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > push_pair;
11638 for(int i = 0 ; i < 3 ;i++){
11639 boost::shared_ptr< l7vs::tcp_socket > new_socket(new l7vs::tcp_socket(io));
11640 push_pair.first.address(boost::asio::ip::address::from_string(DUMMI_SERVER_IP));
11641 push_pair.first.port(7000+i);
11642 push_pair.second = new_socket;
11643 new_socket->close_res = true;
11644 new_socket->close_out_ec.clear();
11645 new_socket->close_call_check = false;
11646 rs_map.insert(push_pair);
11649 l7vs::lockfree_queue<l7vs::tcp_thread_message>& down_thread_message_que = test_obj.get_down_thread_message_que();
11650 l7vs::lockfree_queue<l7vs::tcp_thread_message>& up_thread_message_que = test_obj.get_up_thread_message_que();
11651 while( !down_thread_message_que.empty() ){
11652 l7vs::tcp_thread_message* tmp_ptr = down_thread_message_que.pop();
11655 while( !up_thread_message_que.empty() ){
11656 l7vs::tcp_thread_message* tmp_ptr = up_thread_message_que.pop();
11661 test_obj.set_up_thread_next_function_call_exit();
11662 test_obj.up_thread_realserver_disconnect_event_call_check = false;
11664 test_obj.test_up_call();
11666 rs_it = rs_map.find(discon_end);
11668 // unit_test [1] up_thread_realserver_disconnect socket close call check
11669 std::cout << "[1] up_thread_realserver_disconnect socket close call check" << std::endl;
11670 BOOST_CHECK(rs_it != rs_map.end());
11671 BOOST_CHECK(rs_it->second->close_call_check);
11673 // unit_test [2] up_thread_realserver_disconnect virtualservice connection_inactive call check
11674 std::cout << "[2] up_thread_realserver_disconnect virtualservice connection_inactive call check" << std::endl;
11675 BOOST_CHECK(!vs.connection_inactive_list.empty());
11676 BOOST_CHECK(*(vs.connection_inactive_list.begin()) == discon_end);
11678 // unit_test [3] up_thread_realserver_disconnect up thread message set check
11679 std::cout << "[3] up_thread_realserver_disconnect up thread message set check" << std::endl;
11680 BOOST_CHECK(!up_thread_message_que.empty());
11681 l7vs::tcp_thread_message* up_msg = up_thread_message_que.pop();
11682 BOOST_CHECK(up_thread_message_que.empty());
11683 BOOST_CHECK(up_msg->endpoint_info == discon_end);
11684 test_obj.up_thread_realserver_disconnect_event_call_check = false;
11685 up_msg->message(l7vs::tcp_session::MESSAGE_PROC);
11686 BOOST_CHECK(test_obj.up_thread_realserver_disconnect_event_call_check);
11689 // unit_test [4] up_thread_realserver_disconnect down thread message set check
11690 std::cout << "[4] up_thread_realserver_disconnect down thread message set check" << std::endl;
11691 BOOST_CHECK(!down_thread_message_que.empty());
11692 l7vs::tcp_thread_message* down_msg = down_thread_message_que.pop();
11693 BOOST_CHECK(down_thread_message_que.empty());
11694 BOOST_CHECK(down_msg->endpoint_info == discon_end);
11695 test_obj.down_thread_realserver_disconnect_event_call_check = false;
11696 down_msg->message(l7vs::tcp_session::MESSAGE_PROC);
11697 BOOST_CHECK(test_obj.down_thread_realserver_disconnect_event_call_check);
11700 // unit_test [5] up_thread_realserver_disconnect closed socket not set message check
11701 std::cout << "[5] up_thread_realserver_disconnect closed socket not set message check" << std::endl;
11702 rs_it->second->close_res = false;
11703 test_obj.test_up_call();
11704 BOOST_CHECK(up_thread_message_que.empty());
11705 BOOST_CHECK(down_thread_message_que.empty());
11707 rs_it->second->close_res = true;
11709 // unit_test [6] up_thread_realserver_disconnect not fond down_thread_realserver_disconnect_event function error check
11710 std::cout << "[6] up_thread_realserver_disconnect not fond down_thread_realserver_disconnect_event function error check" << std::endl;
11711 test_obj.up_thread_message_down_thread_function_map_clear();
11712 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
11713 l7vs::Logger::putLogError_id = 0;
11714 test_obj.up_thread_exit_call_check = false;
11715 test_obj.test_up_call();
11716 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
11717 BOOST_CHECK_EQUAL(44,l7vs::Logger::putLogError_id);
11718 std::cout << l7vs::Logger::putLogError_message << std::endl;
11719 BOOST_CHECK(test_obj.up_thread_exit_call_check);
11721 // unit_test [7] up_thread_realserver_disconnect not fond up_thread_sorryserver_disconnect_event function error check
11722 std::cout << "[7] up_thread_realserver_disconnect not fond up_thread_sorryserver_disconnect_event function error check" << std::endl;
11723 test_obj.up_thread_function_array_clear();
11724 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
11725 l7vs::Logger::putLogError_id = 0;
11726 test_obj.up_thread_exit_call_check = false;
11727 test_obj.test_up_call();
11728 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
11729 BOOST_CHECK_EQUAL(43,l7vs::Logger::putLogError_id);
11730 std::cout << l7vs::Logger::putLogError_message << std::endl;
11731 BOOST_CHECK(test_obj.up_thread_exit_call_check);
11733 BOOST_MESSAGE( "----- up_thread_realserver_disconnect test end -----" );
11736 //down_thread_realserver_disconnect test
11737 void down_thread_realserver_disconnect_test(){
11738 BOOST_MESSAGE( "----- down_thread_realserver_disconnect test start -----" );
11740 boost::asio::io_service io;
11741 l7vs::virtualservice_tcp vs;
11742 l7vs::tcp_socket_option_info set_option;
11743 //! TCP_NODELAY (false:not set,true:set option)
11744 set_option.nodelay_opt = false;
11745 //! TCP_NODELAY option value (false:off,true:on)
11746 set_option.nodelay_val = false;
11747 //! TCP_CORK (false:not set,true:set option)
11748 set_option.cork_opt = false;
11749 //! TCP_CORK option value (false:off,true:on)
11750 set_option.cork_val = false;
11751 //! TCP_QUICKACK (false:not set,true:set option)
11752 set_option.quickack_opt = false;
11753 //! TCP_QUICKACK option value (false:off,true:on)
11754 set_option.quickack_val = false;
11756 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
11757 bool set_mode(false);
11758 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
11759 bool set_ssl_cache_flag(false);
11760 int set_ssl_handshake_time_out = 0;
11761 //std::string access_log_file_name = "test";
11762 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
11764 std::string test_protocol_name("test protocol");
11765 l7vs::test_protocol_module proto_test(test_protocol_name);
11766 // realserver_disconnect_test_class test_obj(vs,io);
11767 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);
11769 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
11770 boost::thread::id proc_id = boost::this_thread::get_id();
11772 l7vs::tcp_data& discon_data = test_obj.get_down_thread_data_dest_side();
11774 //up_thread_data_dest_side set
11775 boost::asio::ip::tcp::endpoint discon_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP),7001);
11776 discon_data.initialize();
11777 discon_data.set_endpoint(discon_end);
11779 test_obj.set_up_thread_id(boost::thread::id());
11780 test_obj.set_down_thread_id(proc_id);
11782 vs.connection_inactive_list.clear();
11784 // set realserver socket
11785 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();
11786 std::list< std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > >::iterator rs_it;
11787 std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > push_pair;
11788 for(int i = 0 ; i < 3 ;i++){
11789 boost::shared_ptr< l7vs::tcp_socket > new_socket(new l7vs::tcp_socket(io));
11790 push_pair.first.address(boost::asio::ip::address::from_string(DUMMI_SERVER_IP));
11791 push_pair.first.port(7000+i);
11792 push_pair.second = new_socket;
11793 new_socket->close_res = true;
11794 new_socket->close_out_ec.clear();
11795 new_socket->close_call_check = false;
11796 rs_list.push_back(push_pair);
11800 l7vs::lockfree_queue<l7vs::tcp_thread_message>& down_thread_message_que = test_obj.get_down_thread_message_que();
11801 l7vs::lockfree_queue<l7vs::tcp_thread_message>& up_thread_message_que = test_obj.get_up_thread_message_que();
11802 while( !down_thread_message_que.empty() ){
11803 l7vs::tcp_thread_message* tmp_ptr = down_thread_message_que.pop();
11806 while( !up_thread_message_que.empty() ){
11807 l7vs::tcp_thread_message* tmp_ptr = up_thread_message_que.pop();
11812 test_obj.set_down_thread_next_function_call_exit();
11813 test_obj.down_thread_realserver_disconnect_event_call_check = false;
11815 test_obj.test_down_call();
11817 rs_it = rs_list.begin();
11818 while(rs_it != rs_list.end()){
11819 if( rs_it->first == discon_end )
11824 // unit_test [1] down_thread_realserver_disconnect socket close call check
11825 std::cout << "[1] down_thread_realserver_disconnect socket close call check" << std::endl;
11826 BOOST_CHECK(rs_it != rs_list.end());
11827 BOOST_CHECK(rs_it->second->close_call_check);
11829 // unit_test [2] down_thread_realserver_disconnect virtualservice connection_inactive call check
11830 std::cout << "[2] down_thread_realserver_disconnect virtualservice connection_inactive call check" << std::endl;
11831 BOOST_CHECK(!vs.connection_inactive_list.empty());
11832 BOOST_CHECK(*(vs.connection_inactive_list.begin()) == discon_end);
11834 // unit_test [3] down_thread_realserver_disconnect up thread message set check
11835 std::cout << "[3] down_thread_realserver_disconnect up thread message set check" << std::endl;
11836 BOOST_CHECK(!up_thread_message_que.empty());
11837 l7vs::tcp_thread_message* up_msg = up_thread_message_que.pop();
11838 BOOST_CHECK(up_thread_message_que.empty());
11839 BOOST_CHECK(up_msg->endpoint_info == discon_end);
11840 test_obj.up_thread_realserver_disconnect_event_call_check = false;
11841 up_msg->message(l7vs::tcp_session::MESSAGE_PROC);
11842 BOOST_CHECK(test_obj.up_thread_realserver_disconnect_event_call_check);
11845 // unit_test [4] up_thread_sorryserver_disconnect down thread message set check
11846 std::cout << "[4] up_thread_sorryserver_disconnect down thread message set check" << std::endl;
11847 BOOST_CHECK(!down_thread_message_que.empty());
11848 l7vs::tcp_thread_message* down_msg = down_thread_message_que.pop();
11849 BOOST_CHECK(down_thread_message_que.empty());
11850 BOOST_CHECK(down_msg->endpoint_info == discon_end);
11851 test_obj.down_thread_realserver_disconnect_event_call_check = false;
11852 down_msg->message(l7vs::tcp_session::MESSAGE_PROC);
11853 BOOST_CHECK(test_obj.down_thread_realserver_disconnect_event_call_check);
11856 // unit_test [5] down_thread_realserver_disconnect closed socket not set message check
11857 std::cout << "[5] down_thread_realserver_disconnect closed socket not set message check" << std::endl;
11858 rs_it->second->close_res = false;
11859 test_obj.test_down_call();
11860 BOOST_CHECK(up_thread_message_que.empty());
11861 BOOST_CHECK(down_thread_message_que.empty());
11863 rs_it->second->close_res = true;
11865 // unit_test [6] down_thread_realserver_disconnect not fond down_thread_realserver_disconnect_event function error check
11866 std::cout << "[6] down_thread_realserver_disconnect not fond down_thread_realserver_disconnect_event function error check" << std::endl;
11867 test_obj.down_thread_message_up_thread_function_map_clear();
11868 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
11869 l7vs::Logger::putLogError_id = 0;
11870 test_obj.down_thread_exit_call_check = false;
11871 test_obj.test_down_call();
11872 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
11873 BOOST_CHECK_EQUAL(73,l7vs::Logger::putLogError_id);
11874 std::cout << l7vs::Logger::putLogError_message << std::endl;
11875 BOOST_CHECK(test_obj.down_thread_exit_call_check);
11877 // unit_test [7] down_thread_realserver_disconnect not fond up_thread_sorryserver_disconnect_event function error check
11878 std::cout << "[7] down_thread_realserver_disconnect not fond up_thread_sorryserver_disconnect_event function error check" << std::endl;
11879 test_obj.down_thread_function_array_clear();
11880 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
11881 l7vs::Logger::putLogError_id = 0;
11882 test_obj.down_thread_exit_call_check = false;
11883 test_obj.test_down_call();
11884 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
11885 BOOST_CHECK_EQUAL(72,l7vs::Logger::putLogError_id);
11886 std::cout << l7vs::Logger::putLogError_message << std::endl;
11887 BOOST_CHECK(test_obj.down_thread_exit_call_check);
11889 BOOST_MESSAGE( "----- down_thread_realserver_disconnect test end -----" );
11893 //up_thread_all_realserver_disconnect test
11894 void up_thread_all_realserver_disconnect_test(){
11895 BOOST_MESSAGE( "----- up_thread_all_realserver_disconnect test start -----" );
11897 boost::asio::io_service io;
11898 l7vs::virtualservice_tcp vs;
11899 l7vs::tcp_socket_option_info set_option;
11900 //! TCP_NODELAY (false:not set,true:set option)
11901 set_option.nodelay_opt = false;
11902 //! TCP_NODELAY option value (false:off,true:on)
11903 set_option.nodelay_val = false;
11904 //! TCP_CORK (false:not set,true:set option)
11905 set_option.cork_opt = false;
11906 //! TCP_CORK option value (false:off,true:on)
11907 set_option.cork_val = false;
11908 //! TCP_QUICKACK (false:not set,true:set option)
11909 set_option.quickack_opt = false;
11910 //! TCP_QUICKACK option value (false:off,true:on)
11911 set_option.quickack_val = false;
11913 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
11914 bool set_mode(false);
11915 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
11916 bool set_ssl_cache_flag(false);
11917 int set_ssl_handshake_time_out = 0;
11918 //std::string access_log_file_name = "test";
11919 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
11921 std::string test_protocol_name("test protocol");
11922 l7vs::test_protocol_module proto_test(test_protocol_name);
11923 // realserver_disconnect_test_class test_obj(vs,io);
11924 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);
11925 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
11926 boost::thread::id proc_id = boost::this_thread::get_id();
11928 l7vs::tcp_data& discon_data = test_obj.get_up_thread_data_dest_side();
11930 //up_thread_data_dest_side set
11931 boost::asio::ip::tcp::endpoint discon_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP),7001);
11932 discon_data.initialize();
11933 discon_data.set_endpoint(discon_end);
11935 test_obj.set_down_thread_id(boost::thread::id());
11936 test_obj.set_up_thread_id(proc_id);
11938 vs.connection_inactive_list.clear();
11940 // set realserver socket
11941 std::map<boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > >& rs_map = test_obj.get_up_thread_send_realserver_socket_map();
11942 std::map<boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > >::iterator rs_it;
11943 std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > push_pair;
11944 std::list< std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > > ref_rs_list;
11945 std::list< std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > >::iterator ref_rs_it;
11946 for(int i = 0 ; i < 3 ;i++){
11947 boost::shared_ptr< l7vs::tcp_socket > new_socket(new l7vs::tcp_socket(io));
11948 push_pair.first.address(boost::asio::ip::address::from_string(DUMMI_SERVER_IP));
11949 push_pair.first.port(7000+i);
11950 push_pair.second = new_socket;
11951 new_socket->close_res = true;
11952 new_socket->close_out_ec.clear();
11953 new_socket->close_call_check = false;
11954 rs_map.insert(push_pair);
11955 ref_rs_list.push_back(push_pair);
11958 l7vs::lockfree_queue<l7vs::tcp_thread_message>& down_thread_message_que = test_obj.get_down_thread_message_que();
11959 l7vs::lockfree_queue<l7vs::tcp_thread_message>& up_thread_message_que = test_obj.get_up_thread_message_que();
11960 while( !down_thread_message_que.empty() ){
11961 l7vs::tcp_thread_message* tmp_ptr = down_thread_message_que.pop();
11964 while( !up_thread_message_que.empty() ){
11965 l7vs::tcp_thread_message* tmp_ptr = up_thread_message_que.pop();
11970 test_obj.set_up_thread_next_function_call_exit();
11971 test_obj.up_thread_client_disconnect_call_check = false;
11973 //protocol module set
11974 proto_test.handle_realserver_disconnect_res_tag = l7vs::protocol_module_base::CLIENT_DISCONNECT;
11975 proto_test.handle_realserver_disconnect_thread_id = boost::thread::id();
11976 proto_test.handle_realserver_disconnect_rs_endpoint_list.clear();
11978 test_obj.test_up_all_call();
11980 // unit_test [1] up_thread_all_realserver_disconnect socket close call check
11981 std::cout << "[1] up_thread_all_realserver_disconnect socket close call check" << std::endl;
11982 ref_rs_it = ref_rs_list.begin();
11983 while(ref_rs_it != ref_rs_list.end()){
11984 BOOST_CHECK(ref_rs_it->second->close_call_check);
11988 // unit_test [2] up_thread_all_realserver_disconnect virtualservice connection_inactive call check
11989 std::cout << "[2] up_thread_all_realserver_disconnect virtualservice connection_inactive call check" << std::endl;
11990 BOOST_CHECK(!vs.connection_inactive_list.empty());
11991 ref_rs_it = ref_rs_list.begin();
11992 while(ref_rs_it != ref_rs_list.end()){
11993 std::list<boost::asio::ip::tcp::endpoint>::iterator end_list_it = vs.connection_inactive_list.begin();
11994 while(end_list_it == vs.connection_inactive_list.end()){
11995 if(ref_rs_it->first == *end_list_it)
11999 BOOST_CHECK(end_list_it != vs.connection_inactive_list.end());
12003 // unit_test [3] up_thread_all_realserver_disconnect handle_realserver_disconnect call check
12004 std::cout << "[3] up_thread_all_realserver_disconnect handle_realserver_disconnect call check" << std::endl;
12005 BOOST_CHECK(proto_test.handle_realserver_disconnect_thread_id == proc_id);
12006 BOOST_CHECK(!proto_test.handle_realserver_disconnect_rs_endpoint_list.empty());
12007 ref_rs_it = ref_rs_list.begin();
12008 while(ref_rs_it != ref_rs_list.end()){
12009 std::list<boost::asio::ip::tcp::endpoint>::iterator end_list_it = proto_test.handle_realserver_disconnect_rs_endpoint_list.begin();
12010 while(end_list_it == vs.connection_inactive_list.end()){
12011 if(ref_rs_it->first == *end_list_it)
12015 BOOST_CHECK(end_list_it != proto_test.handle_realserver_disconnect_rs_endpoint_list.end());
12019 // unit_test [4] up_thread_all_realserver_disconnect update up_thread_next_call_function check
12020 std::cout << "[4] up_thread_all_realserver_disconnect update up_thread_next_call_function check" << std::endl;
12021 test_obj.next_up_function_call();
12022 BOOST_CHECK(test_obj.up_thread_client_disconnect_call_check);
12024 // unit_test [5] up_thread_all_realserver_disconnect realserver not fond check
12025 std::cout << "[5] up_thread_all_realserver_disconnect realserver not fond check" << std::endl;
12026 proto_test.handle_realserver_disconnect_thread_id = boost::thread::id();
12027 proto_test.handle_realserver_disconnect_rs_endpoint_list.clear();
12028 test_obj.up_thread_client_disconnect_call_check = false;
12030 test_obj.test_up_all_call();
12032 BOOST_CHECK(proto_test.handle_realserver_disconnect_thread_id == proc_id);
12033 BOOST_CHECK(!proto_test.handle_realserver_disconnect_rs_endpoint_list.empty());
12034 BOOST_CHECK( *(proto_test.handle_realserver_disconnect_rs_endpoint_list.begin()) == boost::asio::ip::tcp::endpoint() );
12035 test_obj.next_up_function_call();
12036 BOOST_CHECK(test_obj.up_thread_client_disconnect_call_check);
12038 // unit_test [6] up_thread_all_realserver_disconnect handle_realserver_disconnect mutex lock check
12039 std::cout << "[6] up_thread_all_realserver_disconnect handle_realserver_disconnect mutex lock check" << std::endl;
12040 ref_rs_it = ref_rs_list.begin();
12041 while(ref_rs_it != ref_rs_list.end()){
12042 rs_map.insert(*ref_rs_it);
12045 proto_test.handle_realserver_disconnect_thread_id = boost::thread::id();
12046 test_obj.mutex_lock();
12047 boost::thread test_thread(boost::bind(&realserver_disconnect_test_class::test_up_all_call,&test_obj));
12049 BOOST_CHECK(proto_test.handle_realserver_disconnect_thread_id == boost::thread::id());
12051 // unit_test [7] up_thread_all_realserver_disconnect handle_realserver_disconnect mutex unlock run check
12052 std::cout << "[7] up_thread_all_realserver_disconnect handle_realserver_disconnect mutex unlock run check" << std::endl;
12053 boost::thread::id test_id = test_thread.get_id();
12054 test_obj.set_up_thread_id(test_id);
12055 test_obj.mutex_unlock();
12057 BOOST_CHECK(proto_test.handle_realserver_disconnect_thread_id == test_id);
12058 test_thread.join();
12060 // unit_test [8] up_thread_all_realserver_disconnect not fond function error check
12061 std::cout << "[8] up_thread_all_realserver_disconnect not fond function error check" << std::endl;
12062 ref_rs_it = ref_rs_list.begin();
12063 while(ref_rs_it != ref_rs_list.end()){
12064 rs_map.insert(*ref_rs_it);
12067 test_obj.up_thread_function_array_clear();
12068 test_obj.up_thread_exit_call_check = false;
12069 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
12070 l7vs::Logger::putLogError_id = 0;
12071 test_obj.test_up_all_call();
12072 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
12073 BOOST_CHECK_EQUAL(48,l7vs::Logger::putLogError_id);
12074 std::cout << l7vs::Logger::putLogError_message << std::endl;
12075 BOOST_CHECK(test_obj.up_thread_exit_call_check);
12077 // unit_test [9] up_thread_all_realserver_disconnect returnd illegal EVENT_TAG error check
12078 std::cout << "[9] up_thread_all_realserver_disconnect returnd illegal EVENT_TAG error check" << std::endl;
12079 ref_rs_it = ref_rs_list.begin();
12080 while(ref_rs_it != ref_rs_list.end()){
12081 rs_map.insert(*ref_rs_it);
12084 test_obj.up_thread_module_event_map_clear();
12085 test_obj.up_thread_exit_call_check = false;
12086 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
12087 l7vs::Logger::putLogError_id = 0;
12088 test_obj.test_up_all_call();
12089 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
12090 BOOST_CHECK_EQUAL(47,l7vs::Logger::putLogError_id);
12091 std::cout << l7vs::Logger::putLogError_message << std::endl;
12092 BOOST_CHECK(test_obj.up_thread_exit_call_check);
12094 BOOST_MESSAGE( "----- up_thread_all_realserver_disconnect test end -----" );
12097 //down_thread_all_realserver_disconnect test
12098 void down_thread_all_realserver_disconnect_test(){
12099 BOOST_MESSAGE( "----- down_thread_all_realserver_disconnect test start -----" );
12101 boost::asio::io_service io;
12102 l7vs::virtualservice_tcp vs;
12103 l7vs::tcp_socket_option_info set_option;
12104 //! TCP_NODELAY (false:not set,true:set option)
12105 set_option.nodelay_opt = false;
12106 //! TCP_NODELAY option value (false:off,true:on)
12107 set_option.nodelay_val = false;
12108 //! TCP_CORK (false:not set,true:set option)
12109 set_option.cork_opt = false;
12110 //! TCP_CORK option value (false:off,true:on)
12111 set_option.cork_val = false;
12112 //! TCP_QUICKACK (false:not set,true:set option)
12113 set_option.quickack_opt = false;
12114 //! TCP_QUICKACK option value (false:off,true:on)
12115 set_option.quickack_val = false;
12117 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
12118 bool set_mode(false);
12119 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
12120 bool set_ssl_cache_flag(false);
12121 int set_ssl_handshake_time_out = 0;
12122 //std::string access_log_file_name = "test";
12123 l7vs::logger_implement_access* plogger = NULL;//new l7vs::logger_implement_access(access_log_file_name);
12125 std::string test_protocol_name("test protocol");
12126 l7vs::test_protocol_module proto_test(test_protocol_name);
12127 // realserver_disconnect_test_class test_obj(vs,io);
12128 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);
12129 test_obj.set_protocol_module((l7vs::protocol_module_base*)&proto_test);
12130 boost::thread::id proc_id = boost::this_thread::get_id();
12132 l7vs::tcp_data& discon_data = test_obj.get_down_thread_data_dest_side();
12134 //down_thread_data_dest_side set
12135 boost::asio::ip::tcp::endpoint discon_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP),7001);
12136 discon_data.initialize();
12137 discon_data.set_endpoint(discon_end);
12139 test_obj.set_up_thread_id(boost::thread::id());
12140 test_obj.set_down_thread_id(proc_id);
12142 vs.connection_inactive_list.clear();
12144 // set realserver socket
12145 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();
12146 std::list< std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > >::iterator rs_it;
12147 std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > push_pair;
12148 std::list< std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > > ref_rs_list;
12149 std::list< std::pair< boost::asio::ip::tcp::endpoint, boost::shared_ptr< l7vs::tcp_socket > > >::iterator ref_rs_it;
12150 for(int i = 0 ; i < 3 ;i++){
12151 boost::shared_ptr< l7vs::tcp_socket > new_socket(new l7vs::tcp_socket(io));
12152 push_pair.first.address(boost::asio::ip::address::from_string(DUMMI_SERVER_IP));
12153 push_pair.first.port(7000+i);
12154 push_pair.second = new_socket;
12155 new_socket->close_res = true;
12156 new_socket->close_out_ec.clear();
12157 new_socket->close_call_check = false;
12158 rs_list.push_back(push_pair);
12159 ref_rs_list.push_back(push_pair);
12162 l7vs::lockfree_queue<l7vs::tcp_thread_message>& down_thread_message_que = test_obj.get_down_thread_message_que();
12163 l7vs::lockfree_queue<l7vs::tcp_thread_message>& up_thread_message_que = test_obj.get_up_thread_message_que();
12164 while( !down_thread_message_que.empty() ){
12165 l7vs::tcp_thread_message* tmp_ptr = down_thread_message_que.pop();
12168 while( !up_thread_message_que.empty() ){
12169 l7vs::tcp_thread_message* tmp_ptr = up_thread_message_que.pop();
12174 test_obj.set_down_thread_next_function_call_exit();
12175 test_obj.down_thread_client_disconnect_call_check = false;
12177 //protocol module set
12178 proto_test.handle_realserver_disconnect_res_tag = l7vs::protocol_module_base::CLIENT_DISCONNECT;
12179 proto_test.handle_realserver_disconnect_thread_id = boost::thread::id();
12180 proto_test.handle_realserver_disconnect_rs_endpoint_list.clear();
12182 test_obj.test_down_all_call();
12184 // unit_test [1] down_thread_all_realserver_disconnect socket close call check
12185 std::cout << "[1] down_thread_all_realserver_disconnect socket close call check" << std::endl;
12186 ref_rs_it = ref_rs_list.begin();
12187 while(ref_rs_it != ref_rs_list.end()){
12188 BOOST_CHECK(ref_rs_it->second->close_call_check);
12192 // unit_test [2] down_thread_all_realserver_disconnect virtualservice connection_inactive call check
12193 std::cout << "[2] down_thread_all_realserver_disconnect virtualservice connection_inactive call check" << std::endl;
12194 BOOST_CHECK(!vs.connection_inactive_list.empty());
12195 ref_rs_it = ref_rs_list.begin();
12196 while(ref_rs_it != ref_rs_list.end()){
12197 std::list<boost::asio::ip::tcp::endpoint>::iterator end_list_it = vs.connection_inactive_list.begin();
12198 while(end_list_it == vs.connection_inactive_list.end()){
12199 if(ref_rs_it->first == *end_list_it)
12203 BOOST_CHECK(end_list_it != vs.connection_inactive_list.end());
12207 // unit_test [3] down_thread_all_realserver_disconnect handle_realserver_disconnect call check
12208 std::cout << "[3] down_thread_all_realserver_disconnect handle_realserver_disconnect call check" << std::endl;
12209 BOOST_CHECK(proto_test.handle_realserver_disconnect_thread_id == proc_id);
12210 BOOST_CHECK(!proto_test.handle_realserver_disconnect_rs_endpoint_list.empty());
12211 ref_rs_it = ref_rs_list.begin();
12212 while(ref_rs_it != ref_rs_list.end()){
12213 std::list<boost::asio::ip::tcp::endpoint>::iterator end_list_it = proto_test.handle_realserver_disconnect_rs_endpoint_list.begin();
12214 while(end_list_it == vs.connection_inactive_list.end()){
12215 if(ref_rs_it->first == *end_list_it)
12219 BOOST_CHECK(end_list_it != proto_test.handle_realserver_disconnect_rs_endpoint_list.end());
12223 // unit_test [4] down_thread_all_realserver_disconnect update up_thread_next_call_function check
12224 std::cout << "[4] down_thread_all_realserver_disconnect update up_thread_next_call_function check" << std::endl;
12225 test_obj.next_down_function_call();
12226 BOOST_CHECK(test_obj.down_thread_client_disconnect_call_check);
12228 // unit_test [5] down_thread_all_realserver_disconnect realserver not fond check
12229 std::cout << "[5] down_thread_all_realserver_disconnect realserver not fond check" << std::endl;
12230 proto_test.handle_realserver_disconnect_thread_id = boost::thread::id();
12231 proto_test.handle_realserver_disconnect_rs_endpoint_list.clear();
12232 test_obj.down_thread_client_disconnect_call_check = false;
12234 test_obj.test_down_all_call();
12236 BOOST_CHECK(proto_test.handle_realserver_disconnect_thread_id == proc_id);
12237 BOOST_CHECK(!proto_test.handle_realserver_disconnect_rs_endpoint_list.empty());
12238 BOOST_CHECK( *(proto_test.handle_realserver_disconnect_rs_endpoint_list.begin()) == boost::asio::ip::tcp::endpoint() );
12239 test_obj.next_down_function_call();
12240 BOOST_CHECK(test_obj.down_thread_client_disconnect_call_check);
12242 // unit_test [6] down_thread_all_realserver_disconnect handle_realserver_disconnect mutex lock check
12243 std::cout << "[6] down_thread_all_realserver_disconnect handle_realserver_disconnect mutex lock check" << std::endl;
12244 ref_rs_it = ref_rs_list.begin();
12245 while(ref_rs_it != ref_rs_list.end()){
12246 rs_list.push_back(*ref_rs_it);
12249 proto_test.handle_realserver_disconnect_thread_id = boost::thread::id();
12250 test_obj.mutex_lock();
12251 boost::thread test_thread(boost::bind(&realserver_disconnect_test_class::test_down_all_call,&test_obj));
12253 BOOST_CHECK(proto_test.handle_realserver_disconnect_thread_id == boost::thread::id());
12255 // unit_test [7] down_thread_all_realserver_disconnect handle_realserver_disconnect mutex unlock run check
12256 std::cout << "[7] down_thread_all_realserver_disconnect handle_realserver_disconnect mutex unlock run check" << std::endl;
12257 boost::thread::id test_id = test_thread.get_id();
12258 test_obj.set_down_thread_id(test_id);
12259 test_obj.mutex_unlock();
12261 BOOST_CHECK(proto_test.handle_realserver_disconnect_thread_id == test_id);
12262 test_thread.join();
12264 // unit_test [8] down_thread_all_realserver_disconnect not fond function error check
12265 std::cout << "[8] down_thread_all_realserver_disconnect not fond function error check" << std::endl;
12266 ref_rs_it = ref_rs_list.begin();
12267 while(ref_rs_it != ref_rs_list.end()){
12268 rs_list.push_back(*ref_rs_it);
12271 test_obj.down_thread_function_array_clear();
12272 test_obj.down_thread_exit_call_check = false;
12273 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
12274 l7vs::Logger::putLogError_id = 0;
12275 test_obj.test_down_all_call();
12276 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
12277 BOOST_CHECK_EQUAL(77,l7vs::Logger::putLogError_id);
12278 std::cout << l7vs::Logger::putLogError_message << std::endl;
12279 BOOST_CHECK(test_obj.down_thread_exit_call_check);
12281 // unit_test [9] down_thread_all_realserver_disconnect returnd illegal EVENT_TAG error check
12282 std::cout << "[9] down_thread_all_realserver_disconnect returnd illegal EVENT_TAG error check" << std::endl;
12283 ref_rs_it = ref_rs_list.begin();
12284 while(ref_rs_it != ref_rs_list.end()){
12285 rs_list.push_back(*ref_rs_it);
12288 test_obj.down_thread_module_event_map_clear();
12289 test_obj.down_thread_exit_call_check = false;
12290 l7vs::Logger::putLogError_category = l7vs::LOG_CAT_NONE;
12291 l7vs::Logger::putLogError_id = 0;
12292 test_obj.test_down_all_call();
12293 BOOST_CHECK_EQUAL(l7vs::LOG_CAT_L7VSD_SESSION,l7vs::Logger::putLogError_category);
12294 BOOST_CHECK_EQUAL(76,l7vs::Logger::putLogError_id);
12295 std::cout << l7vs::Logger::putLogError_message << std::endl;
12296 BOOST_CHECK(test_obj.down_thread_exit_call_check);
12298 BOOST_MESSAGE( "----- down_thread_all_realserver_disconnect test end -----" );
12308 test_client(boost::asio::io_service& io_service, boost::asio::ssl::context& context) :
12309 my_socket(io_service,context){
12316 //! socket connect mutex
12317 connect_mutex.wrlock();
12318 //! socket handshake mutex
12319 handshake_mutex.wrlock();
12320 //! socket read mutex
12321 read_mutex.wrlock();
12322 //! socket write mutex
12323 write_mutex.wrlock();
12324 //! socket close mutex
12325 close_mutex.wrlock();
12329 void handshake_test_run(){
12330 // dummy client start
12334 l7vs::rw_scoped_lock scope_lock(connect_mutex);
12336 if(!connect_test()){
12343 l7vs::rw_scoped_lock scope_lock(handshake_mutex);
12345 if(!handshake_test()){
12352 l7vs::rw_scoped_lock scope_lock(close_mutex);
12358 bool connect_test(){
12360 boost::system::error_code ec;
12361 std::cout << "dummy client connect try" << std::endl;
12362 boost::asio::ip::tcp::endpoint connect_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
12363 my_socket.lowest_layer().connect(connect_end,ec);
12366 std::cout << "dummy client connect Error!" << std::endl;
12367 std::cout << ec << std::endl;
12370 std::cout << "dummy client connect OK" << std::endl;
12374 bool handshake_test(){
12375 boost::system::error_code ec;
12376 std::cout << "dummy client handshake try" << std::endl;
12377 my_socket.handshake(boost::asio::ssl::stream_base::client, ec);
12380 std::cout << "dummy client handshake Error!" << std::endl;
12381 std::cout << ec << std::endl;
12384 std::cout << "dummy client handshake OK" << std::endl;
12390 boost::system::error_code ec;
12391 std::cout << "dummy client write try" << std::endl;
12392 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);
12395 std::cout << "dummy client send Error!" << std::endl;
12396 std::cout << ec << std::endl;
12399 send_data_size += write_size;
12400 std::cout << "dummy client send OK [" << send_data_size << "]" << std::endl;
12403 bool receive_test(){
12405 boost::system::error_code ec;
12406 std::cout << "dummy client read try" << std::endl;
12407 std::size_t read_size = my_socket.read_some(boost::asio::buffer(data_buff.data() + receive_data_size,MAX_BUFFER_SIZE), ec);
12410 std::cout << "dummy client receive Error!" << std::endl;
12411 std::cout << ec << std::endl;
12414 receive_data_size += read_size;
12415 std::cout << "dummy client receive OK [" << receive_data_size << "]" << std::endl;
12420 boost::system::error_code ec;
12421 std::cout << "dummy client close try" << std::endl;
12422 my_socket.lowest_layer().close(ec);
12425 std::cout << "dummy client close Error!" << std::endl;
12426 std::cout << ec << std::endl;
12429 std::cout << "dummy client close OK" << std::endl;
12432 boost::asio::ssl::stream<boost::asio::ip::tcp::socket> my_socket;
12433 boost::array<char,MAX_BUFFER_SIZE> data_buff;
12434 std::size_t receive_data_size;
12435 std::size_t send_data_size;
12437 //! socket connect mutex
12438 l7vs::wr_mutex connect_mutex;
12439 //! socket handshake mutex
12440 l7vs::wr_mutex handshake_mutex;
12441 //! socket read mutex
12442 l7vs::wr_mutex read_mutex;
12443 //! socket write mutex
12444 l7vs::wr_mutex write_mutex;
12445 //! socket close mutex
12446 l7vs::wr_mutex close_mutex;
12455 std::string get_password() const{
12456 std::cout << "call get_password" << std::endl;
12462 // ssl_clear_keep_cache test class
12463 class ssl_clear_keep_cache_test_class : public l7vs::tcp_session{
12465 ssl_clear_keep_cache_test_class(
12466 l7vs::virtualservice_tcp& vs,
12467 boost::asio::io_service& session_io,
12468 l7vs::tcp_socket_option_info& set_socket_option,
12469 boost::asio::ip::tcp::endpoint listen_endpoint,
12471 boost::asio::ssl::context& set_ssl_context,
12472 bool set_ssl_cache_flag,
12473 int set_ssl_handshake_time_out,
12474 l7vs::logger_implement_access* set_access_logger) : l7vs::tcp_session( vs,
12480 set_ssl_cache_flag,
12481 set_ssl_handshake_time_out,
12482 set_access_logger){};
12485 ~ssl_clear_keep_cache_test_class(){};
12486 bool& get_exit_flag(){
12490 bool test_call(SSL *clear_ssl){
12491 return ssl_clear_keep_cache(clear_ssl);
12495 //ssl_clear_keep_cache_test test
12496 void ssl_clear_keep_cache_test(){
12497 BOOST_MESSAGE( "----- ssl_clear_keep_cache test start -----" );
12499 boost::asio::io_service io;
12500 boost::system::error_code ec;
12501 authority test_auth;
12504 boost::asio::ssl::context client_ctx(io,boost::asio::ssl::context::sslv23);
12505 client_ctx.set_verify_mode(boost::asio::ssl::context::verify_peer);
12506 client_ctx.load_verify_file(CLIENT_CTX_LOAD_VERIFY_FILE);
12509 boost::asio::ssl::context server_ctx(io,boost::asio::ssl::context::sslv23);
12510 server_ctx.set_options(
12511 boost::asio::ssl::context::default_workarounds
12512 | boost::asio::ssl::context::no_sslv2
12513 | boost::asio::ssl::context::single_dh_use);
12514 server_ctx.set_password_callback(boost::bind(&authority::get_password, &test_auth));
12515 server_ctx.use_certificate_chain_file(SERVER_CTX_CERTIFICATE_CHAIN_FILE);
12516 server_ctx.use_private_key_file(SERVER_CTX_PRIVATE_KEY_FILE, boost::asio::ssl::context::pem);
12517 server_ctx.use_tmp_dh_file(SERVER_CTX_TMP_DH_FILE);
12519 // Set session cache mode on the context.
12520 SSL_CTX_set_session_cache_mode(server_ctx.impl(), (SSL_SESS_CACHE_SERVER | SSL_SESS_CACHE_NO_AUTO_CLEAR));
12521 // Set session cache size on the context.
12522 SSL_CTX_sess_set_cache_size(server_ctx.impl(), 10);
12523 // Set session cache timeout on the context.
12524 SSL_CTX_set_timeout(server_ctx.impl(), 60);
12528 boost::asio::ssl::stream<boost::asio::ip::tcp::socket> test_sock(io,server_ctx);
12531 boost::asio::ip::tcp::endpoint listen_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
12532 boost::asio::ip::tcp::acceptor test_acceptor(io,listen_end,ec);
12535 test_client dummy_cl(io,client_ctx);
12536 dummy_cl.all_lock();
12539 boost::thread cl_thread(boost::bind(&test_client::handshake_test_run,&dummy_cl));
12542 dummy_cl.connect_mutex.unlock();
12543 test_acceptor.accept(test_sock.lowest_layer(),ec);
12545 std::cout << "server side client connect ERROR" << std::endl;
12546 std::cout << ec << std::endl;
12548 std::cout << "server side client connect OK" << std::endl;
12553 dummy_cl.handshake_mutex.unlock();
12554 test_sock.handshake(boost::asio::ssl::stream_base::server,ec);
12556 std::cout << "server side client handshake ERROR" << std::endl;
12557 std::cout << ec << std::endl;
12559 std::cout << "server side handshake OK" << std::endl;
12563 BOOST_CHECK( SSL_CTX_sess_number(server_ctx.impl()) == 1);
12567 dummy_cl.close_mutex.unlock();
12570 test_sock.lowest_layer().close();
12572 BOOST_CHECK(test_sock.impl()->ssl->method != NULL);
12573 BOOST_CHECK(!test_sock.impl()->ssl->new_session);
12574 // BOOST_CHECK(test_sock.impl()->ssl->init_buf != NULL);
12575 BOOST_CHECK(test_sock.impl()->ssl->enc_read_ctx != NULL);
12576 BOOST_CHECK(test_sock.impl()->ssl->enc_write_ctx != NULL);
12577 // BOOST_CHECK(test_sock.impl()->ssl->expand != NULL);
12578 // BOOST_CHECK(test_sock.impl()->ssl->compress != NULL);
12580 test_sock.impl()->ssl->first_packet = 1; //0
12581 test_sock.impl()->ssl->session = (SSL_SESSION*)99; //NULL;
12582 test_sock.impl()->ssl->type = 2; //0;
12583 test_sock.impl()->ssl->error = 3; //0;
12584 test_sock.impl()->ssl->hit = 4; //0;
12585 test_sock.impl()->ssl->shutdown = 5; //0;
12586 test_sock.impl()->ssl->version = 6; // clear_ssl->method->version;
12587 test_sock.impl()->ssl->client_version = 0;//clear_ssl->version;
12588 test_sock.impl()->ssl->rwstate = 0; //SSL_NOTHING;
12589 test_sock.impl()->ssl->rstate = 0; //SSL_ST_READ_HEADER;
12590 test_sock.impl()->ssl->state = 0; //SSL_ST_BEFORE | ( ( clear_ssl->server ) ? SSL_ST_ACCEPT : SSL_ST_CONNECT);
12592 // BOOST_CHECK( test_sock.impl()->ssl->in_handshake || ( test_sock.impl()->ssl->method == test_sock.impl()->ssl->ctx->method ));
12593 // if ( !clear_ssl->in_handshake && ( clear_ssl->method != clear_ssl->ctx->method ))
12595 l7vs::virtualservice_tcp vs;
12596 l7vs::tcp_socket_option_info set_option;
12597 //! TCP_NODELAY (false:not set,true:set option)
12598 set_option.nodelay_opt = true;
12599 //! TCP_NODELAY option value (false:off,true:on)
12600 set_option.nodelay_val = true;
12601 //! TCP_CORK (false:not set,true:set option)
12602 set_option.cork_opt = true;
12603 //! TCP_CORK option value (false:off,true:on)
12604 set_option.cork_val = true;
12605 //! TCP_QUICKACK (false:not set,true:set option)
12606 set_option.quickack_opt = true;
12607 //! TCP_QUICKACK option value (false:off,true:on)
12608 set_option.quickack_val = true;
12610 boost::asio::ip::tcp::endpoint listen_endpoint(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
12611 bool set_mode(true);
12612 boost::asio::ssl::context set_context(io,boost::asio::ssl::context::sslv23);
12613 bool set_ssl_cache_flag(true);
12614 int set_ssl_handshake_time_out = 111;
12615 std::string access_log_file_name = "test";
12616 l7vs::logger_implement_access* plogger = new l7vs::logger_implement_access(access_log_file_name);
12618 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);
12621 BOOST_CHECK( SSL_CTX_sess_number(server_ctx.impl()) == 1);
12623 bool bres = test_obj.test_call(test_sock.impl()->ssl);
12625 BOOST_CHECK( SSL_CTX_sess_number(server_ctx.impl()) == 0);
12628 BOOST_CHECK(test_sock.impl()->ssl->init_buf == NULL);
12629 BOOST_CHECK(test_sock.impl()->ssl->enc_read_ctx == NULL);
12630 BOOST_CHECK(test_sock.impl()->ssl->enc_write_ctx == NULL);
12631 BOOST_CHECK(test_sock.impl()->ssl->expand == NULL);
12632 BOOST_CHECK(test_sock.impl()->ssl->compress == NULL);
12634 BOOST_CHECK(test_sock.impl()->ssl->first_packet == 0); //0
12635 BOOST_CHECK(test_sock.impl()->ssl->session == NULL); //NULL;
12636 BOOST_CHECK(test_sock.impl()->ssl->type == 0); //0;
12637 BOOST_CHECK(test_sock.impl()->ssl->error == 0); //0;
12638 BOOST_CHECK(test_sock.impl()->ssl->hit == 0); //0;
12639 BOOST_CHECK(test_sock.impl()->ssl->shutdown == 0); //0;
12640 BOOST_CHECK(test_sock.impl()->ssl->version == test_sock.impl()->ssl->method->version); // clear_ssl->method->version;
12641 BOOST_CHECK(test_sock.impl()->ssl->client_version == test_sock.impl()->ssl->method->version); // clear_ssl->version;
12642 BOOST_CHECK(test_sock.impl()->ssl->rwstate == SSL_NOTHING); // SSL_NOTHING;
12643 BOOST_CHECK(test_sock.impl()->ssl->rstate == SSL_ST_READ_HEADER); // SSL_ST_READ_HEADER;
12644 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);
12648 test_acceptor.close();
12650 BOOST_MESSAGE( "----- ssl_clear_keep_cache test end -----" );
12655 test_suite* init_unit_test_suite( int argc, char* argv[] ){
12657 test_suite* ts = BOOST_TEST_SUITE( "l7vs::tcp_socket class test" );
12659 ts->add( BOOST_TEST_CASE( &constructer_test ) );
12660 ts->add( BOOST_TEST_CASE( &initialize_test ) );
12661 ts->add( BOOST_TEST_CASE( &get_client_socket_test) );
12662 ts->add( BOOST_TEST_CASE( &handle_ssl_handshake_timer_test) );
12663 ts->add( BOOST_TEST_CASE( &is_thread_wait_test) );
12664 ts->add( BOOST_TEST_CASE( &set_virtual_service_message_test) );
12666 ts->add( BOOST_TEST_CASE( &up_thread_run_test) );
12667 ts->add( BOOST_TEST_CASE( &down_thread_run_test) );
12668 ts->add( BOOST_TEST_CASE( &thread_state_update_test) );
12669 ts->add( BOOST_TEST_CASE( &up_thread_client_respond_test) );
12670 ts->add( BOOST_TEST_CASE( &up_thread_realserver_get_detination_event_test) );
12671 ts->add( BOOST_TEST_CASE( &up_thread_sorryserver_get_detination_event_test) );
12673 ts->add( BOOST_TEST_CASE( &up_thread_all_socket_close_test) );
12674 ts->add( BOOST_TEST_CASE( &down_thread_all_socket_close_test) );
12675 ts->add( BOOST_TEST_CASE( &up_thread_client_disconnect_test) );
12676 ts->add( BOOST_TEST_CASE( &down_thread_client_disconnect_test) );
12677 ts->add( BOOST_TEST_CASE( &up_thread_sorryserver_disconnect_test) );
12678 ts->add( BOOST_TEST_CASE( &down_thread_sorryserver_disconnect_test) );
12679 ts->add( BOOST_TEST_CASE( &up_thread_realserver_connect_event_test) );
12680 ts->add( BOOST_TEST_CASE( &up_thread_sorryserver_connect_event_test) );
12681 ts->add( BOOST_TEST_CASE( &down_thread_client_connection_chk_event_test) );
12682 ts->add( BOOST_TEST_CASE( &up_thread_realserver_connection_fail_event_test) );
12683 ts->add( BOOST_TEST_CASE( &up_thread_sorryserver_connection_fail_event_test) );
12685 ts->add( BOOST_TEST_CASE( &up_thread_client_receive_test) );
12686 ts->add( BOOST_TEST_CASE( &down_thread_realserver_receive_test) );
12687 ts->add( BOOST_TEST_CASE( &down_thread_sorryserver_receive_test) );
12688 ts->add( BOOST_TEST_CASE( &up_thread_realserver_send_test) );
12689 ts->add( BOOST_TEST_CASE( &up_thread_sorryserver_send_test) );
12690 ts->add( BOOST_TEST_CASE( &down_thread_client_send_test) );
12691 ts->add( BOOST_TEST_CASE( &up_thread_realserver_connect_test) );
12692 ts->add( BOOST_TEST_CASE( &up_thread_sorryserver_connect_test) );
12693 ts->add( BOOST_TEST_CASE( &up_thread_realserver_disconnect_test) );
12694 ts->add( BOOST_TEST_CASE( &down_thread_realserver_disconnect_test) );
12695 ts->add( BOOST_TEST_CASE( &up_thread_all_realserver_disconnect_test) );
12696 ts->add( BOOST_TEST_CASE( &down_thread_all_realserver_disconnect_test) );
12698 ts->add( BOOST_TEST_CASE( &up_thread_exit_test ) );
12699 ts->add( BOOST_TEST_CASE( &down_thread_exit_test ) );
12700 ts->add( BOOST_TEST_CASE( &up_thread_client_disconnect_event_test ) );
12701 ts->add( BOOST_TEST_CASE( &down_thread_client_disconnect_event_test ) );
12702 ts->add( BOOST_TEST_CASE( &up_thread_realserver_disconnect_event_test ) );
12703 ts->add( BOOST_TEST_CASE( &down_thread_realserver_disconnect_event_test ) );
12704 ts->add( BOOST_TEST_CASE( &up_thread_sorryserver_disconnect_event_test ) );
12705 ts->add( BOOST_TEST_CASE( &down_thread_sorryserver_disconnect_event_test ) );
12706 ts->add( BOOST_TEST_CASE( &up_thread_sorryserver_mod_disconnect_test ) );
12707 ts->add( BOOST_TEST_CASE( &down_thread_sorryserver_mod_disconnect_test ) );
12709 ts->add( BOOST_TEST_CASE( &up_thread_sorry_enable_event_test ) );
12710 ts->add( BOOST_TEST_CASE( &up_thread_sorry_disable_event_test ) );
12711 ts->add( BOOST_TEST_CASE( &down_thread_sorry_enable_event_test ) );
12712 ts->add( BOOST_TEST_CASE( &down_thread_sorry_disable_event_test ) );
12713 ts->add( BOOST_TEST_CASE( &up_thread_client_accept_event_test ) );
12714 ts->add( BOOST_TEST_CASE( &up_thread_client_respond_event_test ) );
12715 ts->add( BOOST_TEST_CASE( &down_thread_client_respond_event_test ) );
12718 // ts->add( BOOST_TEST_CASE( &initialize_ssl_mode_test ) );
12719 // ts->add( BOOST_TEST_CASE( &up_thread_run_ssl_mode_test) );
12720 ts->add( BOOST_TEST_CASE( &ssl_clear_keep_cache_test ) );
12723 framework::master_test_suite().add( ts );