l7vsd/unit_tests/session_test/tcp_ssl_socket/tcp_ssl_socket_test.cpp

   1
   2 #define    TEST_CASE
   3
   4 #include <boost/thread/thread.hpp>
   5 #include <boost/test/included/unit_test.hpp>
   6
   7 #include "tcp_ssl_socket.h"
   8 #include "wrlock.h"
   9 #include "logger.h"
  10
  11 #define DUMMI_SERVER_IP     "127.0.0.1"
  12 #define DUMMI_SERVER_PORT     7000
  13
  14 using namespace boost::unit_test_framework;
  15
  16 // dummy client
  17 class test_client{
  18     public:
  19         //
  20         test_client(boost::asio::io_service& io_service, boost::asio::ssl::context& context) :
  21             my_socket(io_service,context){
  22         };
  23
  24         ~test_client(){
  25         };
  26         void all_lock(){
  27
  28             //! socket connect mutex
  29             connect_mutex.wrlock();
  30             //! socket handshake mutex
  31             hadshake_mutex.wrlock();
  32             //! socket read mutex
  33             read_mutex.wrlock();
  34             //! socket write mutex
  35             write_mutex.wrlock();
  36             //! socket close mutex
  37             close_mutex.wrlock();
  38
  39         }
  40
  41
  42         void handshake_test_run(){
  43             // dummy client start
  44
  45             // connect
  46             {
  47                 l7vs::rw_scoped_lock scope_lock(connect_mutex);
  48
  49                 if(!connect_test()){
  50                     return;
  51                 }
  52             }
  53
  54             // handshake
  55             {
  56                 l7vs::rw_scoped_lock scope_lock(hadshake_mutex);
  57
  58                 if(!handshake_test()){
  59                     return;
  60                 }
  61             }
  62 /*
  63             // send
  64             {
  65                 l7vs::rw_scoped_lock scope_lock(write_mutex);
  66                 if(!send_test()){
  67                     close_test();
  68                     return;
  69                 }
  70             }
  71             // receive
  72             {
  73                 l7vs::rw_scoped_lock scope_lock(read_mutex);
  74                 if(!receive_test()){
  75                     close_test();
  76                     return;
  77                 }
  78             }
  79 */
  80             // close
  81             {
  82                 l7vs::rw_scoped_lock scope_lock(close_mutex);
  83                 close_test();
  84             }
  85
  86         };
  87
  88         bool connect_test(){
  89             sleep(1);
  90             boost::system::error_code ec;
  91             boost::asio::ip::tcp::endpoint connect_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
  92             my_socket.lowest_layer().connect(connect_end,ec);
  93             if(ec){
  94                 //receive error
  95                 std::cout << "dummy client connect Error!" << std::endl;
  96                 return false;
  97             }
  98             std::cout << "dummy client connect OK" << std::endl;
  99             return true;
 100         };
 101
 102         bool handshake_test(){
 103             sleep(1);
 104             boost::system::error_code ec;
 105             my_socket.handshake(boost::asio::ssl::stream_base::server, ec);
 106             if(ec){
 107                 //receive error
 108                 std::cout << "dummy client handshake Error!" << std::endl;
 109                 return false;
 110             }
 111             std::cout << "dummy client handshake OK" << std::endl;
 112             return true;
 113         };
 114
 115         bool send_test(){
 116             sleep(1);
 117             boost::system::error_code ec;
 118             my_socket.write_some(boost::asio::buffer(request,MAX_BUFFER_SIZE), ec);
 119             if(ec){
 120                 //receive error
 121                 std::cout << "dummy client send Error!" << std::endl;
 122                 return false;
 123             }
 124             std::cout << "dummy client send OK" << std::endl;
 125             return true;
 126         };
 127         bool receive_test(){
 128             sleep(1);
 129             boost::system::error_code ec;
 130             my_socket.read_some(boost::asio::buffer(response,MAX_BUFFER_SIZE), ec);
 131             if(ec){
 132                 //receive error
 133                 std::cout << "dummy client receive Error!" << std::endl;
 134                 return false;
 135             }
 136             std::cout << "dummy client receive OK" << std::endl;
 137             return true;
 138         };
 139         void close_test(){
 140             sleep(1);
 141             boost::system::error_code ec;
 142             my_socket.lowest_layer().close(ec);
 143             if(ec){
 144                 //close error
 145                 std::cout << "dummy client close Error!" << std::endl;
 146                 return;
 147             }
 148             std::cout << "dummy client close OK" << std::endl;
 149         };
 150
 151         boost::asio::ssl::stream<boost::asio::ip::tcp::socket> my_socket;
 152         boost::array<char,MAX_BUFFER_SIZE> request;
 153         boost::array<char,MAX_BUFFER_SIZE> response;
 154
 155         //! socket connect mutex
 156         l7vs::wr_mutex connect_mutex;
 157         //! socket handshake mutex
 158         l7vs::wr_mutex handshake_mutex;
 159         //! socket read mutex
 160         l7vs::wr_mutex read_mutex;
 161         //! socket write mutex
 162         l7vs::wr_mutex write_mutex;
 163         //! socket close mutex
 164         l7vs::wr_mutex close_mutex;
 165 };
 166
 167 //
 168 class test_ssl_socket_class : public l7vs::tcp_ssl_socket{
 169     public:
 170
 171     test_ssl_socket_class(boost::asio::io_service& io,boost::asio::ssl::context& context,const l7vs::tcp_socket_option_info set_option) : l7vs::tcp_ssl_socket(io,context,set_option){
 172     };
 173     ~test_ssl_socket_class(){};
 174
 175     boost::asio::ip::tcp::endpoint get_local_end(){
 176         return my_socket.lowest_layer().local_endpoint();
 177     };
 178     boost::asio::ip::tcp::endpoint get_remote_end(){
 179         return my_socket.lowest_layer().remote_endpoint();
 180     };
 181     boost::asio::io_service& get_io(){
 182         return my_socket.lowest_layer().get_io_service();
 183     };
 184
 185     void test_close(boost::system::error_code& ec){
 186         my_socket.lowest_layer().close(ec);
 187     };
 188
 189     bool& get_open_flag(){
 190         return open_flag;
 191     };
 192
 193     boost::asio::ssl::stream<boost::asio::ip::tcp::socket>* get_socket_pointer(){
 194         return &my_socket;
 195     };
 196
 197     l7vs::tcp_socket_option_info* get_opt_info(){
 198         return &opt_info;
 199     };
 200
 201     std::string get_password() const
 202     {
 203         return "test";
 204     }
 205
 206 };
 207
 208 //--test case--
 209 // construcor test
 210 void construcor_test(){
 211
 212
 213     BOOST_MESSAGE( "----- construcor test start -----" );
 214
 215     boost::asio::io_service io;
 216
 217     l7vs::tcp_socket_option_info set_option;
 218     //! TCP_NODELAY   (false:not set,true:set option)
 219     set_option.nodelay_opt = true;
 220     //! TCP_NODELAY option value  (false:off,true:on)
 221     set_option.nodelay_val = true;
 222     //! TCP_CORK      (false:not set,true:set option)
 223     set_option.cork_opt = true;
 224     //! TCP_CORK option value     (false:off,true:on)
 225     set_option.cork_val = true;
 226     //! TCP_QUICKACK  (false:not set,true:set option)
 227     set_option.quickack_opt = true;
 228     //! TCP_QUICKACK option value (false:off,true:on)
 229     set_option.quickack_val = true;
 230
 231     // Server context
 232     boost::asio::ssl::context server_ctx(io,boost::asio::ssl::context::sslv23);
 233
 234    test_ssl_socket_class test_obj(io,server_ctx,set_option);
 235
 236     // unit_test [1] construcor test set io object
 237     std::cout << "[1] construcor test set io object" << std::endl;
 238     boost::asio::io_service& set_io = test_obj.get_io();
 239     BOOST_CHECK_EQUAL(&io , &set_io);
 240
 241     // unit_test [2] construcor test init open_flag
 242     std::cout << "[2] construcor test init open_flag" << std::endl;
 243     BOOST_CHECK(!test_obj.get_open_flag());
 244
 245     // unit_test [3] construcor test set socket option nodelay_opt
 246     std::cout << "[3] construcor test set socket option nodelay_opt" << std::endl;
 247     BOOST_CHECK_EQUAL(test_obj.get_opt_info()->nodelay_opt , set_option.nodelay_opt);
 248
 249     // unit_test [4] construcor test set socket option nodelay_val
 250     std::cout << "[4] construcor test set socket option nodelay_val" << std::endl;
 251     BOOST_CHECK_EQUAL(test_obj.get_opt_info()->nodelay_val , set_option.nodelay_val);
 252
 253     // unit_test [5] construcor test set socket option cork_opt
 254     std::cout << "[5] construcor test set socket option cork_opt" << std::endl;
 255     BOOST_CHECK_EQUAL(test_obj.get_opt_info()->cork_opt , set_option.cork_opt);
 256
 257     // unit_test [6] construcor test set socket option cork_val
 258     std::cout << "[6] construcor test set socket option cork_val" << std::endl;
 259     BOOST_CHECK_EQUAL(test_obj.get_opt_info()->cork_val , set_option.cork_val);
 260
 261     // unit_test [7] construcor test set socket option quickack_opt
 262     std::cout << "[7] construcor test set socket option quickack_opt" << std::endl;
 263     BOOST_CHECK_EQUAL(test_obj.get_opt_info()->quickack_opt , set_option.quickack_opt);
 264
 265     // unit_test [8] construcor test set socket option quickack_val
 266     std::cout << "[8] construcor test set socket option quickack_val" << std::endl;
 267     BOOST_CHECK_EQUAL(test_obj.get_opt_info()->quickack_val , set_option.quickack_val);
 268
 269     BOOST_MESSAGE( "----- construcor test end -----" );
 270 }
 271
 272 // handshake test
 273 void handshake_test(){
 274
 275
 276     BOOST_MESSAGE( "----- handshake test start -----" );
 277
 278     boost::asio::io_service io;
 279     boost::system::error_code ec;
 280
 281     l7vs::tcp_socket_option_info set_option;
 282     //! TCP_NODELAY   (false:not set,true:set option)
 283     set_option.nodelay_opt = false;
 284     //! TCP_NODELAY option value  (false:off,true:on)
 285     set_option.nodelay_val = false;
 286     //! TCP_CORK      (false:not set,true:set option)
 287     set_option.cork_opt = false;
 288     //! TCP_CORK option value     (false:off,true:on)
 289     set_option.cork_val = false;
 290     //! TCP_QUICKACK  (false:not set,true:set option)
 291     set_option.quickack_opt = false;
 292     //! TCP_QUICKACK option value (false:off,true:on)
 293     set_option.quickack_val = false;
 294
 295 std::cout << "DEBUG TEST A" << std::endl;
 296
 297     // Client context
 298     boost::asio::ssl::context client_ctx(io,boost::asio::ssl::context::sslv23);
 299     client_ctx.set_verify_mode(boost::asio::ssl::context::verify_peer);
 300     client_ctx.load_verify_file("ca.pem");
 301
 302
 303     // Server context
 304 std::cout << "DEBUG TEST B" << std::endl;
 305     boost::asio::ssl::context server_ctx(io,boost::asio::ssl::context::sslv23);
 306     test_ssl_socket_class test_obj(io,server_ctx,set_option);
 307
 308 std::cout << "DEBUG TEST C" << std::endl;
 309     server_ctx.set_options(
 310         boost::asio::ssl::context::default_workarounds
 311         | boost::asio::ssl::context::no_sslv2
 312         | boost::asio::ssl::context::single_dh_use);
 313     server_ctx.set_password_callback(boost::bind(&test_ssl_socket_class::get_password, &test_obj));
 314     server_ctx.use_certificate_chain_file("server.pem");
 315     server_ctx.use_private_key_file("server.pem", boost::asio::ssl::context::pem);
 316     server_ctx.use_tmp_dh_file("dh512.pem");
 317
 318 std::cout << "DEBUG TEST D" << std::endl;
 319     boost::asio::ip::tcp::endpoint listen_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
 320     boost::asio::ip::tcp::acceptor test_acceptor(io,listen_end,ec);
 321
 322 std::cout << "DEBUG TEST E" << std::endl;
 323     test_client dummy_cl(io,client_ctx);
 324 std::cout << "DEBUG TEST F" << std::endl;
 325
 326     dummy_cl.all_lock();
 327 std::cout << "DEBUG TEST G" << std::endl;
 328
 329     // client start
 330     boost::thread server_thread(boost::bind(&test_client::handshake_test_run,&dummy_cl));
 331 std::cout << "DEBUG TEST H" << std::endl;
 332
 333     // accept
 334     dummy_cl.connect_mutex.unlock();
 335     test_acceptor.accept(test_obj.get_socket().lowest_layer(),ec);
 336     if(ec){
 337         std::cout << "dummy client connect ERROR" << std::endl;
 338     }else{
 339         std::cout << "dummy client connect OK" << std::endl;
 340     }
 341     BOOST_CHECK(!ec);
 342
 343     // handshake
 344 std::cout << "DEBUG TEST I" << std::endl;
 345     dummy_cl.handshake_mutex.unlock();
 346     test_obj.handshake(ec);
 347     if(ec){
 348         std::cout << "dummy client handshake ERROR" << std::endl;
 349     }else{
 350         std::cout << "dummy client handshake OK" << std::endl;
 351     }
 352     BOOST_CHECK(!ec);
 353
 354     // close
 355 std::cout << "DEBUG TEST J" << std::endl;
 356     dummy_cl.close_mutex.unlock();
 357     test_obj.get_socket().lowest_layer().close();
 358
 359     BOOST_MESSAGE( "----- handshake_test test end -----" );
 360 }
 361
 362
 363 test_suite*    init_unit_test_suite( int argc, char* argv[] ){
 364
 365     test_suite* ts = BOOST_TEST_SUITE( "l7vs::tcp_ssl_socket class test" );
 366
 367     ts->add( BOOST_TEST_CASE( &construcor_test ) );
 368     ts->add( BOOST_TEST_CASE( &handshake_test ) );
 369 //    ts->add( BOOST_TEST_CASE( &accept_test ) );
 370 //    ts->add( BOOST_TEST_CASE( &get_ssl_socket_test ) );
 371 //    ts->add( BOOST_TEST_CASE( &set_non_blocking_mode_test ) );
 372 //    ts->add( BOOST_TEST_CASE( &write_some_read_some_test ) );
 373 //    ts->add( BOOST_TEST_CASE( &close_test ) );
 374 //    ts->add( BOOST_TEST_CASE( &close_lock_test ) );
 375 //    ts->add( BOOST_TEST_CASE( &is_open_test ) );
 376
 377     framework::master_test_suite().add( ts );
 378
 379     return NULL;
 380 }
 381
 382
 383
 384
 385
 386
 387
 388
 389
 390
 391 /*
 392
 393 // dummy mirror server
 394 class test_mirror_server{
 395
 396     public:
 397         bool bstop_flag;
 398         bool brun_flag;
 399         bool breq_acc_flag;
 400         bool breq_close_wait_flag;
 401         bool bconnect_flag;
 402         bool bdisconnect_flag;
 403         boost::asio::ip::tcp::endpoint accept_end;
 404         boost::asio::ip::tcp::endpoint connect_end;
 405         size_t receive_size;
 406         int req_recv_cnt;
 407         bool brecv_triger;
 408         size_t data_size;
 409
 410         test_mirror_server() :
 411                 bstop_flag(false),
 412                 brun_flag(false),
 413                 breq_acc_flag(false),
 414                 breq_close_wait_flag(false),
 415                 bconnect_flag(false),
 416                 bdisconnect_flag(false),
 417                 accept_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT),
 418                 connect_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT),
 419                 receive_size(0),
 420                 req_recv_cnt(0),
 421                 brecv_triger(false),
 422                 data_size(0){
 423         };
 424
 425         ~test_mirror_server(){
 426             bstop_flag = true;
 427
 428             while(brun_flag){
 429                 sleep(1);
 430             }
 431
 432         };
 433
 434         void run(){
 435             std::cout << "dummy mirror server run start!" << std::endl;
 436
 437             brun_flag = true;
 438             bconnect_flag = false;
 439             bdisconnect_flag = false;
 440             boost::asio::io_service io;
 441             boost::asio::ip::tcp::acceptor acc(io,accept_end);
 442             boost::system::error_code ec;
 443
 444             boost::array<char,MAX_BUFFER_SIZE> buf;
 445             receive_size = 0;
 446             size_t send_size = 0;
 447
 448
 449             while(!bstop_flag){
 450                 if(!breq_acc_flag){
 451                     continue;
 452                 }
 453
 454                 boost::asio::ip::tcp::socket con(io);
 455
 456                 // accept
 457                 acc.accept(con,ec);
 458                 if(ec){
 459                     std::cout << "dummy mirror server accept NG!" << std::endl;
 460                     break;
 461                 }else{
 462                     connect_end = con.remote_endpoint();
 463                     std::cout << "dummy mirror server accept OK! from " << connect_end << std::endl;
 464
 465                     breq_acc_flag = false;
 466                     // client chk
 467
 468                     bconnect_flag = true;
 469
 470                     for(int i = 0; i < req_recv_cnt ;i++){
 471                         while(!brecv_triger){
 472                             if(bstop_flag)
 473                                 break;
 474                         }
 475                         brecv_triger = false;
 476                         if(bstop_flag)
 477                             break;
 478
 479                         // receive
 480                         receive_size = 0;
 481                         while(receive_size < data_size){
 482                             size_t ret_size = con.read_some(boost::asio::buffer(buf.data() + receive_size,data_size - receive_size),ec);
 483                             if(ec){
 484                                 if(ec == boost::asio::error::eof || ec == boost::asio::error::connection_reset){
 485                                     std::cout << "dummy mirror server detect client disconnect!" << std::endl;
 486                                     bdisconnect_flag = true;
 487                                     break;
 488                                 }else{
 489                                     std::cout << "dummy mirror server receive NG!" << std::endl;
 490                                     break;
 491                                 }
 492                             }else if(ret_size > 0){
 493                                 receive_size += ret_size;
 494                                 std::cout << "dummy mirror server receive " << receive_size << "Byte" << std::endl;
 495                             }
 496                         }
 497                         if(!ec){
 498                             if(receive_size > 0){
 499                                 // send
 500                                 send_size = 0;
 501                                 while(send_size < receive_size){
 502                                     size_t ret_size = con.write_some(boost::asio::buffer(buf.data() + send_size,receive_size - send_size),ec);
 503                                     if(ec){
 504                                         std::cout << "dummy mirror server send NG!" << std::endl;
 505                                         break;
 506                                     }else if(ret_size > 0){
 507                                         send_size += ret_size;
 508                                         std::cout << "dummy mirror server send " << send_size << "Byte" << std::endl;
 509                                     }
 510                                 }
 511                             }
 512                         }
 513                     }
 514
 515                     std::cout << "dummy mirror server connection close wait start" << std::endl;
 516                     while(breq_close_wait_flag){
 517                         sleep(1);
 518                     }
 519                     std::cout << "dummy mirror server connection close wait end" << std::endl;
 520                     // close
 521                     con.close(ec);
 522                 }
 523             }
 524
 525             acc.close(ec);
 526
 527             brun_flag = false;
 528
 529             std::cout << "dummy mirror server run end!" << std::endl;
 530         };
 531 };
 532
 533 //
 534 class test_socket_class : public l7vs::tcp_socket{
 535     public:
 536
 537 //    test_socket_class(boost::asio::io_service& io) : l7vs::tcp_socket(io){
 538 //    };
 539     test_socket_class(boost::asio::io_service& io,const l7vs::tcp_socket_option_info set_option) : l7vs::tcp_socket(io,set_option){
 540     };
 541     ~test_socket_class(){};
 542
 543     boost::asio::ip::tcp::endpoint get_local_end(){
 544         return my_socket.local_endpoint();
 545     }
 546     boost::asio::ip::tcp::endpoint get_remote_end(){
 547         return my_socket.remote_endpoint();
 548     }
 549     boost::asio::io_service& get_io(){
 550         return my_socket.get_io_service();
 551     }
 552
 553     void test_close(boost::system::error_code& ec){
 554         my_socket.close(ec);
 555     }
 556
 557     bool& get_open_flag(){
 558         return open_flag;
 559     }
 560
 561     boost::asio::ip::tcp::socket* get_socket_pointer(){
 562         return &my_socket;
 563     }
 564
 565     l7vs::tcp_socket_option_info* get_opt_info(){
 566         return &opt_info;
 567     }
 568
 569 };
 570
 571
 572 //--test case--
 573 // construcor test
 574 void construcor_test(){
 575
 576
 577     BOOST_MESSAGE( "----- construcor test start -----" );
 578
 579     boost::asio::io_service io;
 580
 581     l7vs::tcp_socket_option_info set_option;
 582     //! TCP_NODELAY   (false:not set,true:set option)
 583     set_option.nodelay_opt = true;
 584     //! TCP_NODELAY option value  (false:off,true:on)
 585     set_option.nodelay_val = true;
 586     //! TCP_CORK      (false:not set,true:set option)
 587     set_option.cork_opt = true;
 588     //! TCP_CORK option value     (false:off,true:on)
 589     set_option.cork_val = true;
 590     //! TCP_QUICKACK  (false:not set,true:set option)
 591     set_option.quickack_opt = true;
 592     //! TCP_QUICKACK option value (false:off,true:on)
 593     set_option.quickack_val = true;
 594
 595     test_socket_class test_obj(io,set_option);
 596
 597     // unit_test [1] construcor test set io object
 598     std::cout << "[1] construcor test set io object" << std::endl;
 599     boost::asio::io_service& set_io = test_obj.get_io();
 600     BOOST_CHECK_EQUAL(&io , &set_io);
 601
 602     // unit_test [2] construcor test init open_flag
 603     std::cout << "[2] construcor test init open_flag" << std::endl;
 604     BOOST_CHECK(!test_obj.get_open_flag());
 605
 606     // unit_test [3] construcor test set socket option nodelay_opt
 607     std::cout << "[3] construcor test set socket option nodelay_opt" << std::endl;
 608     BOOST_CHECK_EQUAL(test_obj.get_opt_info()->nodelay_opt , set_option.nodelay_opt);
 609
 610     // unit_test [4] construcor test set socket option nodelay_val
 611     std::cout << "[4] construcor test set socket option nodelay_val" << std::endl;
 612     BOOST_CHECK_EQUAL(test_obj.get_opt_info()->nodelay_val , set_option.nodelay_val);
 613
 614     // unit_test [5] construcor test set socket option cork_opt
 615     std::cout << "[5] construcor test set socket option cork_opt" << std::endl;
 616     BOOST_CHECK_EQUAL(test_obj.get_opt_info()->cork_opt , set_option.cork_opt);
 617
 618     // unit_test [6] construcor test set socket option cork_val
 619     std::cout << "[6] construcor test set socket option cork_val" << std::endl;
 620     BOOST_CHECK_EQUAL(test_obj.get_opt_info()->cork_val , set_option.cork_val);
 621
 622     // unit_test [7] construcor test set socket option quickack_opt
 623     std::cout << "[7] construcor test set socket option quickack_opt" << std::endl;
 624     BOOST_CHECK_EQUAL(test_obj.get_opt_info()->quickack_opt , set_option.quickack_opt);
 625
 626     // unit_test [8] construcor test set socket option quickack_val
 627     std::cout << "[8] construcor test set socket option quickack_val" << std::endl;
 628     BOOST_CHECK_EQUAL(test_obj.get_opt_info()->quickack_val , set_option.quickack_val);
 629
 630     BOOST_MESSAGE( "----- construcor test end -----" );
 631 }
 632
 633 void connect_test(){
 634
 635     BOOST_MESSAGE( "----- connect test start -----" );
 636
 637
 638     test_mirror_server test_server;
 639
 640     // accept req
 641     test_server.breq_acc_flag = true;
 642     // close wait req
 643     test_server.breq_close_wait_flag = true;
 644
 645     // test server start
 646     boost::thread server_thread(boost::bind(&test_mirror_server::run,&test_server));
 647
 648     while( !test_server.brun_flag ){
 649         sleep(1);
 650     }
 651
 652     std::cout << "ready dummy mirror server" << std::endl;
 653
 654     // unit_test [1] connect test connection success error_code object
 655     std::cout << "[1] connect test connection success error_code object" << std::endl;
 656     boost::asio::ip::tcp::endpoint connect_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
 657     boost::asio::io_service io;
 658     boost::system::error_code ec;
 659
 660     l7vs::tcp_socket_option_info set_option;
 661     //! TCP_NODELAY   (false:not set,true:set option)
 662     set_option.nodelay_opt = true;
 663     //! TCP_NODELAY option value  (false:off,true:on)
 664     set_option.nodelay_val = true;
 665     //! TCP_CORK      (false:not set,true:set option)
 666     set_option.cork_opt = true;
 667     //! TCP_CORK option value     (false:off,true:on)
 668     set_option.cork_val = true;
 669     //! TCP_QUICKACK  (false:not set,true:set option)
 670     set_option.quickack_opt = true;
 671     //! TCP_QUICKACK option value (false:off,true:on)
 672     set_option.quickack_val = true;
 673
 674     test_socket_class test_obj(io,set_option);
 675     test_obj.connect(connect_end,ec);
 676     BOOST_CHECK(!ec);
 677
 678     // unit_test [2] connect test connection success open_flag
 679     std::cout << "[2] connect test connection success open_flag" << std::endl;
 680     BOOST_CHECK(test_obj.get_open_flag());
 681
 682     // TCP_NODELAY check!!
 683     // unit_test [3] connect test set socket option TCP_NODELAY
 684     std::cout << "[3] connect test set socket option TCP_NODELAY" << std::endl;
 685     boost::asio::ip::tcp::no_delay get_option;
 686     test_obj.get_socket_pointer()->get_option(get_option,ec);
 687     BOOST_CHECK(!ec);
 688     BOOST_CHECK(get_option == set_option.nodelay_val);
 689
 690     // TCP_CORK check!!
 691     // unit_test [4] connect test set socket option TCP_CORK
 692     std::cout << "[4] connect test set socket option TCP_CORK" << std::endl;
 693     int val;
 694     size_t len = sizeof(val);
 695     boost::asio::detail::socket_ops::getsockopt(test_obj.get_socket_pointer()->native(),IPPROTO_TCP,TCP_CORK,&val,&len,ec);
 696     BOOST_CHECK(!ec);
 697     BOOST_CHECK((bool)val == set_option.cork_val);
 698
 699
 700     while(!test_server.bconnect_flag){
 701         sleep(1);
 702     }
 703
 704     boost::asio::ip::tcp::endpoint chk_end;
 705     boost::asio::ip::tcp::endpoint ref_end;
 706
 707     // unit_test [5] connect test connect local endpoint
 708     std::cout << "[5] connect test connect local endpoint" << std::endl;
 709     chk_end = test_obj.get_local_end();
 710     ref_end = test_server.connect_end;
 711     BOOST_CHECK_EQUAL(chk_end , ref_end);
 712
 713
 714     // unit_test [6] connect test connect remote endpoint
 715     std::cout << "[6] connect test connect remote endpoint" << std::endl;
 716     chk_end = test_obj.get_remote_end();
 717     ref_end = connect_end;
 718     BOOST_CHECK_EQUAL(chk_end , ref_end);
 719
 720     // unit_test [7] connect test connect recall check
 721     std::cout << "[7] connect test connect recall check" << std::endl;
 722     test_obj.connect(connect_end,ec);
 723     BOOST_CHECK(!ec);
 724     BOOST_CHECK(test_obj.get_open_flag());
 725
 726     test_obj.test_close(ec);
 727     test_obj.get_open_flag() = false;
 728
 729     test_server.breq_close_wait_flag = false;
 730     test_server.bstop_flag = true;
 731     server_thread.join();
 732
 733     // unit_test [8] connect test connection faile error_code object
 734     std::cout << "[8] connect test connection faile error_code object" << std::endl;
 735     test_obj.connect(connect_end,ec);
 736     BOOST_CHECK(ec);
 737
 738     // unit_test [9] connect test connection faile open_flag
 739     std::cout << "[9] connect test connection faile open_flag" << std::endl;
 740     BOOST_CHECK(!test_obj.get_open_flag());
 741
 742     BOOST_MESSAGE( "----- connect test end -----" );
 743
 744 }
 745
 746 void set_non_blocking_mode_test(){
 747     BOOST_MESSAGE( "----- set_non_blocking_mode test start -----" );
 748
 749     test_mirror_server test_server;
 750
 751     // accept req
 752     test_server.breq_acc_flag = true;
 753     // close wait req
 754     test_server.breq_close_wait_flag = true;
 755
 756     // test server start
 757     boost::thread server_thread(boost::bind(&test_mirror_server::run,&test_server));
 758
 759     while( !test_server.brun_flag ){
 760         sleep(1);
 761     }
 762
 763     std::cout << "ready dummy mirror server" << std::endl;
 764
 765
 766
 767     boost::asio::ip::tcp::endpoint connect_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
 768     boost::asio::io_service io;
 769     boost::system::error_code ec;
 770
 771     l7vs::tcp_socket_option_info set_option;
 772     //! TCP_NODELAY   (false:not set,true:set option)
 773     set_option.nodelay_opt = false;
 774     //! TCP_NODELAY option value  (false:off,true:on)
 775     set_option.nodelay_val = false;
 776     //! TCP_CORK      (false:not set,true:set option)
 777     set_option.cork_opt = false;
 778     //! TCP_CORK option value     (false:off,true:on)
 779     set_option.cork_val = false;
 780     //! TCP_QUICKACK  (false:not set,true:set option)
 781     set_option.quickack_opt = false;
 782     //! TCP_QUICKACK option value (false:off,true:on)
 783     set_option.quickack_val = false;
 784
 785     test_socket_class test_obj(io,set_option);
 786     test_obj.connect(connect_end,ec);
 787     BOOST_CHECK(!ec);
 788
 789     while(!test_server.bconnect_flag){
 790         sleep(1);
 791     }
 792
 793     // unit_test [1] set_non_blocking_mode test set non blocking mode success error_code object
 794     std::cout << "[1] set_non_blocking_mode test set non blocking mode success error_code object" << std::endl;
 795     test_obj.set_non_blocking_mode(ec);
 796     BOOST_CHECK(!ec);
 797
 798     test_obj.test_close(ec);
 799
 800     test_server.breq_close_wait_flag = false;
 801     test_server.bstop_flag = true;
 802     server_thread.join();
 803
 804     // unit_test [2] set_non_blocking_mode test set non blocking mode faile error_code object
 805     std::cout << "[2] set_non_blocking_mode test set non blocking mode faile error_code object" << std::endl;
 806     test_obj.set_non_blocking_mode(ec);
 807     BOOST_CHECK(ec);
 808
 809     BOOST_MESSAGE( "----- set_non_blocking_mode test end -----" );
 810 }
 811
 812
 813 void write_some_read_some_test(){
 814     BOOST_MESSAGE( "----- write_some read_some test start -----" );
 815
 816     test_mirror_server test_server;
 817
 818     // accept req
 819     test_server.breq_acc_flag = true;
 820     // close wait req
 821     test_server.breq_close_wait_flag = true;
 822     // recv cont
 823     test_server.req_recv_cnt = 513;
 824
 825
 826     // test server start
 827     boost::thread server_thread(boost::bind(&test_mirror_server::run,&test_server));
 828
 829     while( !test_server.brun_flag ){
 830         sleep(1);
 831     }
 832
 833     std::cout << "ready dummy mirror server" << std::endl;
 834
 835     // connect
 836     boost::asio::ip::tcp::endpoint connect_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
 837     boost::asio::io_service io;
 838     boost::system::error_code ec;
 839
 840     l7vs::tcp_socket_option_info set_option;
 841     //! TCP_NODELAY   (false:not set,true:set option)
 842     set_option.nodelay_opt = true;
 843     //! TCP_NODELAY option value  (false:off,true:on)
 844     set_option.nodelay_val = true;
 845     //! TCP_CORK      (false:not set,true:set option)
 846     set_option.cork_opt = true;
 847     //! TCP_CORK option value     (false:off,true:on)
 848     set_option.cork_val = true;
 849     //! TCP_QUICKACK  (false:not set,true:set option)
 850     set_option.quickack_opt = true;
 851     //! TCP_QUICKACK option value (false:off,true:on)
 852     set_option.quickack_val = true;
 853
 854     test_socket_class test_obj(io,set_option);
 855     test_obj.connect(connect_end,ec);
 856     BOOST_CHECK(!ec);
 857
 858     while(!test_server.bconnect_flag){
 859         sleep(1);
 860     }
 861
 862     test_obj.set_non_blocking_mode(ec);
 863     BOOST_CHECK(!ec);
 864
 865     boost::array<char,MAX_BUFFER_SIZE> send_buff;
 866     boost::array<char,MAX_BUFFER_SIZE> recv_buff;
 867     size_t send_size;
 868     size_t res_size;
 869     size_t send_data_size;
 870     size_t receve_data_size;
 871
 872     //size 0
 873     // ## write some read some test [1] size 0
 874     send_size = 0;
 875     test_server.brecv_triger = true;
 876     test_server.data_size = send_size;
 877     while(true){
 878         res_size = test_obj.write_some(boost::asio::buffer(send_buff, send_size),ec);
 879         if(ec){
 880             if(ec == boost::asio::error::try_again){
 881                 continue;
 882             }
 883         }
 884         break;
 885     }
 886     // unit_test [1] write_some & read_some test size 0 write error_code object
 887     std::cout << "[1] write_some & read_some test size 0 write error_code object" << std::endl;
 888     BOOST_CHECK(!ec);
 889
 890     // unit_test [2] write_some & read_some test size 0 write size
 891     std::cout << "[2] write_some & read_some test size 0 write size" << std::endl;
 892     BOOST_CHECK_EQUAL(res_size, send_size);
 893
 894     sleep(1);
 895
 896     res_size = test_obj.read_some(boost::asio::buffer(recv_buff, MAX_BUFFER_SIZE),ec);
 897
 898     // unit_test [3] write_some & read_some test size 0 read error_code object
 899     std::cout << "[3] write_some & read_some test size 0 read error_code object" << std::endl;
 900     BOOST_CHECK_EQUAL(ec,boost::asio::error::try_again);
 901
 902     // unit_test [4] write_some & read_some test size 0 read size
 903     std::cout << "[4] write_some & read_some test size 0 read size" << std::endl;
 904     BOOST_CHECK_EQUAL(res_size,0UL);
 905
 906     // size 1
 907     send_size = 1;
 908     test_server.data_size = send_size;
 909     send_buff[0] = 'A';
 910     recv_buff[0] = 'B';
 911
 912     test_server.brecv_triger = true;
 913     while(true){
 914         res_size = test_obj.write_some(boost::asio::buffer(send_buff, send_size),ec);
 915         if(ec){
 916             if(ec == boost::asio::error::try_again){
 917                 continue;
 918             }
 919         }
 920         break;
 921     }
 922
 923     // unit_test [5] write_some & read_some test size 1 write error_code object
 924     std::cout << "[5] write_some & read_some test size 1 write error_code object" << std::endl;
 925     BOOST_CHECK(!ec);
 926
 927     // unit_test [6] write_some & read_some test size 1 write send size
 928     std::cout << "[6] write_some & read_some test size 1 write send size" << std::endl;
 929     BOOST_CHECK_EQUAL(res_size, send_size);
 930
 931     while(true){
 932         res_size = test_obj.read_some(boost::asio::buffer(recv_buff, MAX_BUFFER_SIZE),ec);
 933         if(ec){
 934             if(ec == boost::asio::error::try_again){
 935                 continue;
 936             }
 937         }
 938         break;
 939     }
 940
 941     // unit_test [7] write_some & read_some test size 1 read error_code object
 942     std::cout << "[7] write_some & read_some test size 1 read error_code object" << std::endl;
 943     BOOST_CHECK(!ec);
 944
 945     // unit_test [8] write_some & read_some test size 1 read size
 946     std::cout << "[8] write_some & read_some test size 1 read size" << std::endl;
 947     BOOST_CHECK_EQUAL(res_size, send_size);
 948
 949     // unit_test [9] write_some & read_some test size 1 data check
 950     std::cout << "[9] write_some & read_some test size 1 data check" << std::endl;
 951     BOOST_CHECK_EQUAL(send_buff[0],recv_buff[0]);
 952
 953
 954     // size MAX_BUFFER_SIZE
 955     send_size = MAX_BUFFER_SIZE;
 956     test_server.data_size = send_size;
 957     for(int i = 0;i < (int)send_size;i++)
 958         send_buff[i] = 'A';
 959
 960     for(int i = 0;i < (int)send_size;i++)
 961         recv_buff[i] = 'B';
 962
 963     send_data_size = 0;
 964     receve_data_size = 0;
 965     test_server.brecv_triger = true;
 966
 967     while(true){
 968         if(send_data_size == MAX_BUFFER_SIZE){
 969             break;
 970         }
 971         res_size = test_obj.write_some(boost::asio::buffer(send_buff.data() + send_data_size, send_size - send_data_size),ec);
 972         if(!ec){
 973             send_data_size += res_size;
 974             std::cout << send_data_size;
 975             std::cout << " sending data" << std::endl;
 976         }else{
 977             if(ec != boost::asio::error::try_again){
 978                 break;
 979             }
 980         }
 981     }
 982
 983     // unit_test [10] write_some & read_some test size MAX_BUFFER_SIZE write error_code object
 984     std::cout << "[10] write_some & read_some test size MAX_BUFFER_SIZE write error_code object" << std::endl;
 985     BOOST_CHECK(!ec);
 986
 987     // unit_test [11] write_some & read_some test size MAX_BUFFER_SIZE write size
 988     std::cout << "[11] write_some & read_some test size MAX_BUFFER_SIZE write size" << std::endl;
 989     BOOST_CHECK_EQUAL(send_data_size, send_size);
 990
 991
 992     while(true){
 993         if(receve_data_size == MAX_BUFFER_SIZE){
 994             break;
 995         }
 996         res_size = test_obj.read_some(boost::asio::buffer(recv_buff.data() + receve_data_size, MAX_BUFFER_SIZE - receve_data_size),ec);
 997         if(!ec){
 998             receve_data_size += res_size;
 999             std::cout << receve_data_size;
1000             std::cout << " receiving data" << std::endl;
1001         }else{
1002             if(ec != boost::asio::error::try_again){
1003                 break;
1004             }
1005         }
1006     }
1007
1008     // unit_test [12] write_some & read_some test size MAX_BUFFER_SIZE read error_code object
1009     std::cout << "[12] write_some & read_some test size MAX_BUFFER_SIZE read error_code object" << std::endl;
1010     BOOST_CHECK(!ec);
1011
1012     // unit_test [13] write_some & read_some test size MAX_BUFFER_SIZE read size
1013     std::cout << "[13] write_some & read_some test size MAX_BUFFER_SIZE read size" << std::endl;
1014     BOOST_CHECK_EQUAL(receve_data_size, send_size);
1015
1016     // unit_test [14] write_some & read_some test size MAX_BUFFER_SIZE data check
1017     std::cout << "[14] write_some & read_some test size MAX_BUFFER_SIZE data check" << std::endl;
1018     for(int i = 0;i < (int)send_size;i++){
1019         BOOST_CHECK_EQUAL(send_buff[i],recv_buff[i]);
1020         if(send_buff[i] != recv_buff[i]) break;
1021     }
1022
1023     test_obj.test_close(ec);
1024
1025     test_server.breq_close_wait_flag = false;
1026     test_server.bstop_flag = true;
1027     server_thread.join();
1028
1029     BOOST_MESSAGE( "----- write_some & read_some test end -----" );
1030 }
1031
1032 void close_test(){
1033
1034     BOOST_MESSAGE( "----- close test start -----" );
1035
1036     test_mirror_server test_server;
1037
1038     // accept req
1039     test_server.breq_acc_flag = true;
1040     // close wait req
1041     test_server.breq_close_wait_flag = true;
1042
1043     // recv cont
1044     test_server.req_recv_cnt = 1;
1045     test_server.data_size = 1;
1046
1047     // test server start
1048     boost::thread server_thread(boost::bind(&test_mirror_server::run,&test_server));
1049
1050     while( !test_server.brun_flag ){
1051         sleep(1);
1052     }
1053
1054     std::cout << "ready dummy mirror server" << std::endl;
1055
1056
1057
1058     boost::asio::ip::tcp::endpoint connect_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
1059     boost::asio::io_service io;
1060     boost::system::error_code ec;
1061
1062     l7vs::tcp_socket_option_info set_option;
1063     //! TCP_NODELAY   (false:not set,true:set option)
1064     set_option.nodelay_opt = false;
1065     //! TCP_NODELAY option value  (false:off,true:on)
1066     set_option.nodelay_val = false;
1067     //! TCP_CORK      (false:not set,true:set option)
1068     set_option.cork_opt = false;
1069     //! TCP_CORK option value     (false:off,true:on)
1070     set_option.cork_val = false;
1071     //! TCP_QUICKACK  (false:not set,true:set option)
1072     set_option.quickack_opt = false;
1073     //! TCP_QUICKACK option value (false:off,true:on)
1074     set_option.quickack_val = false;
1075
1076     test_socket_class test_obj(io,set_option);
1077     test_obj.connect(connect_end,ec);
1078     BOOST_CHECK(!ec);
1079
1080     while(!test_server.bconnect_flag){
1081         sleep(1);
1082     }
1083
1084     BOOST_CHECK(test_obj.get_open_flag());
1085
1086     BOOST_CHECK(!test_server.bdisconnect_flag);
1087
1088     // unit_test [1] close test close success error_code object
1089     std::cout << "[1] close test close success error_code object" << std::endl;
1090     test_obj.close(ec);
1091     BOOST_CHECK(!ec);
1092
1093     test_server.brecv_triger = true;
1094     sleep(1);
1095
1096     // unit_test [2] close test open_flag set false
1097     std::cout << "[2] close test open_flag set false" << std::endl;
1098     BOOST_CHECK(!test_obj.get_open_flag());
1099
1100     // unit_test [3] close test disconnect check
1101     std::cout << "[3] close test disconnect check" << std::endl;
1102     BOOST_CHECK(test_server.bdisconnect_flag);
1103
1104     test_server.breq_close_wait_flag = false;
1105     test_server.bstop_flag = true;
1106     server_thread.join();
1107     BOOST_MESSAGE( "----- close test end -----" );
1108 }
1109
1110 void get_socket_test(){
1111     BOOST_MESSAGE( "----- get_socket test start -----" );
1112
1113     boost::asio::io_service io;
1114     l7vs::tcp_socket_option_info set_option;
1115     //! TCP_NODELAY   (false:not set,true:set option)
1116     set_option.nodelay_opt = false;
1117     //! TCP_NODELAY option value  (false:off,true:on)
1118     set_option.nodelay_val = false;
1119     //! TCP_CORK      (false:not set,true:set option)
1120     set_option.cork_opt = false;
1121     //! TCP_CORK option value     (false:off,true:on)
1122     set_option.cork_val = false;
1123     //! TCP_QUICKACK  (false:not set,true:set option)
1124     set_option.quickack_opt = false;
1125     //! TCP_QUICKACK option value (false:off,true:on)
1126     set_option.quickack_val = false;
1127
1128     test_socket_class test_obj(io,set_option);
1129
1130     // unit_test [1] get_socket socket check
1131     std::cout << "[1] get_socket socket check" << std::endl;
1132
1133     boost::asio::ip::tcp::socket& chk_socket = test_obj.get_socket();
1134     boost::asio::ip::tcp::socket* pref_pointer = test_obj.get_socket_pointer();
1135
1136     BOOST_CHECK_EQUAL(&chk_socket,pref_pointer);
1137
1138     BOOST_MESSAGE( "----- get_socket test end -----" );
1139 }
1140
1141
1142 class connect_lock_test_class : public l7vs::tcp_socket{
1143     public:
1144         boost::thread::id befor_thread_id;
1145         boost::thread::id after_thread_id;
1146
1147         connect_lock_test_class(boost::asio::io_service& io,const l7vs::tcp_socket_option_info set_option) : l7vs::tcp_socket(io,set_option){
1148         };
1149
1150         ~connect_lock_test_class(){
1151         };
1152
1153         void connect(const boost::asio::ip::tcp::endpoint connect_endpoint,boost::system::error_code& ec){
1154             befor_thread_id = boost::this_thread::get_id();
1155             l7vs::tcp_socket::connect(connect_endpoint,ec);
1156             after_thread_id = boost::this_thread::get_id();
1157
1158         };
1159         void mutex_lock(){
1160             close_mutex.wrlock();
1161         };
1162         void mutex_unlock(){
1163             close_mutex.unlock();
1164         };
1165
1166         boost::mutex test_thread_wait;
1167
1168         void test_run(){
1169             boost::mutex::scoped_lock scope_lock(test_thread_wait);
1170             boost::asio::ip::tcp::endpoint connect_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
1171             boost::system::error_code ec;
1172             connect(connect_end,ec);
1173         };
1174
1175 };
1176
1177
1178
1179 void connect_lock_test(){
1180     BOOST_MESSAGE( "----- connetc lock test start -----" );
1181
1182     boost::asio::io_service io;
1183
1184     l7vs::tcp_socket_option_info set_option;
1185     //! TCP_NODELAY   (false:not set,true:set option)
1186     set_option.nodelay_opt = false;
1187     //! TCP_NODELAY option value  (false:off,true:on)
1188     set_option.nodelay_val = false;
1189     //! TCP_CORK      (false:not set,true:set option)
1190     set_option.cork_opt = false;
1191     //! TCP_CORK option value     (false:off,true:on)
1192     set_option.cork_val = false;
1193     //! TCP_QUICKACK  (false:not set,true:set option)
1194     set_option.quickack_opt = false;
1195     //! TCP_QUICKACK option value (false:off,true:on)
1196     set_option.quickack_val = false;
1197
1198     connect_lock_test_class test_obj(io,set_option);
1199
1200     test_obj.test_thread_wait.lock();
1201     boost::thread::id proc_id = boost::this_thread::get_id();
1202     test_obj.befor_thread_id = proc_id;
1203     test_obj.after_thread_id = proc_id;
1204     test_obj.mutex_lock();
1205
1206     boost::thread test_thread(boost::bind(&connect_lock_test_class::test_run,&test_obj));
1207
1208     BOOST_CHECK(test_obj.befor_thread_id == proc_id);
1209     BOOST_CHECK(test_obj.after_thread_id == proc_id);
1210
1211     boost::thread::id test_id = test_thread.get_id();
1212
1213     BOOST_CHECK(test_id != proc_id);
1214
1215     // test start
1216     test_obj.test_thread_wait.unlock();
1217     sleep(1);
1218
1219     // unit_test [1] connect lock test thread block test (mutex lock)
1220     std::cout << "[1] connect lock test thread block test (mutex lock)" << std::endl;
1221     BOOST_CHECK(test_obj.befor_thread_id == test_id);
1222     BOOST_CHECK(test_obj.after_thread_id == proc_id);
1223
1224     test_obj.mutex_unlock();
1225     sleep(1);
1226
1227     // unit_test [2] connect lock test thread run test (mutex unlock)
1228     std::cout << "[2] connect lock test thread run test (mutex unlock)" << std::endl;
1229     BOOST_CHECK(test_obj.befor_thread_id == test_id);
1230     BOOST_CHECK(test_obj.after_thread_id == test_id);
1231
1232
1233     BOOST_MESSAGE( "----- connetc lock test end -----" );
1234
1235 }
1236
1237 class close_lock_test_class : public l7vs::tcp_socket{
1238     public:
1239         boost::thread::id befor_thread_id;
1240         boost::thread::id after_thread_id;
1241
1242         close_lock_test_class(boost::asio::io_service& io,const l7vs::tcp_socket_option_info set_option) : l7vs::tcp_socket(io,set_option){
1243         };
1244
1245         ~close_lock_test_class(){
1246         };
1247
1248         void close(boost::system::error_code& ec){
1249             befor_thread_id = boost::this_thread::get_id();
1250             l7vs::tcp_socket::close(ec);
1251             after_thread_id = boost::this_thread::get_id();
1252
1253         };
1254         void mutex_lock(){
1255             close_mutex.wrlock();
1256         };
1257         void mutex_unlock(){
1258             close_mutex.unlock();
1259         };
1260
1261         boost::mutex test_thread_wait;
1262
1263         void test_run(){
1264             boost::mutex::scoped_lock scope_lock(test_thread_wait);
1265             boost::system::error_code ec;
1266             close(ec);
1267         };
1268
1269 };
1270
1271
1272 void close_lock_test(){
1273     BOOST_MESSAGE( "----- close lock test start -----" );
1274
1275     boost::asio::io_service io;
1276     l7vs::tcp_socket_option_info set_option;
1277     //! TCP_NODELAY   (false:not set,true:set option)
1278     set_option.nodelay_opt = false;
1279     //! TCP_NODELAY option value  (false:off,true:on)
1280     set_option.nodelay_val = false;
1281     //! TCP_CORK      (false:not set,true:set option)
1282     set_option.cork_opt = false;
1283     //! TCP_CORK option value     (false:off,true:on)
1284     set_option.cork_val = false;
1285     //! TCP_QUICKACK  (false:not set,true:set option)
1286     set_option.quickack_opt = false;
1287     //! TCP_QUICKACK option value (false:off,true:on)
1288     set_option.quickack_val = false;
1289
1290     close_lock_test_class test_obj(io,set_option);
1291
1292     test_obj.test_thread_wait.lock();
1293     boost::thread::id proc_id = boost::this_thread::get_id();
1294     test_obj.befor_thread_id = proc_id;
1295     test_obj.after_thread_id = proc_id;
1296     test_obj.mutex_lock();
1297
1298     boost::thread test_thread(boost::bind(&close_lock_test_class::test_run,&test_obj));
1299
1300     BOOST_CHECK(test_obj.befor_thread_id == proc_id);
1301     BOOST_CHECK(test_obj.after_thread_id == proc_id);
1302
1303     boost::thread::id test_id = test_thread.get_id();
1304
1305     BOOST_CHECK(test_id != proc_id);
1306
1307     // test start
1308     test_obj.test_thread_wait.unlock();
1309     sleep(1);
1310
1311     // unit_test [1] close lock test thread block test (mutex lock)
1312     std::cout << "[1] close lock test thread block test (mutex lock)" << std::endl;
1313     BOOST_CHECK(test_obj.befor_thread_id == test_id);
1314     BOOST_CHECK(test_obj.after_thread_id == proc_id);
1315
1316     test_obj.mutex_unlock();
1317     sleep(1);
1318
1319     // unit_test [2] close lock test thread run test (mutex unlock)
1320     std::cout << "[2] close lock test  thread run test (mutex unlock)" << std::endl;
1321     BOOST_CHECK(test_obj.befor_thread_id == test_id);
1322     BOOST_CHECK(test_obj.after_thread_id == test_id);
1323
1324     BOOST_MESSAGE( "----- close lock test end -----" );
1325
1326 }
1327
1328 void is_open_test(){
1329
1330     BOOST_MESSAGE( "----- is_open test start -----" );
1331
1332     test_mirror_server test_server;
1333
1334     // accept req
1335     test_server.breq_acc_flag = true;
1336     // close wait req
1337     test_server.breq_close_wait_flag = true;
1338
1339     // recv cont
1340     test_server.req_recv_cnt = 1;
1341     test_server.data_size = 1;
1342
1343     // test server start
1344     boost::thread server_thread(boost::bind(&test_mirror_server::run,&test_server));
1345
1346     while( !test_server.brun_flag ){
1347         sleep(1);
1348     }
1349
1350     std::cout << "ready dummy mirror server" << std::endl;
1351
1352
1353
1354     boost::asio::ip::tcp::endpoint connect_end(boost::asio::ip::address::from_string(DUMMI_SERVER_IP), DUMMI_SERVER_PORT);
1355     boost::asio::io_service io;
1356     boost::system::error_code ec;
1357
1358     l7vs::tcp_socket_option_info set_option;
1359     //! TCP_NODELAY   (false:not set,true:set option)
1360     set_option.nodelay_opt = false;
1361     //! TCP_NODELAY option value  (false:off,true:on)
1362     set_option.nodelay_val = false;
1363     //! TCP_CORK      (false:not set,true:set option)
1364     set_option.cork_opt = false;
1365     //! TCP_CORK option value     (false:off,true:on)
1366     set_option.cork_val = false;
1367     //! TCP_QUICKACK  (false:not set,true:set option)
1368     set_option.quickack_opt = false;
1369     //! TCP_QUICKACK option value (false:off,true:on)
1370     set_option.quickack_val = false;
1371
1372     test_socket_class test_obj(io,set_option);
1373
1374     // unit_test [1] is_open before connect check
1375     std::cout << "[1] is_open before connect check" << std::endl;
1376     BOOST_CHECK(!test_obj.is_open());
1377
1378     test_obj.connect(connect_end,ec);
1379     BOOST_CHECK(!ec);
1380
1381     // unit_test [2] is_open after connect check
1382     std::cout << "[2] is_open after connect check" << std::endl;
1383     BOOST_CHECK(test_obj.is_open());
1384
1385     while(!test_server.bconnect_flag){
1386         sleep(1);
1387     }
1388
1389     BOOST_CHECK(test_obj.get_open_flag());
1390
1391     BOOST_CHECK(!test_server.bdisconnect_flag);
1392
1393     test_obj.close(ec);
1394     BOOST_CHECK(!ec);
1395
1396     // unit_test [3] is_open close after check
1397     std::cout << "[3] is_open close after check" << std::endl;
1398     BOOST_CHECK(!test_obj.is_open());
1399
1400     test_server.brecv_triger = true;
1401     sleep(1);
1402
1403     test_server.breq_close_wait_flag = false;
1404     test_server.bstop_flag = true;
1405     server_thread.join();
1406     BOOST_MESSAGE( "----- is_open test end -----" );
1407 }
1408 */