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