l7vsd/unit_tests/l7vsadm_test/l7vsadm_test.cpp

   1 #define    UNIT_TEST
   2
   3 #include <boost/test/included/unit_test.hpp>
   4 #include <boost/algorithm/string.hpp>
   5
   6 //#include "error_code.h"
   7
   8 #include "logger.h"
   9 #include "parameter.h"
  10
  11 #include "protocol_module_stub.h"
  12 #include "schedule_module_stub.h"
  13 #include "protocol_module_control_stub.h"
  14 #include "schedule_module_control_stub.h"
  15 #include "logger_access_manager_stub.h"
  16
  17 #include "../../src/l7vsadm.cpp"
  18
  19 #ifndef    COMMAND_BUFFER_SIZE
  20     #define    COMMAND_BUFFER_SIZE (65535)
  21 #endif
  22 #ifndef    L7VS_CONFIG_SOCKNAME
  23     #define L7VS_CONFIG_SOCKNAME        "./l7vs"
  24 #endif
  25
  26 using namespace boost::unit_test_framework;
  27
  28
  29 // test class
  30 class    l7vsadm_test    :public    l7vs::l7vsadm {
  31 public:
  32
  33     l7vs::l7vsadm_request&        get_request()    { return request; }
  34     l7vs::l7vsd_response&        get_response()    { return response; }
  35
  36     l7vs::error_code&    get_error()    { return l7vsadm_err; }
  37
  38     bool&    get_numeric()    { return numeric_flag; }
  39
  40     bool    parse_list_func_wp( l7vs::l7vsadm_request::COMMAND_CODE_TAG cmd, int argc, char* argv[] )
  41     { return parse_list_func( cmd, argc, argv ); }
  42
  43     bool    parse_opt_vs_target_func_wp( int& pos, int argc, char* argv[] )
  44     { return parse_opt_vs_target_func( pos, argc, argv ); }
  45
  46     bool    parse_opt_vs_module_func_wp( int& pos, int argc, char* argv[] )
  47     { return parse_opt_vs_module_func( pos, argc, argv ); }
  48
  49     bool    parse_opt_vs_scheduler_func_wp( int& pos, int argc, char* argv[] )
  50     { return parse_opt_vs_scheduler_func( pos, argc, argv ); }
  51
  52     bool    parse_opt_vs_upper_func_wp( int& pos, int argc, char* argv[] )
  53     { return parse_opt_vs_upper_func( pos, argc, argv ); }
  54
  55     bool    parse_opt_vs_bypass_func_wp( int& pos, int argc, char* argv[] )
  56     { return parse_opt_vs_bypass_func( pos, argc, argv ); }
  57
  58     bool    parse_opt_vs_flag_func_wp( int& pos, int argc, char* argv[] )
  59     { return parse_opt_vs_flag_func( pos, argc, argv ); }
  60
  61     bool    parse_opt_vs_qosup_func_wp( int& pos, int argc, char* argv[] )
  62     { return parse_opt_vs_qosup_func( pos, argc, argv ); }
  63
  64     bool    parse_opt_vs_qosdown_func_wp( int& pos, int argc, char* argv[] )
  65     { return parse_opt_vs_qosdown_func( pos, argc, argv ); }
  66
  67     bool    parse_opt_vs_udp_func_wp( int& pos, int argc, char* argv[] )
  68     { return parse_opt_vs_udp_func( pos, argc, argv ); }
  69
  70     bool    parse_opt_vs_ssl_file_func_wp( int& pos, int argc, char* argv[] )
  71     { return parse_opt_vs_ssl_file_func( pos, argc, argv ); }
  72
  73     bool    parse_opt_vs_access_log_func_wp( int& pos, int argc, char* argv[] )
  74     { return parse_opt_vs_access_log_func( pos, argc, argv ); }
  75
  76     bool    parse_opt_vs_access_log_logrotate_func_wp( int& pos, int argc, char* argv[] )
  77     { return parse_opt_vs_access_log_logrotate_func( pos, argc, argv ); }
  78
  79     bool    parse_opt_vs_socket_func_wp( int& pos, int argc, char* argv[] )
  80     { return parse_opt_vs_socket_func( pos, argc, argv ); }
  81
  82     bool    parse_vs_func_wp( l7vs::l7vsadm_request::COMMAND_CODE_TAG cmd, int argc, char* argv[] )
  83     { return parse_vs_func( cmd, argc, argv ); }
  84
  85     bool    parse_opt_rs_weight_func_wp( int& pos, int argc, char* argv[] )
  86     { return parse_opt_rs_weight_func( pos, argc, argv ); }
  87
  88     bool    parse_opt_rs_realserver_func_wp( int& pos, int argc, char* argv[] )
  89     { return parse_opt_rs_realserver_func( pos, argc, argv ); }
  90
  91     bool    parse_rs_func_wp( l7vs::l7vsadm_request::COMMAND_CODE_TAG cmd, int argc, char* argv[] )
  92     { return parse_rs_func( cmd, argc, argv ); }
  93
  94     bool    parse_opt_replication_switch_func_wp( int& pos, int argc, char* argv[] )
  95     { return parse_opt_replication_switch_func( pos, argc, argv ); }
  96
  97     bool    parse_opt_replication_force_func_wp( int& pos, int argc, char* argv[] )
  98     { return parse_opt_replication_force_func( pos, argc, argv ); }
  99
 100     bool    parse_opt_replication_dump_func_wp( int& pos, int argc, char* argv[] )
 101     { return parse_opt_replication_dump_func( pos, argc, argv ); }
 102
 103     bool    parse_replication_func_wp( l7vs::l7vsadm_request::COMMAND_CODE_TAG cmd, int argc, char* argv[] )
 104     { return parse_replication_func( cmd, argc, argv ); }
 105
 106     bool    parse_opt_log_category_func_wp( int& pos, int argc, char* argv[] )
 107     { return parse_opt_log_category_func( pos, argc, argv ); }
 108
 109     bool    parse_opt_log_level_func_wp( int& pos, int argc, char* argv[] )
 110     { return parse_opt_log_level_func( pos, argc, argv ); }
 111
 112     bool    parse_log_func_wp( l7vs::l7vsadm_request::COMMAND_CODE_TAG cmd, int argc, char* argv[] )
 113     { return parse_log_func( cmd, argc, argv ); }
 114
 115     bool    parse_opt_snmp_log_category_func_wp( int& pos, int argc, char* argv[] )
 116     { return parse_opt_snmp_log_category_func( pos, argc, argv ); }
 117
 118     bool    parse_opt_snmp_log_level_func_wp( int& pos, int argc, char* argv[] )
 119     { return parse_opt_snmp_log_level_func( pos, argc, argv ); }
 120
 121     bool    parse_snmp_func_wp( l7vs::l7vsadm_request::COMMAND_CODE_TAG cmd, int argc, char* argv[] )
 122     { return parse_snmp_func( cmd, argc, argv ); }
 123
 124     bool    parse_opt_parameter_reload_func_wp( int& pos, int argc, char* argv[] )
 125     { return parse_opt_parameter_reload_func( pos, argc, argv ); }
 126
 127     bool    parse_parameter_func_wp( l7vs::l7vsadm_request::COMMAND_CODE_TAG cmd, int argc, char* argv[] )
 128     { return parse_parameter_func( cmd, argc, argv ); }
 129
 130     bool    execute_wp( int argc, char* argv[] )
 131     { return execute( argc, argv ); }
 132
 133     bool    parse_opt_vs_fwdmode_func_wp( int& pos, int argc, char* argv[] )
 134     { return parse_opt_vs_fwdmode_func( pos, argc, argv ); }
 135
 136     bool    parse_opt_rs_fwdmode_func_wp( int& pos, int argc, char* argv[] )
 137     { return parse_opt_rs_fwdmode_func( pos, argc, argv ); }
 138
 139     static void file_lock_class_test();
 140
 141 };
 142
 143 //variables
 144 //boost::mutex        accept_mutex;
 145 //boost::condition    accept_condition;
 146 volatile    bool    accept_ready;
 147
 148 l7vs::l7vsadm_request        test_request;
 149 l7vs::l7vsd_response        test_response;
 150
 151 //functions
 152 void    server_thread(){
 153     using boost::asio::local::stream_protocol;
 154
 155     boost::array< char,COMMAND_BUFFER_SIZE >    buf;
 156     buf.assign( 0x00 );
 157
 158     // accept
 159     std::cout << "sock:" << L7VS_CONFIG_SOCKNAME << std::endl;
 160     boost::asio::io_service        server_io;
 161     stream_protocol::acceptor    acc(    server_io,
 162                                         stream_protocol::endpoint( L7VS_CONFIG_SOCKNAME ) );
 163     stream_protocol::socket    s( server_io );
 164
 165     // ready to accept
 166     accept_ready = true;
 167     //accept_condition.notify_all();
 168     //std::cout << "accept_ready" << std::endl;
 169
 170     acc.accept( s );
 171     //std::cout << "accepted" << std::endl;
 172
 173     // recv request
 174     s.read_some( boost::asio::buffer( buf ) );
 175     //std::cout << "read_done" << std::endl;
 176
 177     std::stringstream    recv_stream;
 178     recv_stream << &(buf[0]);
 179     boost::archive::text_iarchive    ia( recv_stream );
 180     ia >> test_request;
 181
 182     std::stringstream    send_stream;
 183     boost::archive::text_oarchive    oa( send_stream );
 184     oa << (const l7vs::l7vsd_response&) test_response;
 185
 186     // send response
 187     boost::asio::write( s, boost::asio::buffer( send_stream.str() ) );
 188     //std::cout << "write_done" << std::endl;
 189
 190     s.close();
 191
 192     unlink( L7VS_CONFIG_SOCKNAME );
 193     //std::cout << "unlink" << std::endl;
 194 }
 195
 196 //util
 197 template< typename InternetProtocol >
 198 boost::asio::ip::basic_endpoint< InternetProtocol > string_to_endpoint( std::string str ){
 199     std::string::size_type pos = str.rfind( ":" );
 200     std::string    hostname = str.substr( 0, pos );
 201     std::string    portname = str.substr( pos+1, str.length() );
 202     //remove "[","]"
 203     boost::algorithm::erase_first( hostname, "[" );
 204     boost::algorithm::erase_last( hostname, "]" );
 205
 206     boost::asio::io_service        io_service;
 207     typename InternetProtocol::resolver                resolver(io_service);
 208     typename InternetProtocol::resolver::query        query( hostname, portname );
 209     typename InternetProtocol::resolver::iterator    end;
 210     typename InternetProtocol::resolver::iterator    itr = resolver.resolve( query );
 211     if( itr == end ) return typename InternetProtocol::endpoint();
 212     return *itr;
 213 }
 214
 215 //--tests--
 216 void    parse_list_func_test(){
 217     BOOST_MESSAGE( "----- parse_list_func_test start -----" );
 218
 219     // parse_list_func normal case 1 (no option)
 220     {
 221         l7vsadm_test    adm;
 222         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_LIST;
 223         int        argc    = 2;
 224         char*    argv[]    = { "l7vsadm_test", "-l" };
 225
 226         bool ret = adm.parse_list_func_wp( cmd, argc, argv );
 227
 228         // unit_test[1] parse_list_func normal case 1 (no option) return value check
 229         BOOST_CHECK_EQUAL( ret, true );
 230         // unit_test[2] parse_list_func normal case 1 (no option) request check
 231         BOOST_CHECK_EQUAL( adm.get_request().command, l7vs::l7vsadm_request::CMD_LIST );
 232     }
 233
 234     // parse_list_func normal case 2 (with num option short)
 235     {
 236         l7vsadm_test    adm;
 237         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_LIST;
 238         int        argc    = 3;
 239         char*    argv[]    = { "l7vsadm_test", "-l", "-n" };
 240
 241         bool ret = adm.parse_list_func_wp( cmd, argc, argv );
 242
 243         // unit_test[3] parse_list_func normal case 2 (with num option short) return value check
 244         BOOST_CHECK_EQUAL( ret, true );
 245         // unit_test[4] parse_list_func normal case 2 (with num option short) request check
 246         BOOST_CHECK_EQUAL( adm.get_request().command, l7vs::l7vsadm_request::CMD_LIST );
 247         // unit_test[5] parse_list_func normal case 2 (with num option short) nummeric flag check
 248         BOOST_CHECK_EQUAL( adm.get_numeric(), true );
 249     }
 250
 251     // parse_list_func normal case 3 (with num option long)
 252     {
 253         l7vsadm_test    adm;
 254         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_LIST;
 255         int        argc    = 3;
 256         char*    argv[]    = { "l7vsadm_test", "-l", "--numeric" };
 257
 258         bool ret = adm.parse_list_func_wp( cmd, argc, argv );
 259
 260         // unit_test[6] parse_list_func normal case 3 (with num option long) return value check
 261         BOOST_CHECK_EQUAL( ret, true );
 262         // unit_test[7] parse_list_func normal case 3 (with num option long) request check
 263         BOOST_CHECK_EQUAL( adm.get_request().command, l7vs::l7vsadm_request::CMD_LIST );
 264         // unit_test[8] parse_list_func normal case 3 (with num option long) nummeric flag check
 265         BOOST_CHECK_EQUAL( adm.get_numeric(), true );
 266     }
 267
 268     // parse_list_func error case 1 (invarid option)
 269     {
 270         l7vsadm_test    adm;
 271         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_LIST;
 272         int        argc    = 3;
 273         char*    argv[]    = { "l7vsadm_test", "-l", "-z" };
 274
 275         bool ret = adm.parse_list_func_wp( cmd, argc, argv );
 276
 277         // unit_test[9] parse_list_func error case 1 (invarid option) return value check
 278         BOOST_CHECK_EQUAL( ret, false );
 279     }
 280
 281     BOOST_MESSAGE( "----- parse_list_func_test end -----" );
 282
 283 }
 284
 285 void    parse_opt_vs_target_func_test(){
 286     BOOST_MESSAGE( "----- parse_opt_vs_target_func_test start -----" );
 287
 288     // parse_opt_vs_target_func normal case 1 (tcp endpoint)
 289     {
 290         l7vsadm_test    adm;
 291         int        pos        = 2;
 292         int        argc    = 4;
 293         char*    argv[]    = { "l7vsadm_test", "-A", "-t", "10.144.169.87:22100" };
 294
 295         bool ret = adm.parse_opt_vs_target_func_wp( pos, argc, argv );
 296
 297         // unit_test[10] parse_opt_vs_target_func normal case 1 (tcp endpoint) return value check
 298         BOOST_CHECK_EQUAL( ret, true );
 299         // unit_test[11] parse_opt_vs_target_func normal case 1 (tcp endpoint) endpoint check
 300         boost::asio::ip::tcp::endpoint    ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.87:22100" );
 301         BOOST_CHECK_EQUAL( adm.get_request().vs_element.tcp_accept_endpoint, ep );
 302     }
 303
 304     // parse_opt_vs_target_func normal case 2 (udp endpoint)
 305     {
 306         l7vsadm_test    adm;
 307         int        pos        = 2;
 308         int        argc    = 4;
 309         char*    argv[]    = { "l7vsadm_test", "-A", "-t", "10.144.169.87:22100" };
 310         adm.get_request().vs_element.udpmode = true;
 311
 312         bool ret = adm.parse_opt_vs_target_func_wp( pos, argc, argv );
 313
 314         // unit_test[12] parse_opt_vs_target_func normal case 2 (udp endpoint) return value check
 315         BOOST_CHECK_EQUAL( ret, true );
 316         // unit_test[13] parse_opt_vs_target_func normal case 2 (udp endpoint) endpoint check
 317         boost::asio::ip::udp::endpoint    ep = string_to_endpoint<boost::asio::ip::udp>( "10.144.169.87:22100" );
 318         BOOST_CHECK_EQUAL( adm.get_request().vs_element.udp_recv_endpoint, ep );
 319     }
 320
 321     // parse_opt_vs_target_func normal case 3 (tcp endpoint specified in name)
 322     {
 323         l7vsadm_test    adm;
 324         int        pos        = 2;
 325         int        argc    = 4;
 326         char*    argv[]    = { "l7vsadm_test", "-A", "-t", "127.0.0.1:pop3" };
 327
 328         bool ret = adm.parse_opt_vs_target_func_wp( pos, argc, argv );
 329
 330         // unit_test[14] parse_opt_vs_target_func normal case 3 (tcp endpoint specified in name) return value check
 331         BOOST_CHECK_EQUAL( ret, true );
 332         // unit_test[15] parse_opt_vs_target_func normal case 3 (tcp endpoint specified in name) endpoint check
 333         boost::asio::ip::tcp::endpoint    ep = string_to_endpoint<boost::asio::ip::tcp>( "127.0.0.1:110" );
 334         BOOST_CHECK_EQUAL( adm.get_request().vs_element.tcp_accept_endpoint, ep );
 335     }
 336
 337 // ramiel_ipv6 add
 338     // parse_opt_vs_target_func normal case 4 (any address)
 339     {
 340         l7vsadm_test    adm;
 341         int        pos        = 2;
 342         int        argc    = 4;
 343         char*    argv[]    = { "l7vsadm_test", "-A", "-t", "0.0.0.0:8080" };
 344
 345         bool ret = adm.parse_opt_vs_target_func_wp( pos, argc, argv );
 346
 347         // unit_test[xx] parse_opt_vs_target_func normal case 4 (any address) return value check
 348         BOOST_CHECK_EQUAL( ret, true );
 349         // unit_test[xx] parse_opt_vs_target_func normal case 4 (any address) endpoint check
 350         boost::asio::ip::tcp::endpoint    ep = string_to_endpoint<boost::asio::ip::tcp>( "0.0.0.0:8080" );
 351         BOOST_CHECK_EQUAL( adm.get_request().vs_element.tcp_accept_endpoint, ep );
 352     }
 353
 354 // ramiel_ipv6 add
 355     // parse_opt_vs_target_func normal case 5 (tcp endpoint(ipv6))
 356     {
 357         l7vsadm_test    adm;
 358         int        pos        = 2;
 359         int        argc    = 4;
 360         char*    argv[]    = { "l7vsadm_test", "-A", "-t", "[2001::11]:8080" };
 361
 362         bool ret = adm.parse_opt_vs_target_func_wp( pos, argc, argv );
 363
 364         // unit_test[xx] parse_opt_vs_target_func normal case 4 (tcp endpoint(ipv6)) return value check
 365         BOOST_CHECK_EQUAL( ret, true );
 366         // unit_test[xx] parse_opt_vs_target_func normal case 4 (tcp endpoint(ipv6)) endpoint check
 367         boost::asio::ip::tcp::endpoint    ep = string_to_endpoint<boost::asio::ip::tcp>( "[2001::11]:8080" );
 368         BOOST_CHECK_EQUAL( adm.get_request().vs_element.tcp_accept_endpoint, ep );
 369     }
 370
 371 // ramiel_ipv6 add
 372     // parse_opt_vs_target_func normal case 6 (udp endpoint(ipv6))
 373     {
 374         l7vsadm_test    adm;
 375         int        pos        = 2;
 376         int        argc    = 4;
 377         char*    argv[]    = { "l7vsadm_test", "-A", "-t", "[2001::11]:8080" };
 378         adm.get_request().vs_element.udpmode = true;
 379
 380         bool ret = adm.parse_opt_vs_target_func_wp( pos, argc, argv );
 381
 382         // unit_test[xx] parse_opt_vs_target_func normal case 6 (udp endpoint(ipv6)) return value check
 383         BOOST_CHECK_EQUAL( ret, true );
 384         // unit_test[xx] parse_opt_vs_target_func normal case 6 (udp endpoint(ipv6)) endpoint check
 385         boost::asio::ip::udp::endpoint    ep = string_to_endpoint<boost::asio::ip::udp>( "[2001::11]:8080" );
 386         BOOST_CHECK_EQUAL( adm.get_request().vs_element.udp_recv_endpoint, ep );
 387     }
 388
 389 // ramiel_ipv6 add
 390     // parse_opt_vs_target_func normal case 5 (any address(ipv6))
 391     {
 392         l7vsadm_test    adm;
 393         int        pos        = 2;
 394         int        argc    = 4;
 395         char*    argv[]    = { "l7vsadm_test", "-A", "-t", "[::]:8080" };
 396
 397         bool ret = adm.parse_opt_vs_target_func_wp( pos, argc, argv );
 398
 399         // unit_test[xx] parse_opt_vs_target_func normal case 4 (any address(ipv6)) return value check
 400         BOOST_CHECK_EQUAL( ret, true );
 401         // unit_test[xx] parse_opt_vs_target_func normal case 4 (any address(ipv6)) endpoint check
 402         boost::asio::ip::tcp::endpoint    ep = string_to_endpoint<boost::asio::ip::tcp>( "[::]:8080" );
 403         BOOST_CHECK_EQUAL( adm.get_request().vs_element.tcp_accept_endpoint, ep );
 404     }
 405
 406     // parse_opt_vs_target_func error case 1 (invalid endpoint)
 407     {
 408         l7vsadm_test    adm;
 409         int        pos        = 2;
 410         int        argc    = 4;
 411         char*    argv[]    = { "l7vsadm_test", "-A", "-t", "10.144.169.257:22100" };
 412
 413         bool ret = adm.parse_opt_vs_target_func_wp( pos, argc, argv );
 414
 415         // unit_test[16] parse_opt_vs_target_func error case 1 (invalid endpoint) return value check
 416         BOOST_CHECK_EQUAL( ret, false );
 417     }
 418
 419     // parse_opt_vs_target_func error case 2 (no endpoint)
 420     {
 421         l7vsadm_test    adm;
 422         int        pos        = 2;
 423         int        argc    = 3;
 424         char*    argv[]    = { "l7vsadm_test", "-A", "-t" };
 425
 426         bool ret = adm.parse_opt_vs_target_func_wp( pos, argc, argv );
 427
 428         // unit_test[17] parse_opt_vs_target_func error case 2 (no endpoint) return value check
 429         BOOST_CHECK_EQUAL( ret, false );
 430     }
 431
 432 // ramiel_ipv6 delete
 433 //    // parse_opt_vs_target_func error case 3 (0.0.0.0 address)
 434 //    {
 435 //        l7vsadm_test    adm;
 436 //        int        pos        = 2;
 437 //        int        argc    = 4;
 438 //        char*    argv[]    = { "l7vsadm_test", "-A", "-t", "0.0.0.0:8080" };
 439 //
 440 //        bool ret = adm.parse_opt_vs_target_func_wp( pos, argc, argv );
 441 //
 442 //        // unit_test[18] parse_opt_vs_target_func error case 3 (0.0.0.0 address) return value check
 443 //        BOOST_CHECK_EQUAL( ret, false );
 444 //    }
 445
 446     // parse_opt_vs_target_func error case 4 (0 port)
 447     {
 448         l7vsadm_test    adm;
 449         int        pos        = 2;
 450         int        argc    = 4;
 451         char*    argv[]    = { "l7vsadm_test", "-A", "-t", "10.144.169.87:0" };
 452
 453         bool ret = adm.parse_opt_vs_target_func_wp( pos, argc, argv );
 454
 455         // unit_test[19] parse_opt_vs_target_func error case 4 (0 port) return value check
 456         BOOST_CHECK_EQUAL( ret, false );
 457     }
 458
 459     // parse_opt_vs_target_func error case 5 (invalid port (99999))
 460     {
 461         l7vsadm_test    adm;
 462         int        pos        = 2;
 463         int        argc    = 4;
 464         char*    argv[]    = { "l7vsadm_test", "-A", "-t", "10.144.169.87:99999" };
 465
 466         bool ret = adm.parse_opt_vs_target_func_wp( pos, argc, argv );
 467
 468         // unit_test[20] parse_opt_vs_target_func error case 5 (invalid port (99999)) return value check
 469         BOOST_CHECK_EQUAL( ret, false );
 470     }
 471
 472     // parse_opt_vs_target_func error case 6 (hostname omitted)
 473     {
 474         l7vsadm_test    adm;
 475         int        pos        = 2;
 476         int        argc    = 4;
 477         char*    argv[]    = { "l7vsadm_test", "-A", "-t", ":22100" };
 478
 479         bool ret = adm.parse_opt_vs_target_func_wp( pos, argc, argv );
 480
 481         // unit_test[21] parse_opt_vs_target_func error case 6 (hostname omitted) return value check
 482         BOOST_CHECK_EQUAL( ret, false );
 483     }
 484
 485     // parse_opt_vs_target_func error case 7 (port omitted)
 486     {
 487         l7vsadm_test    adm;
 488         int        pos        = 2;
 489         int        argc    = 4;
 490         char*    argv[]    = { "l7vsadm_test", "-A", "-t", "10.144.169.87:" };
 491
 492         bool ret = adm.parse_opt_vs_target_func_wp( pos, argc, argv );
 493
 494         // unit_test[22] parse_opt_vs_target_func error case 7 (port omitted) return value check
 495         BOOST_CHECK_EQUAL( ret, false );
 496     }
 497
 498     BOOST_MESSAGE( "----- parse_opt_vs_target_func_test end -----" );
 499
 500 }
 501
 502 void    parse_opt_vs_module_func_test(){
 503     BOOST_MESSAGE( "----- parse_opt_vs_module_func_test start -----" );
 504
 505     // parse_opt_vs_module_func normal case 1 (end with module option)
 506     {
 507         l7vsadm_test    adm;
 508         int        pos        = 2;
 509         int        argc    = 5;
 510         char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "option" };
 511         l7vs::protocol_module_control::load_module_fail = false;
 512         l7vs::protocol_module_stub::check_parameter_called = false;
 513         l7vs::protocol_module_stub::check_parameter_fail = false;
 514
 515         bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
 516
 517         // unit_test[23] parse_opt_vs_module_func normal case 1 (end with module option) return value check
 518         BOOST_CHECK_EQUAL( ret, true );
 519         // unit_test[24] parse_opt_vs_module_func normal case 1 (end with module option) check_parameter call check
 520         BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, true );
 521         // unit_test[25] parse_opt_vs_module_func normal case 1 (end with module option) module name check
 522         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
 523         // unit_test[26] parse_opt_vs_module_func normal case 1 (end with module option) module arg check
 524         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "option" );
 525     }
 526
 527     // parse_opt_vs_module_func normal case 2 (end with next vs option)
 528     {
 529         l7vsadm_test    adm;
 530         int        pos        = 2;
 531         int        argc    = 6;
 532         char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "option", "-t" };
 533         l7vs::protocol_module_control::load_module_fail = false;
 534         l7vs::protocol_module_stub::check_parameter_called = false;
 535         l7vs::protocol_module_stub::check_parameter_fail = false;
 536
 537         bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
 538
 539         // unit_test[27] parse_opt_vs_module_func normal case 2 (end with next vs option) return value check
 540         BOOST_CHECK_EQUAL( ret, true );
 541         // unit_test[28] parse_opt_vs_module_func normal case 2 (end with next vs option) check_parameter call check
 542         BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, true );
 543         // unit_test[29] parse_opt_vs_module_func normal case 2 (end with next vs option) module name check
 544         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
 545         // unit_test[30] parse_opt_vs_module_func normal case 2 (end with next vs option) module arg check
 546         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "option" );
 547
 548     }
 549
 550     // parse_opt_vs_module_func normal case 3 (no protocol module arg)
 551     {
 552         l7vsadm_test    adm;
 553         int        pos        = 2;
 554         int        argc    = 5;
 555         char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "-t" };
 556         l7vs::protocol_module_control::load_module_fail = false;
 557         l7vs::protocol_module_stub::check_parameter_called = false;
 558         l7vs::protocol_module_stub::check_parameter_fail = false;
 559
 560         bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
 561
 562         // unit_test[31] parse_opt_vs_module_func normal case 3 (no protocol module arg) return value check
 563         BOOST_CHECK_EQUAL( ret, true );
 564         // unit_test[32] parse_opt_vs_module_func normal case 3 (no protocol module arg) check_parameter call check
 565         BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, true );
 566         // unit_test[33] parse_opt_vs_module_func normal case 3 (no protocol module arg) module name check
 567         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
 568         // unit_test[34] parse_opt_vs_module_func normal case 3 (no protocol module arg) module arg check
 569         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.size(), 0U );
 570
 571     }
 572
 573     // parse_opt_vs_module_func error case 1 (no protocol module name)
 574     {
 575         l7vsadm_test    adm;
 576         int        pos        = 2;
 577         int        argc    = 3;
 578         char*    argv[]    = { "l7vsadm_test", "-A", "-m" };
 579         l7vs::protocol_module_control::load_module_fail = false;
 580         l7vs::protocol_module_stub::check_parameter_called = false;
 581         l7vs::protocol_module_stub::check_parameter_fail = false;
 582
 583         bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
 584
 585         // unit_test[35] parse_opt_vs_module_func error case 1 (no protocol module name) return value check
 586         BOOST_CHECK_EQUAL( ret, false );
 587
 588     }
 589
 590     // parse_opt_vs_module_func error case 2 (protocol module load failed)
 591     {
 592         l7vsadm_test    adm;
 593         int        pos        = 2;
 594         int        argc    = 5;
 595         char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "-t" };
 596         l7vs::protocol_module_control::load_module_fail = true;
 597         l7vs::protocol_module_stub::check_parameter_called = false;
 598         l7vs::protocol_module_stub::check_parameter_fail = false;
 599
 600         bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
 601
 602         // unit_test[36] parse_opt_vs_module_func error case 2 (protocol module load failed) return value check
 603         BOOST_CHECK_EQUAL( ret, false );
 604
 605     }
 606
 607     // parse_opt_vs_module_func error case 3 (check parameter failed)
 608     {
 609         l7vsadm_test    adm;
 610         int        pos        = 2;
 611         int        argc    = 5;
 612         char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "-t" };
 613         l7vs::protocol_module_control::load_module_fail = false;
 614         l7vs::protocol_module_stub::check_parameter_called = false;
 615         l7vs::protocol_module_stub::check_parameter_fail = true;
 616
 617         bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
 618
 619         // unit_test[37] parse_opt_vs_module_func error case 3 (check parameter failed) return value check
 620         BOOST_CHECK_EQUAL( ret, false );
 621         // unit_test[38] parse_opt_vs_module_func error case 3 (check parameter failed) check_parameter call check
 622         BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, true );
 623
 624     }
 625
 626     // parse_opt_vs_module_func error case 4 (protomod name too long)
 627     {
 628         l7vsadm_test    adm;
 629         int        pos        = 2;
 630         int        argc    = 5;
 631         char*    argv[]    = { "l7vsadm_test", "-A", "-m", "protomodnameistoolong", "-t" };
 632         l7vs::protocol_module_control::load_module_fail = false;
 633         l7vs::protocol_module_stub::check_parameter_called = false;
 634         l7vs::protocol_module_stub::check_parameter_fail = false;
 635
 636         bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
 637
 638         // unit_test[39] parse_opt_vs_module_func error case 4 (protomod name too long) return value check
 639         BOOST_CHECK_EQUAL( ret, false );
 640     }
 641
 642     l7vs::protocol_module_control::load_module_fail = false;
 643     l7vs::protocol_module_stub::check_parameter_called = false;
 644     l7vs::protocol_module_stub::check_parameter_fail = false;
 645
 646     BOOST_MESSAGE( "----- parse_opt_vs_module_func_test end -----" );
 647
 648 }
 649
 650 void    parse_opt_vs_scheduler_func_test(){
 651     BOOST_MESSAGE( "----- parse_opt_vs_scheduler_func_test start -----" );
 652
 653     // parse_opt_vs_scheduler_func normal case 1
 654     {
 655         l7vsadm_test    adm;
 656         int        pos        = 2;
 657         int        argc    = 4;
 658         char*    argv[]    = { "l7vsadm_test", "-A", "-s", "rr" };
 659         l7vs::schedule_module_control::load_module_fail = false;
 660
 661         bool ret = adm.parse_opt_vs_scheduler_func_wp( pos, argc, argv );
 662
 663         // unit_test[40] parse_opt_vs_scheduler_func normal case 1 return value check
 664         BOOST_CHECK_EQUAL( ret, true );
 665         // unit_test[41] parse_opt_vs_scheduler_func normal case 1 module name check
 666         BOOST_CHECK_EQUAL( adm.get_request().vs_element.schedule_module_name, "rr" );
 667     }
 668
 669     // parse_opt_vs_scheduler_func error case 1 (no schedule module name)
 670     {
 671         l7vsadm_test    adm;
 672         int        pos        = 2;
 673         int        argc    = 3;
 674         char*    argv[]    = { "l7vsadm_test", "-A", "-s" };
 675         l7vs::schedule_module_control::load_module_fail = false;
 676
 677         bool ret = adm.parse_opt_vs_scheduler_func_wp( pos, argc, argv );
 678
 679         // unit_test[42] parse_opt_vs_scheduler_func error case 1 (no schedule module name) return value check
 680         BOOST_CHECK_EQUAL( ret, false );
 681
 682     }
 683
 684     // parse_opt_vs_scheduler_func error case 2 (schedule module load failed)
 685     {
 686         l7vsadm_test    adm;
 687         int        pos        = 2;
 688         int        argc    = 4;
 689         char*    argv[]    = { "l7vsadm_test", "-A", "-s", "rr" };
 690         l7vs::schedule_module_control::load_module_fail = true;
 691
 692         bool ret = adm.parse_opt_vs_scheduler_func_wp( pos, argc, argv );
 693
 694         // unit_test[43] parse_opt_vs_scheduler_func error case 2 (schedule module load failed) return value check
 695         BOOST_CHECK_EQUAL( ret, false );
 696
 697     }
 698
 699     // parse_opt_vs_scheduler_func error case 3 (schedule module name too long)
 700     {
 701         l7vsadm_test    adm;
 702         int        pos        = 2;
 703         int        argc    = 4;
 704         char*    argv[]    = { "l7vsadm_test", "-A", "-s", "schedulernameistoolong" };
 705         l7vs::schedule_module_control::load_module_fail = false;
 706
 707         bool ret = adm.parse_opt_vs_scheduler_func_wp( pos, argc, argv );
 708
 709         // unit_test[44] parse_opt_vs_scheduler_func error case 3 (schedule module name too long) return value check
 710         BOOST_CHECK_EQUAL( ret, false );
 711     }
 712
 713     l7vs::schedule_module_control::load_module_fail = false;
 714
 715     BOOST_MESSAGE( "----- parse_opt_vs_scheduler_func_test end -----" );
 716
 717 }
 718
 719 void    parse_opt_vs_upper_func_test(){
 720     BOOST_MESSAGE( "----- parse_opt_vs_upper_func_test start -----" );
 721
 722     // parse_opt_vs_upper_func normal case 1
 723     {
 724         l7vsadm_test    adm;
 725         int        pos        = 2;
 726         int        argc    = 4;
 727         char*    argv[]    = { "l7vsadm_test", "-A", "-u", "128" };
 728
 729         bool ret = adm.parse_opt_vs_upper_func_wp( pos, argc, argv );
 730
 731         // unit_test[45] parse_opt_vs_upper_func normal case 1 return value check
 732         BOOST_CHECK_EQUAL( ret, true );
 733         // unit_test[46] parse_opt_vs_upper_func normal case 1 sorry_maxconnection check
 734         BOOST_CHECK_EQUAL( adm.get_request().vs_element.sorry_maxconnection, 128 );
 735     }
 736
 737     // parse_opt_vs_upper_func normal case 2(0 clear)
 738     {
 739         l7vsadm_test    adm;
 740         int        pos        = 2;
 741         int        argc    = 4;
 742         char*    argv[]    = { "l7vsadm_test", "-A", "-u", "0" };
 743
 744         bool ret = adm.parse_opt_vs_upper_func_wp( pos, argc, argv );
 745
 746         // unit_test[47] parse_opt_vs_upper_func normal case 2(0 clear) return value check
 747         BOOST_CHECK_EQUAL( ret, true );
 748         // unit_test[48] parse_opt_vs_upper_func normal case 2(0 clear) sorry_maxconnection check
 749         BOOST_CHECK_EQUAL( adm.get_request().vs_element.sorry_maxconnection, LLONG_MAX );
 750     }
 751
 752     // parse_opt_vs_upper_func error case 1 (invalid maxconnection value (charactor))
 753     {
 754         l7vsadm_test    adm;
 755         int        pos        = 2;
 756         int        argc    = 4;
 757         char*    argv[]    = { "l7vsadm_test", "-A", "-u", "a" };
 758
 759         bool ret = adm.parse_opt_vs_upper_func_wp( pos, argc, argv );
 760
 761         // unit_test[49] parse_opt_vs_upper_func error case 1 (invalid maxconnection value (charactor)) return value check
 762         BOOST_CHECK_EQUAL( ret, false );
 763     }
 764
 765     // parse_opt_vs_upper_func error case 2 (invalid maxconnection value(long long over))
 766     {
 767         l7vsadm_test    adm;
 768         int        pos        = 2;
 769         int        argc    = 4;
 770         std::stringstream    ss;
 771         ss << (1ULL) + LLONG_MAX;
 772         char*    argv[]    = { "l7vsadm_test", "-A", "-u", const_cast<char*>( ss.str().c_str() ) };
 773
 774         bool ret = adm.parse_opt_vs_upper_func_wp( pos, argc, argv );
 775
 776         // unit_test[50] parse_opt_vs_upper_func error case 2 (invalid maxconnection value(long long over)) return value check
 777         BOOST_CHECK_EQUAL( ret, false );
 778     }
 779
 780     // parse_opt_vs_upper_func error case 3 (no maxconnection value)
 781     {
 782         l7vsadm_test    adm;
 783         int        pos        = 2;
 784         int        argc    = 3;
 785         char*    argv[]    = { "l7vsadm_test", "-A", "-u" };
 786
 787         bool ret = adm.parse_opt_vs_upper_func_wp( pos, argc, argv );
 788
 789         // unit_test[51] parse_opt_vs_upper_func error case 3 (no maxconnection value) return value check
 790         BOOST_CHECK_EQUAL( ret, false );
 791     }
 792
 793     // parse_opt_vs_upper_func error case 4 (under 0)
 794     {
 795         l7vsadm_test    adm;
 796         int        pos        = 2;
 797         int        argc    = 4;
 798         char*    argv[]    = { "l7vsadm_test", "-A", "-u", "-1" };
 799
 800         bool ret = adm.parse_opt_vs_upper_func_wp( pos, argc, argv );
 801
 802         // unit_test[52] parse_opt_vs_upper_func error case 4 (under 0) return value check
 803         BOOST_CHECK_EQUAL( ret, false );
 804     }
 805
 806     // parse_opt_vs_upper_func error case 5 (over 100000)
 807     {
 808         l7vsadm_test    adm;
 809         int        pos        = 2;
 810         int        argc    = 4;
 811         char*    argv[]    = { "l7vsadm_test", "-A", "-u", "100001" };
 812
 813         bool ret = adm.parse_opt_vs_upper_func_wp( pos, argc, argv );
 814
 815         // unit_test[53] parse_opt_vs_upper_func error case 5 (over 100000) return value check
 816         BOOST_CHECK_EQUAL( ret, false );
 817     }
 818
 819     BOOST_MESSAGE( "----- parse_opt_vs_upper_func_test end -----" );
 820
 821 }
 822
 823 void    parse_opt_vs_bypass_func_test(){
 824     BOOST_MESSAGE( "----- parse_opt_vs_bypass_func_test start -----" );
 825
 826     // parse_opt_vs_bypass_func normal case 1
 827     {
 828         l7vsadm_test    adm;
 829         int        pos        = 2;
 830         int        argc    = 4;
 831         char*    argv[]    = { "l7vsadm_test", "-A", "-b", "10.144.169.87:8080" };
 832
 833         bool ret = adm.parse_opt_vs_bypass_func_wp( pos, argc, argv );
 834
 835         // unit_test[54] parse_opt_vs_bypass_func normal case 1 return value check
 836         BOOST_CHECK_EQUAL( ret, true );
 837         // unit_test[55] parse_opt_vs_bypass_func normal case 1 sorry_endpoint check
 838         boost::asio::ip::tcp::endpoint    ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.87:8080" );
 839         BOOST_CHECK_EQUAL( adm.get_request().vs_element.sorry_endpoint, ep );
 840     }
 841
 842     // parse_opt_vs_bypass_func normal case 2 (sorryserver_clear)
 843     {
 844         l7vsadm_test    adm;
 845         int        pos        = 2;
 846         int        argc    = 4;
 847         char*    argv[]    = { "l7vsadm_test", "-A", "-b", "0.0.0.0:0" };
 848
 849         bool ret = adm.parse_opt_vs_bypass_func_wp( pos, argc, argv );
 850
 851         // unit_test[56] parse_opt_vs_bypass_func normal case 2 (sorryserver_clear) return value check
 852         BOOST_CHECK_EQUAL( ret, true );
 853         // unit_test[57] parse_opt_vs_bypass_func normal case 2 (sorryserver_clear) sorry_endpoint check
 854         boost::asio::ip::tcp::endpoint    ep = string_to_endpoint<boost::asio::ip::tcp>( "255.255.255.255:0" );
 855         BOOST_CHECK_EQUAL( adm.get_request().vs_element.sorry_endpoint, ep );
 856     }
 857
 858     // parse_opt_vs_bypass_func normal case 3 (sorryserver specified in name)
 859     {
 860         l7vsadm_test    adm;
 861         int        pos        = 2;
 862         int        argc    = 4;
 863         char*    argv[]    = { "l7vsadm_test", "-A", "-b", "127.0.0.1:http" };
 864
 865         bool ret = adm.parse_opt_vs_bypass_func_wp( pos, argc, argv );
 866
 867         // unit_test[58] parse_opt_vs_bypass_func normal case 3 (sorryserver specified in name) return value check
 868         BOOST_CHECK_EQUAL( ret, true );
 869         // unit_test[59] parse_opt_vs_bypass_func normal case 3 (sorryserver specified in name) endpoint check
 870         boost::asio::ip::tcp::endpoint    ep = string_to_endpoint<boost::asio::ip::tcp>( "127.0.0.1:80" );
 871         BOOST_CHECK_EQUAL( adm.get_request().vs_element.sorry_endpoint, ep );
 872     }
 873
 874 //ramiel_ipv6 add
 875     // parse_opt_vs_bypass_func normal case 4 (ipv6)
 876     {
 877         l7vsadm_test    adm;
 878         int        pos        = 2;
 879         int        argc    = 4;
 880         char*    argv[]    = { "l7vsadm_test", "-A", "-b", "[2001::10]:8080" };
 881
 882         bool ret = adm.parse_opt_vs_bypass_func_wp( pos, argc, argv );
 883
 884         // unit_test[xx] parse_opt_vs_bypass_func normal case 4 (ipv6) return value check
 885         BOOST_CHECK_EQUAL( ret, true );
 886         // unit_test[xx] parse_opt_vs_bypass_func normal case 4 (ipv6) sorry_endpoint check
 887         boost::asio::ip::tcp::endpoint    ep = string_to_endpoint<boost::asio::ip::tcp>( "[2001::10]:8080" );
 888         BOOST_CHECK_EQUAL( adm.get_request().vs_element.sorry_endpoint, ep );
 889     }
 890
 891     // parse_opt_vs_bypass_func error case 1 (invalid endpoint)
 892     {
 893         l7vsadm_test    adm;
 894         int        pos        = 2;
 895         int        argc    = 4;
 896         char*    argv[]    = { "l7vsadm_test", "-A", "-b", "10.144.169.257:8080" };
 897
 898         bool ret = adm.parse_opt_vs_bypass_func_wp( pos, argc, argv );
 899
 900         // unit_test[60] parse_opt_vs_bypass_func error case 1 (invalid endpoint) return value check
 901         BOOST_CHECK_EQUAL( ret, false );
 902     }
 903
 904     // parse_opt_vs_bypass_func error case 2 (no endpoint)
 905     {
 906         l7vsadm_test    adm;
 907         int        pos        = 2;
 908         int        argc    = 3;
 909         char*    argv[]    = { "l7vsadm_test", "-A", "-b" };
 910
 911         bool ret = adm.parse_opt_vs_bypass_func_wp( pos, argc, argv );
 912
 913         // unit_test[61] parse_opt_vs_bypass_func error case 2 (no endpoint) return value check
 914         BOOST_CHECK_EQUAL( ret, false );
 915     }
 916
 917     // parse_opt_vs_bypass_func error case 3 (0.0.0.0 address)
 918     {
 919         l7vsadm_test    adm;
 920         int        pos        = 2;
 921         int        argc    = 4;
 922         char*    argv[]    = { "l7vsadm_test", "-A", "-b", "0.0.0.0:8080" };
 923
 924         bool ret = adm.parse_opt_vs_bypass_func_wp( pos, argc, argv );
 925
 926         // unit_test[62] parse_opt_vs_bypass_func error case 3 (0.0.0.0 address) return value check
 927         BOOST_CHECK_EQUAL( ret, false );
 928     }
 929
 930     // parse_opt_vs_bypass_func error case 4 (0 port)
 931     {
 932         l7vsadm_test    adm;
 933         int        pos        = 2;
 934         int        argc    = 4;
 935         char*    argv[]    = { "l7vsadm_test", "-A", "-b", "10.144.169.87:0" };
 936
 937         bool ret = adm.parse_opt_vs_bypass_func_wp( pos, argc, argv );
 938
 939         // unit_test[63] parse_opt_vs_bypass_func error case 4 (0 port) return value check
 940         BOOST_CHECK_EQUAL( ret, false );
 941     }
 942
 943     // parse_opt_vs_bypass_func error case 5 (invalid port (99999))
 944     {
 945         l7vsadm_test    adm;
 946         int        pos        = 2;
 947         int        argc    = 4;
 948         char*    argv[]    = { "l7vsadm_test", "-A", "-b", "10.144.169.87:99999" };
 949
 950         bool ret = adm.parse_opt_vs_bypass_func_wp( pos, argc, argv );
 951
 952         // unit_test[64] parse_opt_vs_bypass_func error case 5 (invalid port (99999)) return value check
 953         BOOST_CHECK_EQUAL( ret, false );
 954     }
 955
 956     // parse_opt_vs_bypass_func error case 6 (hostname omitted)
 957     {
 958         l7vsadm_test    adm;
 959         int        pos        = 2;
 960         int        argc    = 4;
 961         char*    argv[]    = { "l7vsadm_test", "-A", "-b", ":22100" };
 962
 963         bool ret = adm.parse_opt_vs_bypass_func_wp( pos, argc, argv );
 964
 965         // unit_test[65] parse_opt_vs_bypass_func error case 6 (hostname omitted) return value check
 966         BOOST_CHECK_EQUAL( ret, false );
 967     }
 968
 969     // parse_opt_vs_bypass_func error case 7 (port omitted)
 970     {
 971         l7vsadm_test    adm;
 972         int        pos        = 2;
 973         int        argc    = 4;
 974         char*    argv[]    = { "l7vsadm_test", "-A", "-b", "10.144.169.87:" };
 975
 976         bool ret = adm.parse_opt_vs_bypass_func_wp( pos, argc, argv );
 977
 978         // unit_test[66] parse_opt_vs_bypass_func error case 7 (port omitted) return value check
 979         BOOST_CHECK_EQUAL( ret, false );
 980     }
 981
 982 //ramiel_ipv6 add
 983     // parse_opt_vs_bypass_func error case 8 (ipv6 any address)
 984     {
 985         l7vsadm_test    adm;
 986         int        pos        = 2;
 987         int        argc    = 4;
 988         char*    argv[]    = { "l7vsadm_test", "-A", "-b", "[::]:8080" };
 989
 990         bool ret = adm.parse_opt_vs_bypass_func_wp( pos, argc, argv );
 991
 992         // unit_test[xx] parse_opt_vs_bypass_func error case 8 (ipv6 any address) return value check
 993         BOOST_CHECK_EQUAL( ret, false );
 994     }
 995
 996     BOOST_MESSAGE( "----- parse_opt_vs_bypass_func_test end -----" );
 997
 998 }
 999
1000 void    parse_opt_vs_flag_func_test(){
1001     BOOST_MESSAGE( "----- parse_opt_vs_flag_func_test start -----" );
1002
1003     // parse_opt_vs_flag_func normal case 1 (flag on)
1004     {
1005         l7vsadm_test    adm;
1006         int        pos        = 2;
1007         int        argc    = 4;
1008         char*    argv[]    = { "l7vsadm_test", "-A", "-f", "1" };
1009
1010         bool ret = adm.parse_opt_vs_flag_func_wp( pos, argc, argv );
1011
1012         // unit_test[67] parse_opt_vs_flag_func normal case 1 (flag on) return value check
1013         BOOST_CHECK_EQUAL( ret, true );
1014         // unit_test[68] parse_opt_vs_flag_func normal case 1 (flag on) sorry_flag check
1015         BOOST_CHECK_EQUAL( adm.get_request().vs_element.sorry_flag, 1 );
1016     }
1017
1018     // parse_opt_vs_flag_func normal case 2 (flag off)
1019     {
1020         l7vsadm_test    adm;
1021         int        pos        = 2;
1022         int        argc    = 4;
1023         char*    argv[]    = { "l7vsadm_test", "-A", "-f", "0" };
1024
1025         bool ret = adm.parse_opt_vs_flag_func_wp( pos, argc, argv );
1026
1027         // unit_test[69] parse_opt_vs_flag_func normal case 2 (flag off) return value check
1028         BOOST_CHECK_EQUAL( ret, true );
1029         // unit_test[70] parse_opt_vs_flag_func normal case 2 (flag off) sorry_flag check
1030         BOOST_CHECK_EQUAL( adm.get_request().vs_element.sorry_flag, INT_MAX );
1031     }
1032
1033     // parse_opt_vs_flag_func error case 1 (no flag)
1034     {
1035         l7vsadm_test    adm;
1036         int        pos        = 2;
1037         int        argc    = 3;
1038         char*    argv[]    = { "l7vsadm_test", "-A", "-f" };
1039
1040         bool ret = adm.parse_opt_vs_bypass_func_wp( pos, argc, argv );
1041
1042         // unit_test[71] parse_opt_vs_flag_func error case 1 (no flag) return value check
1043         BOOST_CHECK_EQUAL( ret, false );
1044     }
1045
1046     // parse_opt_vs_flag_func error case 2 (1 nor 0)
1047     {
1048         l7vsadm_test    adm;
1049         int        pos        = 2;
1050         int        argc    = 4;
1051         char*    argv[]    = { "l7vsadm_test", "-A", "-f", "2" };
1052
1053         bool ret = adm.parse_opt_vs_bypass_func_wp( pos, argc, argv );
1054
1055         // unit_test[72] parse_opt_vs_flag_func error case 2 (1 nor 0) return value check
1056         BOOST_CHECK_EQUAL( ret, false );
1057     }
1058
1059     // parse_opt_vs_flag_func error case 3 (int over)
1060     {
1061         l7vsadm_test    adm;
1062         int        pos        = 2;
1063         int        argc    = 4;
1064         std::stringstream    ss;
1065         ss << (1ULL) + INT_MAX;
1066         char*    argv[]    = { "l7vsadm_test", "-A", "-f", const_cast<char*>( ss.str().c_str() ) };
1067
1068         bool ret = adm.parse_opt_vs_bypass_func_wp( pos, argc, argv );
1069
1070         // unit_test[73] parse_opt_vs_flag_func error case 3 (int over) return value check
1071         BOOST_CHECK_EQUAL( ret, false );
1072     }
1073
1074     BOOST_MESSAGE( "----- parse_opt_vs_flag_func_test end -----" );
1075
1076 }
1077
1078 void    parse_opt_vs_qosup_func_test(){
1079     BOOST_MESSAGE( "----- parse_opt_vs_qosup_func_test start -----" );
1080
1081     // parse_opt_vs_qosup_func normal case 1 (no unit postfix)
1082     {
1083         l7vsadm_test    adm;
1084         int        pos        = 2;
1085         int        argc    = 4;
1086         char*    argv[]    = { "l7vsadm_test", "-A", "-Q", "128" };
1087
1088         bool ret = adm.parse_opt_vs_qosup_func_wp( pos, argc, argv );
1089
1090         // unit_test[74] parse_opt_vs_qosup_func normal case 1 (no unit postfix) return value check
1091         BOOST_CHECK_EQUAL( ret, true );
1092         // unit_test[75] parse_opt_vs_qosup_func normal case 1 (no unit postfix) qos_upstream check
1093         BOOST_CHECK_EQUAL( adm.get_request().vs_element.qos_upstream, ( 128ULL / 8 ) );
1094     }
1095
1096     // parse_opt_vs_qosup_func normal case 2 (unit postfix 'G')
1097     {
1098         l7vsadm_test    adm;
1099         int        pos        = 2;
1100         int        argc    = 4;
1101         char*    argv[]    = { "l7vsadm_test", "-A", "-Q", "128G" };
1102
1103         bool ret = adm.parse_opt_vs_qosup_func_wp( pos, argc, argv );
1104
1105         // unit_test[76] parse_opt_vs_qosup_func normal case 2 (unit postfix 'G') return value check
1106         BOOST_CHECK_EQUAL( ret, true );
1107         // unit_test[77] parse_opt_vs_qosup_func normal case 2 (unit postfix 'G') qos_upstream check
1108         BOOST_CHECK_EQUAL( adm.get_request().vs_element.qos_upstream, ( 128000000000ULL / 8 ) );
1109     }
1110
1111     // parse_opt_vs_qosup_func normal case 3 (unit postfix 'g')
1112     {
1113         l7vsadm_test    adm;
1114         int        pos        = 2;
1115         int        argc    = 4;
1116         char*    argv[]    = { "l7vsadm_test", "-A", "-Q", "128g" };
1117
1118         bool ret = adm.parse_opt_vs_qosup_func_wp( pos, argc, argv );
1119
1120         // unit_test[78] parse_opt_vs_qosup_func normal case 3 (unit postfix 'g') return value check
1121         BOOST_CHECK_EQUAL( ret, true );
1122         // unit_test[79] parse_opt_vs_qosup_func normal case 3 (unit postfix 'g') qos_upstream check
1123         BOOST_CHECK_EQUAL( adm.get_request().vs_element.qos_upstream, ( 128000000000ULL / 8 ) );
1124     }
1125
1126     // parse_opt_vs_qosup_func normal case 4 (unit postfix 'M')
1127     {
1128         l7vsadm_test    adm;
1129         int        pos        = 2;
1130         int        argc    = 4;
1131         char*    argv[]    = { "l7vsadm_test", "-A", "-Q", "128M" };
1132
1133         bool ret = adm.parse_opt_vs_qosup_func_wp( pos, argc, argv );
1134
1135         // unit_test[80] parse_opt_vs_qosup_func normal case 4 (unit postfix 'M') return value check
1136         BOOST_CHECK_EQUAL( ret, true );
1137         // unit_test[81] parse_opt_vs_qosup_func normal case 4 (unit postfix 'M') qos_upstream check
1138         BOOST_CHECK_EQUAL( adm.get_request().vs_element.qos_upstream, ( 128000000ULL / 8 ) );
1139     }
1140
1141     // parse_opt_vs_qosup_func normal case 5 (unit postfix 'm')
1142     {
1143         l7vsadm_test    adm;
1144         int        pos        = 2;
1145         int        argc    = 4;
1146         char*    argv[]    = { "l7vsadm_test", "-A", "-Q", "128m" };
1147
1148         bool ret = adm.parse_opt_vs_qosup_func_wp( pos, argc, argv );
1149
1150         // unit_test[82] parse_opt_vs_qosup_func normal case 5 (unit postfix 'm') return value check
1151         BOOST_CHECK_EQUAL( ret, true );
1152         // unit_test[83] parse_opt_vs_qosup_func normal case 5 (unit postfix 'm') qos_upstream check
1153         BOOST_CHECK_EQUAL( adm.get_request().vs_element.qos_upstream, ( 128000000ULL / 8 ) );
1154     }
1155
1156     // parse_opt_vs_qosup_func normal case 6 (unit postfix 'K')
1157     {
1158         l7vsadm_test    adm;
1159         int        pos        = 2;
1160         int        argc    = 4;
1161         char*    argv[]    = { "l7vsadm_test", "-A", "-Q", "128K" };
1162
1163         bool ret = adm.parse_opt_vs_qosup_func_wp( pos, argc, argv );
1164
1165         // unit_test[84] parse_opt_vs_qosup_func normal case 6 (unit postfix 'K') return value check
1166         BOOST_CHECK_EQUAL( ret, true );
1167         // unit_test[85] parse_opt_vs_qosup_func normal case 6 (unit postfix 'K') qos_upstream check
1168         BOOST_CHECK_EQUAL( adm.get_request().vs_element.qos_upstream, ( 128000ULL / 8 ) );
1169     }
1170
1171     // parse_opt_vs_qosup_func normal case 7 (unit postfix 'k')
1172     {
1173         l7vsadm_test    adm;
1174         int        pos        = 2;
1175         int        argc    = 4;
1176         char*    argv[]    = { "l7vsadm_test", "-A", "-Q", "128k" };
1177
1178         bool ret = adm.parse_opt_vs_qosup_func_wp( pos, argc, argv );
1179
1180         // unit_test[86] parse_opt_vs_qosup_func normal case 7 (unit postfix 'k') return value check
1181         BOOST_CHECK_EQUAL( ret, true );
1182         // unit_test[87] parse_opt_vs_qosup_func normal case 7 (unit postfix 'k') qos_upstream check
1183         BOOST_CHECK_EQUAL( adm.get_request().vs_element.qos_upstream, ( 128000ULL / 8 ) );
1184     }
1185
1186     // parse_opt_vs_qosup_func error case 1 (invalid qos_upstream value (charactor))
1187     {
1188         l7vsadm_test    adm;
1189         int        pos        = 2;
1190         int        argc    = 4;
1191         char*    argv[]    = { "l7vsadm_test", "-A", "-Q", "a" };
1192
1193         bool ret = adm.parse_opt_vs_qosup_func_wp( pos, argc, argv );
1194
1195         // unit_test[88] parse_opt_vs_qosup_func error case 1 (invalid qos_upstream value (charactor)) return value check
1196         BOOST_CHECK_EQUAL( ret, false );
1197     }
1198
1199     // parse_opt_vs_qosup_func error case 2 (invalid qos_upstream value(unsigned long long over))
1200     {
1201         l7vsadm_test    adm;
1202         int        pos        = 2;
1203         int        argc    = 4;
1204         std::stringstream    ss;
1205         ss << "18446744073709551616";    // ULLONG_MAX is 18446744073709551615
1206         char*    argv[]    = { "l7vsadm_test", "-A", "-Q", const_cast<char*>( ss.str().c_str() ) };
1207
1208         bool ret = adm.parse_opt_vs_qosup_func_wp( pos, argc, argv );
1209
1210         // unit_test[89] parse_opt_vs_qosup_func error case 2 (invalid qos_upstream value(unsigned long long over)) return value check
1211         BOOST_CHECK_EQUAL( ret, false );
1212     }
1213
1214     // parse_opt_vs_qosup_func error case 3 (invalid qos_upstream value(unsigned long long over in postfix 'G'))
1215     {
1216         l7vsadm_test    adm;
1217         int        pos        = 2;
1218         int        argc    = 4;
1219         std::stringstream    ss;
1220         ss << "17179869184G";    // ULLONG_MAX / 1024 / 1024 / 1024
1221         char*    argv[]    = { "l7vsadm_test", "-A", "-Q", const_cast<char*>( ss.str().c_str() ) };
1222
1223         bool ret = adm.parse_opt_vs_qosup_func_wp( pos, argc, argv );
1224
1225         // unit_test[90] parse_opt_vs_qosup_func error case 3 (invalid qos_upstream value(unsigned long long over in postfix 'G')) return value check
1226         BOOST_CHECK_EQUAL( ret, false );
1227     }
1228
1229     // parse_opt_vs_qosup_func error case 4 (invalid qos_upstream value(unsigned long long over in postfix 'M'))
1230     {
1231         l7vsadm_test    adm;
1232         int        pos        = 2;
1233         int        argc    = 4;
1234         std::stringstream    ss;
1235         ss << "17592186044416M";    // ULLONG_MAX / 1024 / 1024
1236         char*    argv[]    = { "l7vsadm_test", "-A", "-Q", const_cast<char*>( ss.str().c_str() ) };
1237
1238         bool ret = adm.parse_opt_vs_qosup_func_wp( pos, argc, argv );
1239
1240         // unit_test[91] parse_opt_vs_qosup_func error case 4 (invalid qos_upstream value(unsigned long long over in postfix 'M')) return value check
1241         BOOST_CHECK_EQUAL( ret, false );
1242     }
1243
1244     // parse_opt_vs_qosup_func error case 5 (invalid qos_upstream value(unsigned long long over in postfix 'K'))
1245     {
1246         l7vsadm_test    adm;
1247         int        pos        = 2;
1248         int        argc    = 4;
1249         std::stringstream    ss;
1250         ss << "18014398509481984K";    // ULLONG_MAX / 1024
1251         char*    argv[]    = { "l7vsadm_test", "-A", "-Q", const_cast<char*>( ss.str().c_str() ) };
1252
1253         bool ret = adm.parse_opt_vs_qosup_func_wp( pos, argc, argv );
1254
1255         // unit_test[92] parse_opt_vs_qosup_func error case 5 (invalid qos_upstream value(unsigned long long over in postfix 'K')) return value check
1256         BOOST_CHECK_EQUAL( ret, false );
1257     }
1258
1259     // parse_opt_vs_qosup_func error case 6 (no qos_upstream value)
1260     {
1261         l7vsadm_test    adm;
1262         int        pos        = 2;
1263         int        argc    = 3;
1264         char*    argv[]    = { "l7vsadm_test", "-A", "-Q" };
1265
1266         bool ret = adm.parse_opt_vs_qosup_func_wp( pos, argc, argv );
1267
1268         // unit_test[93] parse_opt_vs_qosup_func error case 6 (no qos_upstream value) return value check
1269         BOOST_CHECK_EQUAL( ret, false );
1270     }
1271
1272     BOOST_MESSAGE( "----- parse_opt_vs_qosup_func_test end -----" );
1273
1274 }
1275
1276 void    parse_opt_vs_qosdown_func_test(){
1277     BOOST_MESSAGE( "----- parse_opt_vs_qosdown_func_test start -----" );
1278
1279     // parse_opt_vs_qosdown_func normal case 1 (no unit postfix)
1280     {
1281         l7vsadm_test    adm;
1282         int        pos        = 2;
1283         int        argc    = 4;
1284         char*    argv[]    = { "l7vsadm_test", "-A", "-Q", "128" };
1285
1286         bool ret = adm.parse_opt_vs_qosdown_func_wp( pos, argc, argv );
1287
1288         // unit_test[94] parse_opt_vs_qosdown_func normal case 1 (no unit postfix) return value check
1289         BOOST_CHECK_EQUAL( ret, true );
1290         // unit_test[95] parse_opt_vs_qosdown_func normal case 1 (no unit postfix) qos_downstream check
1291         BOOST_CHECK_EQUAL( adm.get_request().vs_element.qos_downstream, ( 128ULL / 8 ) );
1292     }
1293
1294     // parse_opt_vs_qosdown_func normal case 2 (unit postfix 'G')
1295     {
1296         l7vsadm_test    adm;
1297         int        pos        = 2;
1298         int        argc    = 4;
1299         char*    argv[]    = { "l7vsadm_test", "-A", "-Q", "128G" };
1300
1301         bool ret = adm.parse_opt_vs_qosdown_func_wp( pos, argc, argv );
1302
1303         // unit_test[96] parse_opt_vs_qosdown_func normal case 2 (unit postfix 'G') return value check
1304         BOOST_CHECK_EQUAL( ret, true );
1305         // unit_test[97] parse_opt_vs_qosdown_func normal case 2 (unit postfix 'G') qos_downstream check
1306         BOOST_CHECK_EQUAL( adm.get_request().vs_element.qos_downstream, ( 128000000000ULL / 8 ) );
1307     }
1308
1309     // parse_opt_vs_qosdown_func normal case 3 (unit postfix 'g')
1310     {
1311         l7vsadm_test    adm;
1312         int        pos        = 2;
1313         int        argc    = 4;
1314         char*    argv[]    = { "l7vsadm_test", "-A", "-Q", "128g" };
1315
1316         bool ret = adm.parse_opt_vs_qosdown_func_wp( pos, argc, argv );
1317
1318         // unit_test[98] parse_opt_vs_qosdown_func normal case 3 (unit postfix 'g') return value check
1319         BOOST_CHECK_EQUAL( ret, true );
1320         // unit_test[99] parse_opt_vs_qosdown_func normal case 3 (unit postfix 'g') qos_downstream check
1321         BOOST_CHECK_EQUAL( adm.get_request().vs_element.qos_downstream, ( 128000000000ULL / 8 ) );
1322     }
1323
1324     // parse_opt_vs_qosdown_func normal case 4 (unit postfix 'M')
1325     {
1326         l7vsadm_test    adm;
1327         int        pos        = 2;
1328         int        argc    = 4;
1329         char*    argv[]    = { "l7vsadm_test", "-A", "-Q", "128M" };
1330
1331         bool ret = adm.parse_opt_vs_qosdown_func_wp( pos, argc, argv );
1332
1333         // unit_test[100] parse_opt_vs_qosdown_func normal case 4 (unit postfix 'M') return value check
1334         BOOST_CHECK_EQUAL( ret, true );
1335         // unit_test[101] parse_opt_vs_qosdown_func normal case 4 (unit postfix 'M') qos_downstream check
1336         BOOST_CHECK_EQUAL( adm.get_request().vs_element.qos_downstream, ( 128000000ULL / 8 ) );
1337     }
1338
1339     // parse_opt_vs_qosdown_func normal case 5 (unit postfix 'm')
1340     {
1341         l7vsadm_test    adm;
1342         int        pos        = 2;
1343         int        argc    = 4;
1344         char*    argv[]    = { "l7vsadm_test", "-A", "-Q", "128m" };
1345
1346         bool ret = adm.parse_opt_vs_qosdown_func_wp( pos, argc, argv );
1347
1348         // unit_test[102] parse_opt_vs_qosdown_func normal case 5 (unit postfix 'm') return value check
1349         BOOST_CHECK_EQUAL( ret, true );
1350         // unit_test[103] parse_opt_vs_qosdown_func normal case 5 (unit postfix 'm') qos_downstream check
1351         BOOST_CHECK_EQUAL( adm.get_request().vs_element.qos_downstream, ( 128000000ULL / 8 ) );
1352     }
1353
1354     // parse_opt_vs_qosdown_func normal case 6 (unit postfix 'K')
1355     {
1356         l7vsadm_test    adm;
1357         int        pos        = 2;
1358         int        argc    = 4;
1359         char*    argv[]    = { "l7vsadm_test", "-A", "-Q", "128K" };
1360
1361         bool ret = adm.parse_opt_vs_qosdown_func_wp( pos, argc, argv );
1362
1363         // unit_test[104] parse_opt_vs_qosdown_func normal case 6 (unit postfix 'K') return value check
1364         BOOST_CHECK_EQUAL( ret, true );
1365         // unit_test[105] parse_opt_vs_qosdown_func normal case 6 (unit postfix 'K') qos_downstream check
1366         BOOST_CHECK_EQUAL( adm.get_request().vs_element.qos_downstream, ( 128000ULL / 8 ) );
1367     }
1368
1369     // parse_opt_vs_qosdown_func normal case 7 (unit postfix 'k')
1370     {
1371         l7vsadm_test    adm;
1372         int        pos        = 2;
1373         int        argc    = 4;
1374         char*    argv[]    = { "l7vsadm_test", "-A", "-Q", "128k" };
1375
1376         bool ret = adm.parse_opt_vs_qosdown_func_wp( pos, argc, argv );
1377
1378         // unit_test[106] parse_opt_vs_qosdown_func normal case 7 (unit postfix 'k') return value check
1379         BOOST_CHECK_EQUAL( ret, true );
1380         // unit_test[107] parse_opt_vs_qosdown_func normal case 7 (unit postfix 'k') qos_downstream check
1381         BOOST_CHECK_EQUAL( adm.get_request().vs_element.qos_downstream, ( 128000ULL / 8 ) );
1382     }
1383
1384     // parse_opt_vs_qosdown_func error case 1 (invalid qos_downstream value (charactor))
1385     {
1386         l7vsadm_test    adm;
1387         int        pos        = 2;
1388         int        argc    = 4;
1389         char*    argv[]    = { "l7vsadm_test", "-A", "-Q", "a" };
1390
1391         bool ret = adm.parse_opt_vs_qosdown_func_wp( pos, argc, argv );
1392
1393         // unit_test[108] parse_opt_vs_qosdown_func error case 1 (invalid qos_upstream value (charactor)) return value check
1394         BOOST_CHECK_EQUAL( ret, false );
1395     }
1396
1397     // parse_opt_vs_qosdown_func error case 2 (invalid qos_downstream value(unsigned long long over))
1398     {
1399         l7vsadm_test    adm;
1400         int        pos        = 2;
1401         int        argc    = 4;
1402         std::stringstream    ss;
1403         ss << "18446744073709551616";    // ULLONG_MAX is 18446744073709551615
1404         char*    argv[]    = { "l7vsadm_test", "-A", "-Q", const_cast<char*>( ss.str().c_str() ) };
1405
1406         bool ret = adm.parse_opt_vs_qosdown_func_wp( pos, argc, argv );
1407
1408         // unit_test[109] parse_opt_vs_qosdown_func error case 2 (invalid qos_downstream value(unsigned long long over)) return value check
1409         BOOST_CHECK_EQUAL( ret, false );
1410     }
1411
1412     // parse_opt_vs_qosdown_func error case 3 (invalid qos_downstream value(unsigned long long over in postfix 'G'))
1413     {
1414         l7vsadm_test    adm;
1415         int        pos        = 2;
1416         int        argc    = 4;
1417         std::stringstream    ss;
1418         ss << "17179869184G";    // ULLONG_MAX / 1024 / 1024 / 1024
1419         char*    argv[]    = { "l7vsadm_test", "-A", "-Q", const_cast<char*>( ss.str().c_str() ) };
1420
1421         bool ret = adm.parse_opt_vs_qosdown_func_wp( pos, argc, argv );
1422
1423         // unit_test[110] parse_opt_vs_qosdown_func error case 3 (invalid qos_downstream value(unsigned long long over in postfix 'G')) return value check
1424         BOOST_CHECK_EQUAL( ret, false );
1425     }
1426
1427     // parse_opt_vs_qosdown_func error case 4 (invalid qos_downstream value(unsigned long long over in postfix 'M'))
1428     {
1429         l7vsadm_test    adm;
1430         int        pos        = 2;
1431         int        argc    = 4;
1432         std::stringstream    ss;
1433         ss << "17592186044416M";    // ULLONG_MAX / 1024 / 1024
1434         char*    argv[]    = { "l7vsadm_test", "-A", "-Q", const_cast<char*>( ss.str().c_str() ) };
1435
1436         bool ret = adm.parse_opt_vs_qosdown_func_wp( pos, argc, argv );
1437
1438         // unit_test[111] parse_opt_vs_qosdown_func error case 4 (invalid qos_downstream value(unsigned long long over in postfix 'M')) return value check
1439         BOOST_CHECK_EQUAL( ret, false );
1440     }
1441
1442     // parse_opt_vs_qosdown_func error case 5 (invalid qos_downstream value(unsigned long long over in postfix 'K'))
1443     {
1444         l7vsadm_test    adm;
1445         int        pos        = 2;
1446         int        argc    = 4;
1447         std::stringstream    ss;
1448         ss << "18014398509481984K";    // ULLONG_MAX / 1024
1449         char*    argv[]    = { "l7vsadm_test", "-A", "-Q", const_cast<char*>( ss.str().c_str() ) };
1450
1451         bool ret = adm.parse_opt_vs_qosdown_func_wp( pos, argc, argv );
1452
1453         // unit_test[112] parse_opt_vs_qosdown_func error case 5 (invalid qos_downstream value(unsigned long long over in postfix 'K')) return value check
1454         BOOST_CHECK_EQUAL( ret, false );
1455     }
1456
1457     // parse_opt_vs_qosdown_func error case 6 (no qos_upstream value)
1458     {
1459         l7vsadm_test    adm;
1460         int        pos        = 2;
1461         int        argc    = 3;
1462         char*    argv[]    = { "l7vsadm_test", "-A", "-Q" };
1463
1464         bool ret = adm.parse_opt_vs_qosdown_func_wp( pos, argc, argv );
1465
1466         // unit_test[113] parse_opt_vs_qosdown_func error case 6 (no qos_downstream value) return value check
1467         BOOST_CHECK_EQUAL( ret, false );
1468     }
1469
1470     BOOST_MESSAGE( "----- parse_opt_vs_qosdown_func_test end -----" );
1471
1472 }
1473
1474 void    parse_opt_vs_udp_func_test(){
1475     BOOST_MESSAGE( "----- parse_opt_vs_udp_func_test start -----" );
1476
1477     // parse_opt_vs_udp_func normal case 1
1478     {
1479         l7vsadm_test    adm;
1480         int        pos        = 2;
1481         int        argc    = 3;
1482         char*    argv[]    = { "l7vsadm_test", "-A", "-p" };
1483
1484         bool ret = adm.parse_opt_vs_udp_func_wp( pos, argc, argv );
1485
1486         // unit_test[114] parse_opt_vs_udp_func normal case 1 return value check
1487         BOOST_CHECK_EQUAL( ret, true );
1488         // unit_test[115] parse_opt_vs_udp_func normal case 1 udp_mode check
1489         BOOST_CHECK_EQUAL( adm.get_request().vs_element.udpmode, true );
1490     }
1491
1492     // parse_opt_vs_udp_func normal case 2 (already set tcp_endpoint)
1493     {
1494         l7vsadm_test    adm;
1495         int        pos        = 2;
1496         int        argc    = 3;
1497         char*    argv[]    = { "l7vsadm_test", "-A", "-p" };
1498
1499         adm.get_request().vs_element.tcp_accept_endpoint = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.87:22100" );
1500         adm.get_request().vs_element.realserver_vector.push_back( l7vs::realserver_element() );
1501         adm.get_request().vs_element.realserver_vector.front().tcp_endpoint = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.86:80" );
1502
1503         bool ret = adm.parse_opt_vs_udp_func_wp( pos, argc, argv );
1504
1505         // unit_test[116] parse_opt_vs_udp_func normal case 2 (already set tcp_endpoint) return value check
1506         BOOST_CHECK_EQUAL( ret, true );
1507         // unit_test[117] parse_opt_vs_udp_func normal case 2 (already set tcp_endpoint) udp_mode check
1508         BOOST_CHECK_EQUAL( adm.get_request().vs_element.udpmode, true );
1509
1510         // unit_test[118] parse_opt_vs_udp_func normal case 2 (already set tcp_endpoint) tcp_accept_endpoint check
1511         boost::asio::ip::tcp::endpoint    zeropoint;
1512         BOOST_CHECK_EQUAL( adm.get_request().vs_element.tcp_accept_endpoint, zeropoint );
1513
1514         // unit_test[119] parse_opt_vs_udp_func normal case 2 (already set tcp_endpoint) udp_recv_endpoint check
1515         boost::asio::ip::udp::endpoint    udp_recv_ep = string_to_endpoint<boost::asio::ip::udp>( "10.144.169.87:22100" );
1516         BOOST_CHECK_EQUAL( adm.get_request().vs_element.udp_recv_endpoint, udp_recv_ep );
1517
1518         // unit_test[120] parse_opt_vs_udp_func normal case 2 (already set tcp_endpoint) realserver tcp_endpoint check
1519         BOOST_CHECK_EQUAL( adm.get_request().vs_element.realserver_vector.front().tcp_endpoint, zeropoint );
1520
1521         // unit_test[121] parse_opt_vs_udp_func normal case 2 (already set tcp_endpoint) realserver udp_endpoint check
1522         boost::asio::ip::udp::endpoint    rs_udp_ep = string_to_endpoint<boost::asio::ip::udp>( "10.144.169.86:80" );
1523         BOOST_CHECK_EQUAL( adm.get_request().vs_element.realserver_vector.front().udp_endpoint, rs_udp_ep );
1524
1525     }
1526
1527     BOOST_MESSAGE( "----- parse_opt_vs_udp_func_test end -----" );
1528
1529 }
1530
1531 void    parse_opt_vs_ssl_file_func_test(){
1532     BOOST_MESSAGE( "----- parse_opt_vs_ssl_file_func_test start -----" );
1533
1534     // parse_opt_vs_ssl_file_func normal case 1
1535     {
1536         l7vsadm_test    adm;
1537         int     pos         = 2;
1538         int     argc        = 4;
1539         char*   argv[]      = { "l7vsadm_test", "-A", "-z", "./sslfile.cf" };
1540
1541         bool ret = adm.parse_opt_vs_ssl_file_func_wp( pos, argc, argv );
1542
1543         // unit_test[xx] parse_opt_vs_ssl_file_func normal case 1 return value check
1544         BOOST_CHECK_EQUAL( ret, true );
1545         // unit_test[xx] parse_opt_vs_ssl_file_func normal case 1 filename check
1546         BOOST_CHECK_EQUAL( adm.get_request().vs_element.ssl_file_name, "./sslfile.cf" );
1547     }
1548
1549     // pser_opt_vs_ssl_file_func error case 1 (filename not specified)
1550     {
1551         l7vsadm_test    adm;
1552         int     pos         = 2;
1553         int     argc        = 3;
1554         char*   argv[]      = { "l7vsadm_test", "-A", "-z"};
1555
1556         bool ret = adm.parse_opt_vs_ssl_file_func_wp( pos, argc, argv );
1557
1558         // unit_test[xx] parse_opt_vs_ssl_file_func error case 1 return value check
1559         BOOST_CHECK_EQUAL( ret, false );
1560     }
1561
1562     // pser_opt_vs_ssl_file_func error case 2 (filename too long)
1563     {
1564         std::string filename;
1565         filename.resize( L7VS_FILENAME_LEN + 1, 'a' );
1566
1567         l7vsadm_test    adm;
1568         int     pos         = 2;
1569         int     argc        = 4;
1570         char*   argv[]      = { "l7vsadm_test", "-A", "-z", const_cast< char* >( filename.c_str() )  };
1571
1572         bool ret = adm.parse_opt_vs_ssl_file_func_wp( pos, argc, argv );
1573
1574         // unit_test[xx] parse_opt_vs_ssl_file_func error case 2 return value check
1575         BOOST_CHECK_EQUAL( ret, false );
1576     }
1577
1578     // pser_opt_vs_ssl_file_func error case 3 (file cannnot open)
1579     {
1580         l7vsadm_test    adm;
1581         int     pos         = 2;
1582         int     argc        = 4;
1583         char*   argv[]      = { "l7vsadm_test", "-A", "-z", "./test.dat"};
1584
1585         bool ret = adm.parse_opt_vs_ssl_file_func_wp( pos, argc, argv );
1586
1587         // unit_test[xx] parse_opt_vs_ssl_file_func error case 3 return value check
1588         BOOST_CHECK_EQUAL( ret, false );
1589     }
1590
1591     BOOST_MESSAGE( "----- parse_opt_vs_ssl_file_func_test end -----" );
1592
1593 }
1594
1595 void    parse_opt_vs_access_log_func_test(){
1596     BOOST_MESSAGE( "----- parse_opt_vs_access_log_func_test start -----" );
1597
1598     // parse_opt_vs_access_log_func normal case 1
1599     {
1600         l7vsadm_test    adm;
1601         int     pos         = 2;
1602         int     argc        = 4;
1603         char*   argv[]      = { "l7vsadm_test", "-A", "-L", "1" };
1604
1605         bool ret = adm.parse_opt_vs_access_log_func_wp( pos, argc, argv );
1606
1607         // unit_test[xx] parse_opt_vs_access_log_func normal case 1 return value check
1608         BOOST_CHECK_EQUAL( ret, true );
1609         // unit_test[xx] parse_opt_vs_access_log_func normal case 1 filename check
1610         BOOST_CHECK_EQUAL( adm.get_request().vs_element.access_log_flag, 1 );
1611     }
1612
1613     // pser_opt_vs_access_log_func error case 1 (access_log_flag not specified)
1614     {
1615         l7vsadm_test    adm;
1616         int     pos         = 2;
1617         int     argc        = 3;
1618         char*   argv[]      = { "l7vsadm_test", "-A", "-L"};
1619
1620         bool ret = adm.parse_opt_vs_access_log_func_wp( pos, argc, argv );
1621
1622         // unit_test[xx] parse_opt_vs_access_log_func error case 1 return value check
1623         BOOST_CHECK_EQUAL( ret, false );
1624     }
1625
1626     // pser_opt_vs_access_log_func error case 2 (invalid range access log flag value)
1627     {
1628         l7vsadm_test    adm;
1629         int     pos         = 2;
1630         int     argc        = 4;
1631         char*   argv[]      = { "l7vsadm_test", "-A", "-z", "2"};
1632
1633         bool ret = adm.parse_opt_vs_access_log_func_wp( pos, argc, argv );
1634
1635         // unit_test[xx] parse_opt_vs_access_log_func error case 2 return value check
1636         BOOST_CHECK_EQUAL( ret, false );
1637     }
1638
1639     // pser_opt_vs_access_log_func error case 3 (invalied charactor access log flag value)
1640     {
1641         l7vsadm_test    adm;
1642         int     pos         = 2;
1643         int     argc        = 4;
1644         char*   argv[]      = { "l7vsadm_test", "-A", "-z", "a"};
1645
1646         bool ret = adm.parse_opt_vs_access_log_func_wp( pos, argc, argv );
1647
1648         // unit_test[xx] parse_opt_vs_access_log_func error case 3 return value check
1649         BOOST_CHECK_EQUAL( ret, false );
1650     }
1651
1652     BOOST_MESSAGE( "----- parse_opt_vs_access_log_func_test end -----" );
1653
1654 }
1655
1656 void    parse_opt_vs_access_log_logrotate_func_test(){
1657     BOOST_MESSAGE( "----- parse_opt_vs_access_log_logrotate_func_test start -----" );
1658
1659     // parse_opt_vs_access_log_logrotate_func normal case 1 (end with access log rotate option)
1660     {
1661         l7vsadm_test    adm;
1662         int        pos     = 2;
1663         int        argc    = 6;
1664         char*    argv[]    = { "l7vsadm_test", "-A", "-a", "/var/log/l7vs/access.log", "--option", "zzz" };
1665         l7vs::logger_access_manager::access_log_logrotate_parameter_check_called = false;
1666         l7vs::logger_access_manager::access_log_logrotate_parameter_check_fail = false;
1667
1668         bool ret = adm.parse_opt_vs_access_log_logrotate_func_wp( pos, argc, argv );
1669
1670         // unit_test[xx] parse_opt_vs_access_log_logrotate_func normal case 1 return value check
1671         BOOST_CHECK_EQUAL( ret, true );
1672         // unit_test[xx] parse_opt_vs_access_log_logrotate_func normal case 1 check_parameter call check
1673         BOOST_CHECK_EQUAL( l7vs::logger_access_manager::access_log_logrotate_parameter_check_called, true );
1674         // unit_test[xx] parse_opt_vs_access_log_logrotate_func normal case 1 access log file name check
1675         BOOST_CHECK_EQUAL( adm.get_request().vs_element.access_log_file_name, "/var/log/l7vs/access.log" );
1676         // unit_test[xx] parse_opt_vs_access_log_logrotate_func normal case 1 rotate argument check
1677         std::map< std::string, std::string >::iterator it =  adm.get_request().vs_element.access_log_rotate_arguments.find("--option");
1678         BOOST_CHECK( it != adm.get_request().vs_element.access_log_rotate_arguments.end() );
1679         BOOST_CHECK( it->second == "zzz" );
1680         // unit_test[xx] parse_opt_vs_access_log_logrotate_func normal case 1 rotate argument atring check
1681         BOOST_CHECK_EQUAL( adm.get_request().vs_element.access_log_rotate_key_info, "--option zzz" );
1682     }
1683
1684
1685     // parse_opt_vs_access_log_logrotate_func normal case 2 (end with next vs option)
1686     {
1687         l7vsadm_test    adm;
1688         int        pos     = 2;
1689         int        argc    = 7;
1690         char*    argv[]    = { "l7vsadm_test", "-A", "-a", "/var/log/l7vs/access.log", "--option", "zzz", "-t" };
1691         l7vs::logger_access_manager::access_log_logrotate_parameter_check_called = false;
1692         l7vs::logger_access_manager::access_log_logrotate_parameter_check_fail = false;
1693
1694         bool ret = adm.parse_opt_vs_access_log_logrotate_func_wp( pos, argc, argv );
1695
1696         // unit_test[xx] parse_opt_vs_access_log_logrotate_func normal case 2 return value check
1697         BOOST_CHECK_EQUAL( ret, true );
1698         // unit_test[xx] parse_opt_vs_access_log_logrotate_func normal case 2 check_parameter call check
1699         BOOST_CHECK_EQUAL( l7vs::logger_access_manager::access_log_logrotate_parameter_check_called, true );
1700         // unit_test[xx] parse_opt_vs_access_log_logrotate_func normal case 2 access log file name check
1701         BOOST_CHECK_EQUAL( adm.get_request().vs_element.access_log_file_name, "/var/log/l7vs/access.log" );
1702         // unit_test[xx] parse_opt_vs_access_log_logrotate_func normal case 2 rotate argument check
1703         std::map< std::string, std::string >::iterator it =  adm.get_request().vs_element.access_log_rotate_arguments.find("--option");
1704         BOOST_CHECK( it != adm.get_request().vs_element.access_log_rotate_arguments.end() );
1705         BOOST_CHECK( it->second == "zzz" );
1706         // unit_test[xx] parse_opt_vs_access_log_logrotate_func normal case 2 rotate argument atring check
1707         BOOST_CHECK_EQUAL( adm.get_request().vs_element.access_log_rotate_key_info, "--option zzz" );
1708     }
1709
1710     // parse_opt_vs_access_log_logrotate_func normal case 3 (no rotate arg)
1711     {
1712         l7vsadm_test    adm;
1713         int        pos     = 2;
1714         int        argc    = 5;
1715         char*    argv[]    = { "l7vsadm_test", "-A", "-a", "/var/log/l7vs/access.log", "-t" };
1716         l7vs::logger_access_manager::access_log_logrotate_parameter_check_called = false;
1717         l7vs::logger_access_manager::access_log_logrotate_parameter_check_fail = false;
1718
1719         bool ret = adm.parse_opt_vs_access_log_logrotate_func_wp( pos, argc, argv );
1720
1721         // unit_test[xx] parse_opt_vs_access_log_logrotate_func normal case 3 return value check
1722         BOOST_CHECK_EQUAL( ret, true );
1723         // unit_test[xx] parse_opt_vs_access_log_logrotate_func normal case 3 check_parameter call check
1724         BOOST_CHECK_EQUAL( l7vs::logger_access_manager::access_log_logrotate_parameter_check_called, false );
1725         // unit_test[xx] parse_opt_vs_access_log_logrotate_func normal case 3 access log file name check
1726         BOOST_CHECK_EQUAL( adm.get_request().vs_element.access_log_file_name, "/var/log/l7vs/access.log" );
1727         // unit_test[xx] parse_opt_vs_access_log_logrotate_func normal case 3 rotate argument atring check
1728         BOOST_CHECK_EQUAL( adm.get_request().vs_element.access_log_rotate_key_info, "" );
1729     }
1730
1731     // parse_opt_access_log_logrotate_func error case 1 (no access_log_file name)
1732     {
1733         l7vsadm_test    adm;
1734         int        pos     = 2;
1735         int        argc    = 3;
1736         char*    argv[]    = { "l7vsadm_test", "-A", "-a" };
1737         l7vs::logger_access_manager::access_log_logrotate_parameter_check_called = false;
1738         l7vs::logger_access_manager::access_log_logrotate_parameter_check_fail = false;
1739
1740         bool ret = adm.parse_opt_vs_access_log_logrotate_func_wp( pos, argc, argv );
1741
1742         // unit_test[xx] parse_opt_vs_access_log_logrotate_func error case 1 return value check
1743         BOOST_CHECK_EQUAL( ret, false );
1744
1745     }
1746
1747     // parse_opt_access_log_logrotate_func error case 2 (access_log_file name too long)
1748     {
1749         std::string filename;
1750         filename.resize( L7VS_FILENAME_LEN, 'a');
1751         filename = "/" + filename;
1752
1753         l7vsadm_test    adm;
1754         int        pos     = 2;
1755         int        argc    = 4;
1756         char*    argv[]    = { "l7vsadm_test", "-A", "-a", const_cast< char* >( filename.c_str() ) };
1757         l7vs::logger_access_manager::access_log_logrotate_parameter_check_called = false;
1758         l7vs::logger_access_manager::access_log_logrotate_parameter_check_fail = false;
1759
1760         bool ret = adm.parse_opt_vs_access_log_logrotate_func_wp( pos, argc, argv );
1761
1762         // unit_test[xx] parse_opt_vs_access_log_logrotate_func error case 2 return value check
1763         BOOST_CHECK_EQUAL( ret, false );
1764     }
1765
1766     // parse_opt_access_log_logrotate_func error case 3 (access_log_file name not fullpath)
1767     {
1768         l7vsadm_test    adm;
1769         int        pos     = 2;
1770         int        argc    = 4;
1771         char*    argv[]    = { "l7vsadm_test", "-A", "-a", "access.log" };
1772         l7vs::logger_access_manager::access_log_logrotate_parameter_check_called = false;
1773         l7vs::logger_access_manager::access_log_logrotate_parameter_check_fail = false;
1774
1775         bool ret = adm.parse_opt_vs_access_log_logrotate_func_wp( pos, argc, argv );
1776
1777         // unit_test[xx] parse_opt_vs_access_log_logrotate_func error case 3 return value check
1778         BOOST_CHECK_EQUAL( ret, false );
1779     }
1780
1781     // parse_opt_access_log_logrotate_func error case 4 (rotate argument check error)
1782     {
1783         l7vsadm_test    adm;
1784         int        pos     = 2;
1785         int        argc    = 6;
1786         char*    argv[]    = { "l7vsadm_test", "-A", "-a", "/var/log/l7vs/access.log", "--option", "zzz" };
1787         l7vs::logger_access_manager::access_log_logrotate_parameter_check_called = false;
1788         l7vs::logger_access_manager::access_log_logrotate_parameter_check_fail = true;
1789
1790         bool ret = adm.parse_opt_vs_access_log_logrotate_func_wp( pos, argc, argv );
1791
1792         // unit_test[xx] parse_opt_vs_access_log_logrotate_func error case 4 return value check
1793         BOOST_CHECK_EQUAL( ret, false );
1794     }
1795
1796     // parse_opt_access_log_logrotate_func error case 5 (rotate argument is not pair)
1797     {
1798         l7vsadm_test    adm;
1799         int        pos     = 2;
1800         int        argc    = 5;
1801         char*    argv[]    = { "l7vsadm_test", "-A", "-a", "/var/log/l7vs/access.log", "--option" };
1802         l7vs::logger_access_manager::access_log_logrotate_parameter_check_called = false;
1803         l7vs::logger_access_manager::access_log_logrotate_parameter_check_fail = false;
1804
1805         bool ret = adm.parse_opt_vs_access_log_logrotate_func_wp( pos, argc, argv );
1806
1807         // unit_test[xx] parse_opt_vs_access_log_logrotate_func error case 5 return value check
1808         BOOST_CHECK_EQUAL( ret, false );
1809     }
1810
1811     // parse_opt_access_log_logrotate_func error case 6 (rotate argument is duplicated)
1812     {
1813         l7vsadm_test    adm;
1814         int        pos     = 2;
1815         int        argc    = 8;
1816         char*    argv[]    = { "l7vsadm_test", "-A", "-a", "/var/log/l7vs/access.log", "--option", "zzz", "--option", "xxx" };
1817         l7vs::logger_access_manager::access_log_logrotate_parameter_check_called = false;
1818         l7vs::logger_access_manager::access_log_logrotate_parameter_check_fail = false;
1819
1820         bool ret = adm.parse_opt_vs_access_log_logrotate_func_wp( pos, argc, argv );
1821
1822         // unit_test[xx] parse_opt_vs_access_log_logrotate_func error case 6 return value check
1823         BOOST_CHECK_EQUAL( ret, false );
1824     }
1825
1826     BOOST_MESSAGE( "----- parse_opt_vs_access_log_logrotate_func_test end -----" );
1827
1828 }
1829
1830 void    parse_opt_vs_socket_func_test(){
1831     BOOST_MESSAGE( "----- parse_opt_vs_socket_func_test start -----" );
1832
1833     // parse_opt_vs_socket_func normal case 1
1834     {
1835         l7vsadm_test    adm;
1836         int     pos         = 2;
1837         int     argc        = 4;
1838         char*   argv[]      = { "l7vsadm_test", "-A", "-O", "deferaccept,nodelay,cork,quickackoff" };
1839
1840         bool ret = adm.parse_opt_vs_socket_func_wp( pos, argc, argv );
1841
1842         // unit_test[xx] parse_opt_vs_socket_func normal case 1 return value check
1843         BOOST_CHECK_EQUAL( ret, true );
1844         // unit_test[xx] parse_opt_vs_socket_func normal case 1 option check
1845         BOOST_CHECK_EQUAL( adm.get_request().vs_element.socket_option_tcp_defer_accept, 1 );
1846         BOOST_CHECK_EQUAL( adm.get_request().vs_element.socket_option_tcp_nodelay, 1 );
1847         BOOST_CHECK_EQUAL( adm.get_request().vs_element.socket_option_tcp_cork, 1 );
1848         BOOST_CHECK_EQUAL( adm.get_request().vs_element.socket_option_tcp_quickack, 2 );
1849         BOOST_CHECK_EQUAL( adm.get_request().vs_element.socket_option_string, "deferaccept,nodelay,cork,quickackoff" );
1850     }
1851
1852     // parse_opt_vs_socket_func normal case 2
1853     {
1854         l7vsadm_test    adm;
1855         int     pos         = 2;
1856         int     argc        = 4;
1857         char*   argv[]      = { "l7vsadm_test", "-A", "-O", "nodelay" };
1858
1859         bool ret = adm.parse_opt_vs_socket_func_wp( pos, argc, argv );
1860
1861         // unit_test[xx] parse_opt_vs_socket_func normal case 3 return value check
1862         BOOST_CHECK_EQUAL( ret, true );
1863         // unit_test[xx] parse_opt_vs_socket_func normal case 3 option check
1864         BOOST_CHECK_EQUAL( adm.get_request().vs_element.socket_option_tcp_defer_accept, 0 );
1865         BOOST_CHECK_EQUAL( adm.get_request().vs_element.socket_option_tcp_nodelay, 1 );
1866         BOOST_CHECK_EQUAL( adm.get_request().vs_element.socket_option_tcp_cork, 0 );
1867         BOOST_CHECK_EQUAL( adm.get_request().vs_element.socket_option_tcp_quickack, 0 );
1868         BOOST_CHECK_EQUAL( adm.get_request().vs_element.socket_option_string, "nodelay" );
1869     }
1870
1871     // parse_opt_vs_socket_func normal case 3
1872     {
1873         l7vsadm_test    adm;
1874         int     pos         = 2;
1875         int     argc        = 4;
1876         char*   argv[]      = { "l7vsadm_test", "-A", "-O", "deferaccept,quickackon" };
1877
1878         bool ret = adm.parse_opt_vs_socket_func_wp( pos, argc, argv );
1879
1880         // unit_test[xx] parse_opt_vs_socket_func normal case 3 return value check
1881         BOOST_CHECK_EQUAL( ret, true );
1882         // unit_test[xx] parse_opt_vs_socket_func normal case 3 option check
1883         BOOST_CHECK_EQUAL( adm.get_request().vs_element.socket_option_tcp_defer_accept, 1 );
1884         BOOST_CHECK_EQUAL( adm.get_request().vs_element.socket_option_tcp_nodelay, 0 );
1885         BOOST_CHECK_EQUAL( adm.get_request().vs_element.socket_option_tcp_cork, 0 );
1886         BOOST_CHECK_EQUAL( adm.get_request().vs_element.socket_option_tcp_quickack, 1 );
1887         BOOST_CHECK_EQUAL( adm.get_request().vs_element.socket_option_string, "deferaccept,quickackon" );
1888     }
1889
1890     // pser_opt_vs_socket_func error case 1 (socket option not specified)
1891     {
1892         l7vsadm_test    adm;
1893         int     pos         = 2;
1894         int     argc        = 3;
1895         char*   argv[]      = { "l7vsadm_test", "-A", "-O"};
1896
1897         bool ret = adm.parse_opt_vs_socket_func_wp( pos, argc, argv );
1898
1899         // unit_test[xx] parse_opt_vs_socket_func error case 1 return value check
1900         BOOST_CHECK_EQUAL( ret, false );
1901     }
1902
1903     // pser_opt_vs_socket_func error case 2 (unknown socket option)
1904     {
1905         l7vsadm_test    adm;
1906         int     pos         = 2;
1907         int     argc        = 4;
1908         char*   argv[]      = { "l7vsadm_test", "-A", "-O", "deferaccept,nodelay,cork,quickackoff,zzz" };
1909
1910         bool ret = adm.parse_opt_vs_socket_func_wp( pos, argc, argv );
1911
1912         // unit_test[xx] parse_opt_vs_socket_func error case 2 return value check
1913         BOOST_CHECK_EQUAL( ret, false );
1914     }
1915
1916     // pser_opt_vs_socket_func error case 3 (deferaccept duplicated)
1917     {
1918         l7vsadm_test    adm;
1919         int     pos         = 2;
1920         int     argc        = 4;
1921         char*   argv[]      = { "l7vsadm_test", "-A", "-O", "deferaccept,nodelay,cork,quickackoff,deferaccept" };
1922
1923         bool ret = adm.parse_opt_vs_socket_func_wp( pos, argc, argv );
1924
1925         // unit_test[xx] parse_opt_vs_socket_func error case 3 return value check
1926         BOOST_CHECK_EQUAL( ret, false );
1927     }
1928
1929     // pser_opt_vs_socket_func error case 4 (nodelay duplicated)
1930     {
1931         l7vsadm_test    adm;
1932         int     pos         = 2;
1933         int     argc        = 4;
1934         char*   argv[]      = { "l7vsadm_test", "-A", "-O", "deferaccept,nodelay,cork,quickackoff,nodelay" };
1935
1936         bool ret = adm.parse_opt_vs_socket_func_wp( pos, argc, argv );
1937
1938         // unit_test[xx] parse_opt_vs_socket_func error case 4 return value check
1939         BOOST_CHECK_EQUAL( ret, false );
1940     }
1941
1942     // pser_opt_vs_socket_func error case 5 (cork duplicated)
1943     {
1944         l7vsadm_test    adm;
1945         int     pos         = 2;
1946         int     argc        = 4;
1947         char*   argv[]      = { "l7vsadm_test", "-A", "-O", "deferaccept,nodelay,cork,quickackoff,cork" };
1948
1949         bool ret = adm.parse_opt_vs_socket_func_wp( pos, argc, argv );
1950
1951         // unit_test[xx] parse_opt_vs_socket_func error case 5 return value check
1952         BOOST_CHECK_EQUAL( ret, false );
1953     }
1954
1955     // pser_opt_vs_socket_func error case 6 (quickack duplicated 1)
1956     {
1957         l7vsadm_test    adm;
1958         int     pos         = 2;
1959         int     argc        = 4;
1960         char*   argv[]      = { "l7vsadm_test", "-A", "-O", "deferaccept,nodelay,cork,quickackoff,quickackoff" };
1961
1962         bool ret = adm.parse_opt_vs_socket_func_wp( pos, argc, argv );
1963
1964         // unit_test[xx] parse_opt_vs_socket_func error case 6 return value check
1965         BOOST_CHECK_EQUAL( ret, false );
1966     }
1967
1968     // pser_opt_vs_socket_func error case 7 (quickack duplicated 2)
1969     {
1970         l7vsadm_test    adm;
1971         int     pos         = 2;
1972         int     argc        = 4;
1973         char*   argv[]      = { "l7vsadm_test", "-A", "-O", "deferaccept,nodelay,cork,quickackoff,quickackon" };
1974
1975         bool ret = adm.parse_opt_vs_socket_func_wp( pos, argc, argv );
1976
1977         // unit_test[xx] parse_opt_vs_socket_func error case 7 return value check
1978         BOOST_CHECK_EQUAL( ret, false );
1979     }
1980
1981     BOOST_MESSAGE( "----- parse_opt_vs_socket_func_test end -----" );
1982
1983 }
1984
1985 void    parse_vs_func_test(){
1986     BOOST_MESSAGE( "----- parse_vs_func_test start -----" );
1987
1988     // parse_vs_func normal case 1 (CMD_ADD_VS short_option)
1989     {
1990         l7vsadm_test    adm;
1991         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_ADD_VS;
1992         int        argc    = 17;
1993         char*    argv[]    = {    "l7vsadm_test",
1994                             "-A",
1995                             "-t",
1996                             "10.144.169.87:22100",
1997                             "-m",
1998                             "cinsert",
1999                             "mod_arg",
2000                             "-s",
2001                             "lc",
2002                             "-u",
2003                             "50",
2004                             "-b",
2005                             "10.144.169.86:8080",
2006                             "-Q",
2007                             "100M",
2008                             "-q",
2009                             "200M"
2010                             };
2011
2012         bool ret = adm.parse_vs_func_wp( cmd, argc, argv );
2013
2014         // unit_test[122] parse_vs_func normal case 1 (CMD_ADD_VS short_option) return value check
2015         BOOST_CHECK_EQUAL( ret, true );
2016         // unit_test[123] parse_vs_func normal case 1 (CMD_ADD_VS short_option) request check
2017         BOOST_CHECK_EQUAL( adm.get_request().command, l7vs::l7vsadm_request::CMD_ADD_VS );
2018         // unit_test[124] parse_vs_func normal case 1 (CMD_ADD_VS short_option) tcp_accept_endpoint check
2019         boost::asio::ip::tcp::endpoint    tcp_acc_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.87:22100" );
2020         BOOST_CHECK_EQUAL( adm.get_request().vs_element.tcp_accept_endpoint, tcp_acc_ep );
2021         // unit_test[125] parse_vs_func normal case 1 (CMD_ADD_VS short_option) protocol module name check
2022         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
2023         // unit_test[126] parse_vs_func normal case 1 (CMD_ADD_VS short_option) protocol module arg check
2024         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "mod_arg" );
2025         // unit_test[127] parse_vs_func normal case 1 (CMD_ADD_VS short_option) schedule module name check
2026         BOOST_CHECK_EQUAL( adm.get_request().vs_element.schedule_module_name, "lc" );
2027         // unit_test[128] parse_vs_func normal case 1 (CMD_ADD_VS short_option) sorry_maxconnection check
2028         BOOST_CHECK_EQUAL( adm.get_request().vs_element.sorry_maxconnection, 50 );
2029         // unit_test[129] parse_vs_func normal case 1 (CMD_ADD_VS short_option) sorry_endpoint check
2030         boost::asio::ip::tcp::endpoint    sorry_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.86:8080" );
2031         BOOST_CHECK_EQUAL( adm.get_request().vs_element.sorry_endpoint, sorry_ep );
2032         // unit_test[130] parse_vs_func normal case 1 (CMD_ADD_VS short_option) qos_upstream check
2033         BOOST_CHECK_EQUAL( adm.get_request().vs_element.qos_upstream, ( 100000000ULL / 8 ) );
2034         // unit_test[131] parse_vs_func normal case 1 (CMD_ADD_VS short_option) qos_downstream check
2035         BOOST_CHECK_EQUAL( adm.get_request().vs_element.qos_downstream, ( 200000000ULL / 8 ) );
2036     }
2037
2038     // parse_vs_func normal case 2 (CMD_ADD_VS long_option)
2039     {
2040         l7vsadm_test    adm;
2041         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_ADD_VS;
2042         int        argc    = 17;
2043         char*    argv[]    = {    "l7vsadm_test",
2044                             "--add-service",
2045                             "--tcp-service",
2046                             "10.144.169.86:11500",
2047                             "--proto-module",
2048                             "cinsert",
2049                             "mod_arg",
2050                             "--scheduler",
2051                             "wrr",
2052                             "--upper",
2053                             "96",
2054                             "--bypass",
2055                             "10.144.169.87:80",
2056                             "--qos-up",
2057                             "100M",
2058                             "--qos-down",
2059                             "200M"
2060                             };
2061
2062         bool ret = adm.parse_vs_func_wp( cmd, argc, argv );
2063
2064         // unit_test[132] parse_vs_func normal case 2 (CMD_ADD_VS long_option) return value check
2065         BOOST_CHECK_EQUAL( ret, true );
2066         // unit_test[133] parse_vs_func normal case 2 (CMD_ADD_VS long_option) request check
2067         BOOST_CHECK_EQUAL( adm.get_request().command, l7vs::l7vsadm_request::CMD_ADD_VS );
2068         // unit_test[134] parse_vs_func normal case 2 (CMD_ADD_VS long_option) tcp_accept_endpoint check
2069         boost::asio::ip::tcp::endpoint    tcp_acc_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.86:11500" );
2070         BOOST_CHECK_EQUAL( adm.get_request().vs_element.tcp_accept_endpoint, tcp_acc_ep );
2071         // unit_test[135] parse_vs_func normal case 2 (CMD_ADD_VS long_option) protocol module name check
2072         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
2073         // unit_test[136] parse_vs_func normal case 2 (CMD_ADD_VS long_option) protocol module arg check
2074         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "mod_arg" );
2075         // unit_test[137] parse_vs_func normal case 2 (CMD_ADD_VS long_option) schedule module name check
2076         BOOST_CHECK_EQUAL( adm.get_request().vs_element.schedule_module_name, "wrr" );
2077         // unit_test[138] parse_vs_func normal case 2 (CMD_ADD_VS long_option) sorry_maxconnection check
2078         BOOST_CHECK_EQUAL( adm.get_request().vs_element.sorry_maxconnection, 96 );
2079         // unit_test[139] parse_vs_func normal case 2 (CMD_ADD_VS long_option) sorry_endpoint check
2080         boost::asio::ip::tcp::endpoint    sorry_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.87:80" );
2081         BOOST_CHECK_EQUAL( adm.get_request().vs_element.sorry_endpoint, sorry_ep );
2082         // unit_test[140] parse_vs_func normal case 2 (CMD_ADD_VS long_option) qos_upstream check
2083         BOOST_CHECK_EQUAL( adm.get_request().vs_element.qos_upstream, ( 100000000ULL / 8 ) );
2084         // unit_test[141] parse_vs_func normal case 2 (CMD_ADD_VS long_option) qos_downstream check
2085         BOOST_CHECK_EQUAL( adm.get_request().vs_element.qos_downstream, ( 200000000ULL / 8 ) );
2086     }
2087
2088     // parse_vs_func normal case 3 (CMD_EDIT_VS short_option)
2089     {
2090         l7vsadm_test    adm;
2091         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_EDIT_VS;
2092         int        argc    = 19;
2093         char*    argv[]    = {    "l7vsadm_test",
2094                             "-E",
2095                             "-t",
2096                             "10.144.169.87:22100",
2097                             "-m",
2098                             "cinsert",
2099                             "mod_arg",
2100                             "-s",
2101                             "rr",
2102                             "-u",
2103                             "50",
2104                             "-b",
2105                             "10.144.169.86:8080",
2106                             "-f",
2107                             "1",
2108                             "-Q",
2109                             "100M",
2110                             "-q",
2111                             "200M"
2112                             };
2113
2114         bool ret = adm.parse_vs_func_wp( cmd, argc, argv );
2115
2116         // unit_test[142] parse_vs_func normal case 3 (CMD_EDIT_VS short_option) return value check
2117         BOOST_CHECK_EQUAL( ret, true );
2118         // unit_test[143] parse_vs_func normal case 3 (CMD_EDIT_VS short_option) request check
2119         BOOST_CHECK_EQUAL( adm.get_request().command, l7vs::l7vsadm_request::CMD_EDIT_VS );
2120         // unit_test[144] parse_vs_func normal case 3 (CMD_EDIT_VS short_option) tcp_accept_endpoint check
2121         boost::asio::ip::tcp::endpoint    tcp_acc_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.87:22100" );
2122         BOOST_CHECK_EQUAL( adm.get_request().vs_element.tcp_accept_endpoint, tcp_acc_ep );
2123         // unit_test[145] parse_vs_func normal case 3 (CMD_EDIT_VS short_option) protocol module name check
2124         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
2125         // unit_test[146] parse_vs_func normal case 3 (CMD_EDIT_VS short_option) protocol module arg check
2126         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "mod_arg" );
2127         // unit_test[147] parse_vs_func normal case 3 (CMD_EDIT_VS short_option) schedule module name check
2128         BOOST_CHECK_EQUAL( adm.get_request().vs_element.schedule_module_name, "rr" );
2129         // unit_test[148] parse_vs_func normal case 3 (CMD_EDIT_VS short_option) sorry_maxconnection check
2130         BOOST_CHECK_EQUAL( adm.get_request().vs_element.sorry_maxconnection, 50 );
2131         // unit_test[149] parse_vs_func normal case 3 (CMD_EDIT_VS short_option) sorry_endpoint check
2132         boost::asio::ip::tcp::endpoint    sorry_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.86:8080" );
2133         BOOST_CHECK_EQUAL( adm.get_request().vs_element.sorry_endpoint, sorry_ep );
2134         // unit_test[150] parse_vs_func normal case 3 (CMD_EDIT_VS short_option) sorry_flag check
2135         BOOST_CHECK_EQUAL( adm.get_request().vs_element.sorry_flag, true );
2136         // unit_test[151] parse_vs_func normal case 3 (CMD_EDIT_VS short_option) qos_upstream check
2137         BOOST_CHECK_EQUAL( adm.get_request().vs_element.qos_upstream, ( 100000000ULL / 8 ) );
2138         // unit_test[152] parse_vs_func normal case 3 (CMD_EDIT_VS short_option) qos_downstream check
2139         BOOST_CHECK_EQUAL( adm.get_request().vs_element.qos_downstream, ( 200000000ULL / 8 ) );
2140     }
2141
2142     // parse_vs_func normal case 4 (CMD_EDIT_VS long_option)
2143     {
2144         l7vsadm_test    adm;
2145         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_EDIT_VS;
2146         int        argc    = 19;
2147         char*    argv[]    = {    "l7vsadm_test",
2148                             "--edit-service",
2149                             "--tcp-service",
2150                             "10.144.169.86:11500",
2151                             "--proto-module",
2152                             "cinsert",
2153                             "mod_arg",
2154                             "--scheduler",
2155                             "lc",
2156                             "--upper",
2157                             "96",
2158                             "--bypass",
2159                             "10.144.169.87:80",
2160                             "--flag",
2161                             "1",
2162                             "--qos-up",
2163                             "100M",
2164                             "--qos-down",
2165                             "200M"
2166                             };
2167
2168         bool ret = adm.parse_vs_func_wp( cmd, argc, argv );
2169
2170         // unit_test[153] parse_vs_func normal case 4 (CMD_EDIT_VS long_option) return value check
2171         BOOST_CHECK_EQUAL( ret, true );
2172         // unit_test[154] parse_vs_func normal case 4 (CMD_EDIT_VS long_option) request check
2173         BOOST_CHECK_EQUAL( adm.get_request().command, l7vs::l7vsadm_request::CMD_EDIT_VS );
2174         // unit_test[155] parse_vs_func normal case 4 (CMD_EDIT_VS long_option) tcp_accept_endpoint check
2175         boost::asio::ip::tcp::endpoint    tcp_acc_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.86:11500" );
2176         BOOST_CHECK_EQUAL( adm.get_request().vs_element.tcp_accept_endpoint, tcp_acc_ep );
2177         // unit_test[156] parse_vs_func normal case 4 (CMD_EDIT_VS long_option) protocol module name check
2178         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
2179         // unit_test[157] parse_vs_func normal case 4 (CMD_EDIT_VS long_option) protocol module arg check
2180         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "mod_arg" );
2181         // unit_test[158] parse_vs_func normal case 4 (CMD_EDIT_VS long_option) schedule module name check
2182         BOOST_CHECK_EQUAL( adm.get_request().vs_element.schedule_module_name, "lc" );
2183         // unit_test[159] parse_vs_func normal case 4 (CMD_EDIT_VS long_option) sorry_maxconnection check
2184         BOOST_CHECK_EQUAL( adm.get_request().vs_element.sorry_maxconnection, 96 );
2185         // unit_test[160] parse_vs_func normal case 4 (CMD_EDIT_VS long_option) sorry_endpoint check
2186         boost::asio::ip::tcp::endpoint    sorry_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.87:80" );
2187         BOOST_CHECK_EQUAL( adm.get_request().vs_element.sorry_endpoint, sorry_ep );
2188         // unit_test[161] parse_vs_func normal case 4 (CMD_EDIT_VS long_option) sorry_flag check
2189         BOOST_CHECK_EQUAL( adm.get_request().vs_element.sorry_flag, true );
2190         // unit_test[162] parse_vs_func normal case 4 (CMD_EDIT_VS long_option) qos_upstream check
2191         BOOST_CHECK_EQUAL( adm.get_request().vs_element.qos_upstream, ( 100000000ULL / 8 ) );
2192         // unit_test[163] parse_vs_func normal case 4 (CMD_EDIT_VS long_option) qos_downstream check
2193         BOOST_CHECK_EQUAL( adm.get_request().vs_element.qos_downstream, ( 200000000ULL / 8 ) );
2194     }
2195
2196     // parse_vs_func normal case 5 (CMD_DEL_VS short_option)
2197     {
2198         l7vsadm_test    adm;
2199         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_DEL_VS;
2200         int        argc    = 7;
2201         char*    argv[]    = {    "l7vsadm_test",
2202                             "-D",
2203                             "-t",
2204                             "10.144.169.87:22100",
2205                             "-m",
2206                             "cinsert",
2207                             "mod_arg"
2208                             };
2209
2210         bool ret = adm.parse_vs_func_wp( cmd, argc, argv );
2211
2212         // unit_test[164] parse_vs_func normal case 5 (CMD_DEL_VS short_option) return value check
2213         BOOST_CHECK_EQUAL( ret, true );
2214         // unit_test[165] parse_vs_func normal case 5 (CMD_DEL_VS short_option) request check
2215         BOOST_CHECK_EQUAL( adm.get_request().command, l7vs::l7vsadm_request::CMD_DEL_VS );
2216         // unit_test[166] parse_vs_func normal case 5 (CMD_DEL_VS short_option) tcp_accept_endpoint check
2217         boost::asio::ip::tcp::endpoint    tcp_acc_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.87:22100" );
2218         BOOST_CHECK_EQUAL( adm.get_request().vs_element.tcp_accept_endpoint, tcp_acc_ep );
2219         // unit_test[167] parse_vs_func normal case 5 (CMD_DEL_VS short_option) protocol module name check
2220         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
2221         // unit_test[168] parse_vs_func normal case 5 (CMD_DEL_VS short_option) protocol module arg check
2222         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "mod_arg" );
2223     }
2224
2225     // parse_vs_func normal case 6 (CMD_DEL_VS long_option)
2226     {
2227         l7vsadm_test    adm;
2228         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_DEL_VS;
2229         int        argc    = 7;
2230         char*    argv[]    = {    "l7vsadm_test",
2231                             "--delete-service",
2232                             "--tcp-service",
2233                             "10.144.169.86:11500",
2234                             "--proto-module",
2235                             "curl",
2236                             "specified_url"
2237                             };
2238
2239         bool ret = adm.parse_vs_func_wp( cmd, argc, argv );
2240
2241         // unit_test[169] parse_vs_func normal case 6 (CMD_DEL_VS long_option) return value check
2242         BOOST_CHECK_EQUAL( ret, true );
2243         // unit_test[170] parse_vs_func normal case 6 (CMD_DEL_VS long_option) request check
2244         BOOST_CHECK_EQUAL( adm.get_request().command, l7vs::l7vsadm_request::CMD_DEL_VS );
2245         // unit_test[171] parse_vs_func normal case 6 (CMD_DEL_VS long_option) tcp_accept_endpoint check
2246         boost::asio::ip::tcp::endpoint    tcp_acc_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.86:11500" );
2247         BOOST_CHECK_EQUAL( adm.get_request().vs_element.tcp_accept_endpoint, tcp_acc_ep );
2248         // unit_test[172] parse_vs_func normal case 6 (CMD_DEL_VS long_option) protocol module name check
2249         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "curl" );
2250         // unit_test[173] parse_vs_func normal case 6 (CMD_DEL_VS long_option) protocol module arg check
2251         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "specified_url" );
2252     }
2253
2254     // parse_vs_func normal case 7 (CMD_ADD_VS scheduler omit)
2255     {
2256         l7vsadm_test    adm;
2257         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_ADD_VS;
2258         int        argc    = 7;
2259         char*    argv[]    = {    "l7vsadm_test",
2260                             "-A",
2261                             "-t",
2262                             "10.144.169.87:22100",
2263                             "-m",
2264                             "cinsert",
2265                             "mod_arg"
2266                             };
2267
2268         bool ret = adm.parse_vs_func_wp( cmd, argc, argv );
2269
2270         // unit_test[174] parse_vs_func normal case 7 (CMD_ADD_VS scheduler omit) return value check
2271         BOOST_CHECK_EQUAL( ret, true );
2272         // unit_test[175] parse_vs_func normal case 7 (CMD_ADD_VS scheduler omit) request check
2273         BOOST_CHECK_EQUAL( adm.get_request().command, l7vs::l7vsadm_request::CMD_ADD_VS );
2274         // unit_test[176] parse_vs_func normal case 7 (CMD_ADD_VS scheduler omit) tcp_accept_endpoint check
2275         boost::asio::ip::tcp::endpoint    tcp_acc_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.87:22100" );
2276         BOOST_CHECK_EQUAL( adm.get_request().vs_element.tcp_accept_endpoint, tcp_acc_ep );
2277         // unit_test[177] parse_vs_func normal case 7 (CMD_ADD_VS scheduler omit) protocol module name check
2278         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
2279         // unit_test[178] parse_vs_func normal case 7 (CMD_ADD_VS scheduler omit) protocol module arg check
2280         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "mod_arg" );
2281         // unit_test[179] parse_vs_func normal case 7 (CMD_ADD_VS scheduler omit) schedule module name check
2282         BOOST_CHECK_EQUAL( adm.get_request().vs_element.schedule_module_name, "rr" );
2283     }
2284
2285     // parse_vs_func normal case 8 (CMD_FLUSH_VS)
2286     {
2287         l7vsadm_test    adm;
2288         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_FLUSH_VS;
2289         int        argc    = 2;
2290         char*    argv[]    = {    "l7vsadm_test",
2291                             "-C"
2292                             };
2293
2294         bool ret = adm.parse_vs_func_wp( cmd, argc, argv );
2295
2296         // unit_test[180] parse_vs_func normal case 8 (CMD_FLUSH_VS) return value check
2297         BOOST_CHECK_EQUAL( ret, true );
2298         // unit_test[181] parse_vs_func normal case 8 (CMD_FLUSH_VS) request check
2299         BOOST_CHECK_EQUAL( adm.get_request().command, l7vs::l7vsadm_request::CMD_FLUSH_VS );
2300     }
2301
2302     // parse_vs_func normal case 9 (CMD_EDIT_VS minimum option)
2303     {
2304         l7vsadm_test    adm;
2305         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_EDIT_VS;
2306         int        argc    = 9;
2307         char*    argv[]    = {    "l7vsadm_test",
2308                             "-E",
2309                             "-t",
2310                             "10.144.169.87:22100",
2311                             "-m",
2312                             "cinsert",
2313                             "mod_arg",
2314                             "-s",
2315                             "lc"
2316                             };
2317
2318         bool ret = adm.parse_vs_func_wp( cmd, argc, argv );
2319
2320         // unit_test[182] parse_vs_func normal case 9 (CMD_EDIT_VS minimum option) return value check
2321         BOOST_CHECK_EQUAL( ret, true );
2322         // unit_test[183] parse_vs_func normal case 9 (CMD_EDIT_VS minimum option) request check
2323         BOOST_CHECK_EQUAL( adm.get_request().command, l7vs::l7vsadm_request::CMD_EDIT_VS );
2324         // unit_test[184] parse_vs_func normal case 9 (CMD_EDIT_VS minimum option) tcp_accept_endpoint check
2325         boost::asio::ip::tcp::endpoint    tcp_acc_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.87:22100" );
2326         BOOST_CHECK_EQUAL( adm.get_request().vs_element.tcp_accept_endpoint, tcp_acc_ep );
2327         // unit_test[185] parse_vs_func normal case 9 (CMD_EDIT_VS minimum option) protocol module name check
2328         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
2329     }
2330
2331     // parse_vs_func normal case 10 (CMD_DEL_VS minimum option)
2332     {
2333         l7vsadm_test    adm;
2334         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_DEL_VS;
2335         int        argc    = 6;
2336         char*    argv[]    = {    "l7vsadm_test",
2337                             "-D",
2338                             "-t",
2339                             "10.144.169.87:22100",
2340                             "-m",
2341                             "cinsert"
2342                             };
2343
2344         bool ret = adm.parse_vs_func_wp( cmd, argc, argv );
2345
2346         // unit_test[186] parse_vs_func normal case 10 (CMD_DEL_VS minimum option) return value check
2347         BOOST_CHECK_EQUAL( ret, true );
2348         // unit_test[187] parse_vs_func normal case 10 (CMD_DEL_VS minimum option) request check
2349         BOOST_CHECK_EQUAL( adm.get_request().command, l7vs::l7vsadm_request::CMD_DEL_VS );
2350         // unit_test[188] parse_vs_func normal case 10 (CMD_DEL_VS minimum option) tcp_accept_endpoint check
2351         boost::asio::ip::tcp::endpoint    tcp_acc_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.87:22100" );
2352         BOOST_CHECK_EQUAL( adm.get_request().vs_element.tcp_accept_endpoint, tcp_acc_ep );
2353         // unit_test[189] parse_vs_func normal case 10 (CMD_DEL_VS minimum option) protocol module name check
2354         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
2355     }
2356
2357     // parse_vs_func error case 1 (CMD_ADD_VS protocol module not specified)
2358     {
2359         l7vsadm_test    adm;
2360         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_ADD_VS;
2361         int        argc    = 4;
2362         char*    argv[]    = {    "l7vsadm_test",
2363                             "-A",
2364                             "-t",
2365                             "10.144.169.87:22100"
2366                             };
2367
2368         bool ret = adm.parse_vs_func_wp( cmd, argc, argv );
2369
2370         // unit_test[190] parse_vs_func error case 1 (CMD_ADD_VS protocol module not specified) return value check
2371         BOOST_CHECK_EQUAL( ret, false );
2372     }
2373
2374     // parse_vs_func error case 2 (CMD_ADD_VS target address not specified)
2375     {
2376         l7vsadm_test    adm;
2377         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_ADD_VS;
2378         int        argc    = 5;
2379         char*    argv[]    = {    "l7vsadm_test",
2380                             "-A",
2381                             "-m",
2382                             "cinsert",
2383                             "mod_arg"
2384                             };
2385
2386         bool ret = adm.parse_vs_func_wp( cmd, argc, argv );
2387
2388         // unit_test[191] parse_vs_func error case 2 (CMD_ADD_VS target address not specified) return value check
2389         BOOST_CHECK_EQUAL( ret, false );
2390     }
2391
2392     // parse_vs_func error case 3 (upper option value under 0)
2393     {
2394         l7vsadm_test    adm;
2395         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_ADD_VS;
2396         int        argc    = 9;
2397         char*    argv[]    = {    "l7vsadm_test",
2398                             "-A",
2399                             "-t",
2400                             "10.144.169.87:22100",
2401                             "-m",
2402                             "cinsert",
2403                             "mod_arg",
2404                             "-u",
2405                             "-1"
2406                             };
2407
2408         bool ret = adm.parse_vs_func_wp( cmd, argc, argv );
2409
2410         // unit_test[192] parse_vs_func error case 3 (upper option value under 0) return value check
2411         BOOST_CHECK_EQUAL( ret, false );
2412     }
2413
2414     // parse_vs_func error case 4 (access log on but not specified access log fil name)
2415     {
2416         l7vsadm_test    adm;
2417         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_ADD_VS;
2418         int        argc    = 9;
2419         char*    argv[]    = {    "l7vsadm_test",
2420                             "-A",
2421                             "-t",
2422                             "10.144.169.87:22100",
2423                             "-m",
2424                             "cinsert",
2425                             "mod_arg",
2426                             "-L",
2427                             "1"
2428                             };
2429
2430         bool ret = adm.parse_vs_func_wp( cmd, argc, argv );
2431
2432         // unit_test[xx] parse_vs_func error case 4  return value check
2433         BOOST_CHECK_EQUAL( ret, false );
2434     }
2435
2436     BOOST_MESSAGE( "----- parse_vs_func_test end -----" );
2437
2438 }
2439
2440 void    parse_opt_rs_weight_func_test(){
2441     BOOST_MESSAGE( "----- parse_opt_rs_weight_func_test start -----" );
2442
2443     // parse_opt_rs_weight_func normal case 1
2444     {
2445         l7vsadm_test    adm;
2446         int        pos        = 2;
2447         int        argc    = 4;
2448         char*    argv[]    = { "l7vsadm_test", "-a", "-w", "64" };
2449         adm.get_request().vs_element.realserver_vector.push_back( l7vs::realserver_element() );
2450
2451         bool ret = adm.parse_opt_rs_weight_func_wp( pos, argc, argv );
2452
2453         // unit_test[193] parse_opt_rs_weight_func normal case 1 return value check
2454         BOOST_CHECK_EQUAL( ret, true );
2455         // unit_test[194] parse_opt_rs_weight_func normal case 1 weight check
2456         BOOST_CHECK_EQUAL( adm.get_request().vs_element.realserver_vector.front().weight, 64 );
2457     }
2458
2459     // parse_opt_rs_weight_func error case 1 (invalid weight value (charactor))
2460     {
2461         l7vsadm_test    adm;
2462         int        pos        = 2;
2463         int        argc    = 4;
2464         char*    argv[]    = { "l7vsadm_test", "-a", "-w", "a" };
2465         adm.get_request().vs_element.realserver_vector.push_back( l7vs::realserver_element() );
2466
2467         bool ret = adm.parse_opt_rs_weight_func_wp( pos, argc, argv );
2468
2469         // unit_test[195] parse_opt_rs_weight_func error case 1 (invalid weight value (charactor)) return value check
2470         BOOST_CHECK_EQUAL( ret, false );
2471     }
2472
2473     // parse_opt_rs_weight_func error case 2 (invalid weight value(int over))
2474     {
2475         l7vsadm_test    adm;
2476         int        pos        = 2;
2477         int        argc    = 4;
2478         std::stringstream    ss;
2479         ss << (1ULL) + INT_MAX;
2480         char*    argv[]    = { "l7vsadm_test", "-a", "-w", const_cast<char*>( ss.str().c_str() ) };
2481         adm.get_request().vs_element.realserver_vector.push_back( l7vs::realserver_element() );
2482
2483         bool ret = adm.parse_opt_rs_weight_func_wp( pos, argc, argv );
2484
2485         // unit_test[196] parse_opt_rs_weight_func error case 2 (invalid weight value(int over)) return value check
2486         BOOST_CHECK_EQUAL( ret, false );
2487     }
2488
2489     // parse_opt_rs_weight_func error case 3 (no weight value)
2490     {
2491         l7vsadm_test    adm;
2492         int        pos        = 2;
2493         int        argc    = 3;
2494         char*    argv[]    = { "l7vsadm_test", "-a", "-w" };
2495         adm.get_request().vs_element.realserver_vector.push_back( l7vs::realserver_element() );
2496
2497         bool ret = adm.parse_opt_rs_weight_func_wp( pos, argc, argv );
2498
2499         // unit_test[197] parse_opt_rs_weight_func error case 3 (no weight value) return value check
2500         BOOST_CHECK_EQUAL( ret, false );
2501     }
2502
2503     // parse_opt_rs_weight_func error case 4 (under 0)
2504     {
2505         l7vsadm_test    adm;
2506         int        pos        = 2;
2507         int        argc    = 4;
2508         char*    argv[]    = { "l7vsadm_test", "-a", "-w", "-1" };
2509         adm.get_request().vs_element.realserver_vector.push_back( l7vs::realserver_element() );
2510
2511         bool ret = adm.parse_opt_rs_weight_func_wp( pos, argc, argv );
2512
2513         // unit_test[198] parse_opt_rs_weight_func error case 4 (under 0) return value check
2514         BOOST_CHECK_EQUAL( ret, false );
2515     }
2516
2517     // parse_opt_rs_weight_func error case 5 (over 100)
2518     {
2519         l7vsadm_test    adm;
2520         int        pos        = 2;
2521         int        argc    = 4;
2522         char*    argv[]    = { "l7vsadm_test", "-a", "-w", "101" };
2523         adm.get_request().vs_element.realserver_vector.push_back( l7vs::realserver_element() );
2524
2525         bool ret = adm.parse_opt_rs_weight_func_wp( pos, argc, argv );
2526
2527         // unit_test[199] parse_opt_rs_weight_func error case 5 (over 100) return value check
2528         BOOST_CHECK_EQUAL( ret, false );
2529     }
2530
2531     BOOST_MESSAGE( "----- parse_opt_rs_weight_func_test end -----" );
2532
2533 }
2534
2535 void    parse_opt_rs_realserver_func_test(){
2536     BOOST_MESSAGE( "----- parse_opt_rs_realserver_func_test start -----" );
2537
2538     // parse_opt_rs_realserver_func normal case 1
2539     {
2540         l7vsadm_test    adm;
2541         int        pos        = 2;
2542         int        argc    = 4;
2543         char*    argv[]    = { "l7vsadm_test", "-a", "-r", "10.144.169.87:8080" };
2544         adm.get_request().vs_element.realserver_vector.push_back( l7vs::realserver_element() );
2545
2546         bool ret = adm.parse_opt_rs_realserver_func_wp( pos, argc, argv );
2547
2548         // unit_test[200] parse_opt_rs_realserver_func normal case 1 return value check
2549         BOOST_CHECK_EQUAL( ret, true );
2550         // unit_test[201] parse_opt_rs_realserver_func normal case 1 endpoint check
2551         boost::asio::ip::tcp::endpoint    ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.87:8080" );
2552         BOOST_CHECK_EQUAL( adm.get_request().vs_element.realserver_vector.front().tcp_endpoint, ep );
2553     }
2554
2555     // parse_opt_rs_realserver_func normal case 2 (realserver specified in name)
2556     {
2557         l7vsadm_test    adm;
2558         int        pos        = 2;
2559         int        argc    = 4;
2560         char*    argv[]    = { "l7vsadm_test", "-a", "-r", "localhost:http" };
2561         adm.get_request().vs_element.realserver_vector.push_back( l7vs::realserver_element() );
2562
2563         bool ret = adm.parse_opt_rs_realserver_func_wp( pos, argc, argv );
2564
2565         // unit_test[202] parse_opt_rs_realserver_func normal case 2 (realserver specified in name) return value check
2566         BOOST_CHECK_EQUAL( ret, true );
2567         // unit_test[203] parse_opt_rs_realserver_func normal case 2 (realserver specified in name) endpoint check
2568         boost::asio::ip::tcp::endpoint ep1 = string_to_endpoint<boost::asio::ip::tcp>("127.0.0.1:80");
2569         boost::asio::ip::tcp::endpoint ep2 = string_to_endpoint<boost::asio::ip::tcp>("[::1]:80");
2570         BOOST_CHECK( adm.get_request().vs_element.realserver_vector.front().tcp_endpoint == ep1 ||
2571                 adm.get_request().vs_element.realserver_vector.front().tcp_endpoint == ep2);
2572     }
2573
2574     // parse_opt_rs_realserver_func error case 1 (invalid endpoint)
2575     {
2576         l7vsadm_test    adm;
2577         int        pos        = 2;
2578         int        argc    = 4;
2579         char*    argv[]    = { "l7vsadm_test", "-a", "-r", "10.144.169.257:8080" };
2580         adm.get_request().vs_element.realserver_vector.push_back( l7vs::realserver_element() );
2581
2582         bool ret = adm.parse_opt_rs_realserver_func_wp( pos, argc, argv );
2583
2584         // unit_test[204] parse_opt_rs_realserver_func error case 1 (invalid endpoint) return value check
2585         BOOST_CHECK_EQUAL( ret, false );
2586     }
2587
2588     // parse_opt_rs_realserver_func error case 2 (no endpoint)
2589     {
2590         l7vsadm_test    adm;
2591         int        pos        = 2;
2592         int        argc    = 3;
2593         char*    argv[]    = { "l7vsadm_test", "-a", "-r" };
2594         adm.get_request().vs_element.realserver_vector.push_back( l7vs::realserver_element() );
2595
2596         bool ret = adm.parse_opt_rs_realserver_func_wp( pos, argc, argv );
2597
2598         // unit_test[205] parse_opt_rs_realserver_func error case 2 (no endpoint) return value check
2599         BOOST_CHECK_EQUAL( ret, false );
2600     }
2601
2602     // parse_opt_rs_realserver_func error case 3 (0.0.0.0 address)
2603     {
2604         l7vsadm_test    adm;
2605         int        pos        = 2;
2606         int        argc    = 4;
2607         char*    argv[]    = { "l7vsadm_test", "-a", "-r", "0.0.0.0:8080" };
2608         adm.get_request().vs_element.realserver_vector.push_back( l7vs::realserver_element() );
2609
2610         bool ret = adm.parse_opt_rs_realserver_func_wp( pos, argc, argv );
2611
2612         // unit_test[206] parse_opt_rs_realserver_func error case 3 (0.0.0.0 address) return value check
2613         BOOST_CHECK_EQUAL( ret, false );
2614     }
2615
2616     // parse_opt_rs_realserver_func error case 4 (0 port)
2617     {
2618         l7vsadm_test    adm;
2619         int        pos        = 2;
2620         int        argc    = 4;
2621         char*    argv[]    = { "l7vsadm_test", "-a", "-r", "10.144.169.87:0" };
2622         adm.get_request().vs_element.realserver_vector.push_back( l7vs::realserver_element() );
2623
2624         bool ret = adm.parse_opt_rs_realserver_func_wp( pos, argc, argv );
2625
2626         // unit_test[207] parse_opt_rs_realserver_func error case 4 (0 port) return value check
2627         BOOST_CHECK_EQUAL( ret, false );
2628     }
2629
2630     // parse_opt_rs_realserver_func error case 5 (invalid port (99999))
2631     {
2632         l7vsadm_test    adm;
2633         int        pos        = 2;
2634         int        argc    = 4;
2635         char*    argv[]    = { "l7vsadm_test", "-a", "-r", "10.144.169.87:99999" };
2636         adm.get_request().vs_element.realserver_vector.push_back( l7vs::realserver_element() );
2637
2638         bool ret = adm.parse_opt_rs_realserver_func_wp( pos, argc, argv );
2639
2640         // unit_test[208] parse_opt_rs_realserver_func error case 5 (invalid port (99999)) return value check
2641         BOOST_CHECK_EQUAL( ret, false );
2642     }
2643
2644     // parse_opt_rs_realserver_func error case 6 (hostname omitted)
2645     {
2646         l7vsadm_test    adm;
2647         int        pos        = 2;
2648         int        argc    = 4;
2649         char*    argv[]    = { "l7vsadm_test", "-a", "-r", ":22100" };
2650         adm.get_request().vs_element.realserver_vector.push_back( l7vs::realserver_element() );
2651
2652         bool ret = adm.parse_opt_rs_realserver_func_wp( pos, argc, argv );
2653
2654         // unit_test[209] parse_opt_rs_realserver_func error case 6 (hostname omitted) return value check
2655         BOOST_CHECK_EQUAL( ret, false );
2656     }
2657
2658     // parse_opt_rs_realserver_func error case 7 (port omitted)
2659     {
2660         l7vsadm_test    adm;
2661         int        pos        = 2;
2662         int        argc    = 4;
2663         char*    argv[]    = { "l7vsadm_test", "-a", "-r", "10.144.169.87:" };
2664         adm.get_request().vs_element.realserver_vector.push_back( l7vs::realserver_element() );
2665
2666         bool ret = adm.parse_opt_rs_realserver_func_wp( pos, argc, argv );
2667
2668         // unit_test[210] parse_opt_rs_realserver_func error case 7 (port omitted) return value check
2669         BOOST_CHECK_EQUAL( ret, false );
2670     }
2671
2672     BOOST_MESSAGE( "----- parse_opt_rs_realserver_func_test end -----" );
2673
2674 }
2675
2676 void    parse_rs_func_test(){
2677     BOOST_MESSAGE( "----- parse_rs_func_test start -----" );
2678
2679     // parse_rs_func normal case 1 (CMD_ADD_RS short_option)
2680     {
2681         l7vsadm_test    adm;
2682         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_ADD_RS;
2683         int        argc    = 11;
2684         char*    argv[]    = {    "l7vsadm_test",
2685                             "-a",
2686                             "-t",
2687                             "10.144.169.87:22100",
2688                             "-m",
2689                             "cinsert",
2690                             "mod_arg",
2691                             "-r",
2692                             "10.144.169.86:8080",
2693                             "-w",
2694                             "10"
2695                             };
2696
2697         bool ret = adm.parse_rs_func_wp( cmd, argc, argv );
2698
2699         // unit_test[211] parse_rs_func normal case 1 (CMD_ADD_RS short_option) return value check
2700         BOOST_CHECK_EQUAL( ret, true );
2701         // unit_test[212] parse_rs_func normal case 1 (CMD_ADD_RS short_option) request check
2702         BOOST_CHECK_EQUAL( adm.get_request().command, l7vs::l7vsadm_request::CMD_ADD_RS );
2703         // unit_test[213] parse_rs_func normal case 1 (CMD_ADD_RS short_option) tcp_accept_endpoint check
2704         boost::asio::ip::tcp::endpoint    tcp_acc_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.87:22100" );
2705         BOOST_CHECK_EQUAL( adm.get_request().vs_element.tcp_accept_endpoint, tcp_acc_ep );
2706         // unit_test[214] parse_rs_func normal case 1 (CMD_ADD_RS short_option) protocol module name check
2707         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
2708         // unit_test[215] parse_rs_func normal case 1 (CMD_ADD_RS short_option) protocol module arg check
2709         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "mod_arg" );
2710         // unit_test[216] parse_rs_func normal case 1 (CMD_ADD_RS short_option) realserver endpoint check
2711         boost::asio::ip::tcp::endpoint    rs_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.86:8080" );
2712         BOOST_CHECK_EQUAL( adm.get_request().vs_element.realserver_vector.front().tcp_endpoint, rs_ep );
2713         // unit_test[217] parse_rs_func normal case 1 (CMD_ADD_RS short_option) weight check
2714         BOOST_CHECK_EQUAL( adm.get_request().vs_element.realserver_vector.front().weight, 10 );
2715     }
2716
2717     // parse_rs_func normal case 2 (CMD_ADD_RS long_option)
2718     {
2719         l7vsadm_test    adm;
2720         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_ADD_RS;
2721         int        argc    = 11;
2722         char*    argv[]    = {    "l7vsadm_test",
2723                             "--add-server",
2724                             "--tcp-service",
2725                             "10.144.169.86:11500",
2726                             "--proto-module",
2727                             "cinsert",
2728                             "mod_arg",
2729                             "--real-server",
2730                             "10.144.169.87:8888",
2731                             "--weight",
2732                             "20"
2733                             };
2734
2735         bool ret = adm.parse_rs_func_wp( cmd, argc, argv );
2736
2737         // unit_test[218] parse_rs_func normal case 2 (CMD_ADD_RS long_option) return value check
2738         BOOST_CHECK_EQUAL( ret, true );
2739         // unit_test[219] parse_rs_func normal case 2 (CMD_ADD_RS long_option) request check
2740         BOOST_CHECK_EQUAL( adm.get_request().command, l7vs::l7vsadm_request::CMD_ADD_RS );
2741         // unit_test[220] parse_rs_func normal case 2 (CMD_ADD_RS long_option) tcp_accept_endpoint check
2742         boost::asio::ip::tcp::endpoint    tcp_acc_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.86:11500" );
2743         BOOST_CHECK_EQUAL( adm.get_request().vs_element.tcp_accept_endpoint, tcp_acc_ep );
2744         // unit_test[221] parse_rs_func normal case 2 (CMD_ADD_RS long_option) protocol module name check
2745         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
2746         // unit_test[222] parse_rs_func normal case 2 (CMD_ADD_RS long_option) protocol module arg check
2747         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "mod_arg" );
2748         // unit_test[223] parse_rs_func normal case 2 (CMD_ADD_RS long_option) realserver endpoint check
2749         boost::asio::ip::tcp::endpoint    rs_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.87:8888" );
2750         BOOST_CHECK_EQUAL( adm.get_request().vs_element.realserver_vector.front().tcp_endpoint, rs_ep );
2751         // unit_test[224] parse_rs_func normal case 2 (CMD_ADD_RS long_option) weight check
2752         BOOST_CHECK_EQUAL( adm.get_request().vs_element.realserver_vector.front().weight, 20 );
2753     }
2754
2755     // parse_rs_func normal case 3 (CMD_EDIT_RS short_option)
2756     {
2757         l7vsadm_test    adm;
2758         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_EDIT_RS;
2759         int        argc    = 11;
2760         char*    argv[]    = {    "l7vsadm_test",
2761                             "-e",
2762                             "-t",
2763                             "10.144.169.87:22100",
2764                             "-m",
2765                             "cinsert",
2766                             "mod_arg",
2767                             "-r",
2768                             "10.144.169.86:8080",
2769                             "-w",
2770                             "20"
2771                             };
2772
2773         bool ret = adm.parse_rs_func_wp( cmd, argc, argv );
2774
2775         // unit_test[225] parse_rs_func normal case 3 (CMD_EDIT_RS short_option) return value check
2776         BOOST_CHECK_EQUAL( ret, true );
2777         // unit_test[226] parse_rs_func normal case 3 (CMD_EDIT_RS short_option) request check
2778         BOOST_CHECK_EQUAL( adm.get_request().command, l7vs::l7vsadm_request::CMD_EDIT_RS );
2779         // unit_test[227] parse_rs_func normal case 3 (CMD_EDIT_RS short_option) tcp_accept_endpoint check
2780         boost::asio::ip::tcp::endpoint    tcp_acc_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.87:22100" );
2781         BOOST_CHECK_EQUAL( adm.get_request().vs_element.tcp_accept_endpoint, tcp_acc_ep );
2782         // unit_test[228] parse_rs_func normal case 3 (CMD_EDIT_RS short_option) protocol module name check
2783         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
2784         // unit_test[229] parse_rs_func normal case 3 (CMD_EDIT_RS short_option) protocol module arg check
2785         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "mod_arg" );
2786         // unit_test[230] parse_rs_func normal case 3 (CMD_EDIT_RS short_option) realserver endpoint check
2787         boost::asio::ip::tcp::endpoint    rs_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.86:8080" );
2788         BOOST_CHECK_EQUAL( adm.get_request().vs_element.realserver_vector.front().tcp_endpoint, rs_ep );
2789         // unit_test[231] parse_rs_func normal case 3 (CMD_EDIT_RS short_option) weight check
2790         BOOST_CHECK_EQUAL( adm.get_request().vs_element.realserver_vector.front().weight, 20 );
2791     }
2792
2793     // parse_rs_func normal case 4 (CMD_EDIT_RS long_option)
2794     {
2795         l7vsadm_test    adm;
2796         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_EDIT_RS;
2797         int        argc    = 11;
2798         char*    argv[]    = {    "l7vsadm_test",
2799                             "--edit-server",
2800                             "--tcp-service",
2801                             "10.144.169.86:11500",
2802                             "--proto-module",
2803                             "cinsert",
2804                             "mod_arg",
2805                             "--real-server",
2806                             "10.144.169.87:8888",
2807                             "--weight",
2808                             "30"
2809                             };
2810
2811         bool ret = adm.parse_rs_func_wp( cmd, argc, argv );
2812
2813         // unit_test[232] parse_rs_func normal case 4 (CMD_EDIT_RS long_option) return value check
2814         BOOST_CHECK_EQUAL( ret, true );
2815         // unit_test[233] parse_rs_func normal case 4 (CMD_EDIT_RS long_option) request check
2816         BOOST_CHECK_EQUAL( adm.get_request().command, l7vs::l7vsadm_request::CMD_EDIT_RS );
2817         // unit_test[234] parse_rs_func normal case 4 (CMD_EDIT_RS long_option) tcp_accept_endpoint check
2818         boost::asio::ip::tcp::endpoint    tcp_acc_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.86:11500" );
2819         BOOST_CHECK_EQUAL( adm.get_request().vs_element.tcp_accept_endpoint, tcp_acc_ep );
2820         // unit_test[235] parse_rs_func normal case 4 (CMD_EDIT_RS long_option) protocol module name check
2821         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
2822         // unit_test[236] parse_rs_func normal case 4 (CMD_EDIT_RS long_option) protocol module arg check
2823         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "mod_arg" );
2824         // unit_test[237] parse_rs_func normal case 4 (CMD_EDIT_RS long_option) realserver endpoint check
2825         boost::asio::ip::tcp::endpoint    rs_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.87:8888" );
2826         BOOST_CHECK_EQUAL( adm.get_request().vs_element.realserver_vector.front().tcp_endpoint, rs_ep );
2827         // unit_test[238] parse_rs_func normal case 4 (CMD_EDIT_RS long_option) weight check
2828         BOOST_CHECK_EQUAL( adm.get_request().vs_element.realserver_vector.front().weight, 30 );
2829     }
2830
2831     // parse_rs_func normal case 5 (CMD_DEL_RS short_option)
2832     {
2833         l7vsadm_test    adm;
2834         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_DEL_RS;
2835         int        argc    = 9;
2836         char*    argv[]    = {    "l7vsadm_test",
2837                             "-d",
2838                             "-t",
2839                             "10.144.169.87:22100",
2840                             "-m",
2841                             "cinsert",
2842                             "mod_arg",
2843                             "-r",
2844                             "10.144.169.86:8080"
2845                             };
2846
2847         bool ret = adm.parse_rs_func_wp( cmd, argc, argv );
2848
2849         // unit_test[239] parse_rs_func normal case 5 (CMD_DEL_RS short_option) return value check
2850         BOOST_CHECK_EQUAL( ret, true );
2851         // unit_test[240] parse_rs_func normal case 5 (CMD_DEL_RS short_option) request check
2852         BOOST_CHECK_EQUAL( adm.get_request().command, l7vs::l7vsadm_request::CMD_DEL_RS );
2853         // unit_test[241] parse_rs_func normal case 5 (CMD_DEL_RS short_option) tcp_accept_endpoint check
2854         boost::asio::ip::tcp::endpoint    tcp_acc_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.87:22100" );
2855         BOOST_CHECK_EQUAL( adm.get_request().vs_element.tcp_accept_endpoint, tcp_acc_ep );
2856         // unit_test[242] parse_rs_func normal case 5 (CMD_DEL_RS short_option) protocol module name check
2857         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
2858         // unit_test[243] parse_rs_func normal case 5 (CMD_DEL_RS short_option) protocol module arg check
2859         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "mod_arg" );
2860         // unit_test[244] parse_rs_func normal case 5 (CMD_DEL_RS short_option) realserver endpoint check
2861         boost::asio::ip::tcp::endpoint    rs_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.86:8080" );
2862         BOOST_CHECK_EQUAL( adm.get_request().vs_element.realserver_vector.front().tcp_endpoint, rs_ep );
2863     }
2864
2865     // parse_rs_func normal case 6 (CMD_DEL_RS long_option)
2866     {
2867         l7vsadm_test    adm;
2868         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_DEL_RS;
2869         int        argc    = 9;
2870         char*    argv[]    = {    "l7vsadm_test",
2871                             "--delete-server",
2872                             "--tcp-service",
2873                             "10.144.169.86:11500",
2874                             "--proto-module",
2875                             "cinsert",
2876                             "mod_arg",
2877                             "--real-server",
2878                             "10.144.169.87:8888"
2879                             };
2880
2881         bool ret = adm.parse_rs_func_wp( cmd, argc, argv );
2882
2883         // unit_test[245] parse_rs_func normal case 6 (CMD_DEL_RS long_option) return value check
2884         BOOST_CHECK_EQUAL( ret, true );
2885         // unit_test[246] parse_rs_func normal case 6 (CMD_DEL_RS long_option) request check
2886         BOOST_CHECK_EQUAL( adm.get_request().command, l7vs::l7vsadm_request::CMD_DEL_RS );
2887         // unit_test[247] parse_rs_func normal case 6 (CMD_DEL_RS long_option) tcp_accept_endpoint check
2888         boost::asio::ip::tcp::endpoint    tcp_acc_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.86:11500" );
2889         BOOST_CHECK_EQUAL( adm.get_request().vs_element.tcp_accept_endpoint, tcp_acc_ep );
2890         // unit_test[248] parse_rs_func normal case 6 (CMD_DEL_RS long_option) protocol module name check
2891         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
2892         // unit_test[249] parse_rs_func normal case 6 (CMD_DEL_RS long_option) protocol module arg check
2893         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "mod_arg" );
2894         // unit_test[250] parse_rs_func normal case 6 (CMD_DEL_RS long_option) realserver endpoint check
2895         boost::asio::ip::tcp::endpoint    rs_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.87:8888" );
2896         BOOST_CHECK_EQUAL( adm.get_request().vs_element.realserver_vector.front().tcp_endpoint, rs_ep );
2897     }
2898
2899 //ramiel_ipv6 add
2900     // parse_rs_func normal case 7 (CMD_ADD_RS ipv6 )
2901     {
2902         l7vsadm_test    adm;
2903         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_ADD_RS;
2904         int        argc    = 11;
2905         char*    argv[]    = {    "l7vsadm_test",
2906                             "-a",
2907                             "-t",
2908                             "10.144.169.87:22100",
2909                             "-m",
2910                             "cinsert",
2911                             "mod_arg",
2912                             "-r",
2913                             "[2001::10]:8080",
2914                             "-w",
2915                             "10"
2916                             };
2917
2918         bool ret = adm.parse_rs_func_wp( cmd, argc, argv );
2919
2920         // unit_test[xx] parse_rs_func normal case 7 (CMD_ADD_RS ipv6) return value check
2921         BOOST_CHECK_EQUAL( ret, true );
2922         // unit_test[xx] parse_rs_func normal case 7 (CMD_ADD_RS ipv6) request check
2923         BOOST_CHECK_EQUAL( adm.get_request().command, l7vs::l7vsadm_request::CMD_ADD_RS );
2924         // unit_test[xx] parse_rs_func normal case 7 (CMD_ADD_RS ipv6) tcp_accept_endpoint check
2925         boost::asio::ip::tcp::endpoint    tcp_acc_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.87:22100" );
2926         BOOST_CHECK_EQUAL( adm.get_request().vs_element.tcp_accept_endpoint, tcp_acc_ep );
2927         // unit_test[xx] parse_rs_func normal case 7 (CMD_ADD_RS ipv6) protocol module name check
2928         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
2929         // unit_test[xx] parse_rs_func normal case 7 (CMD_ADD_RS ipv6) protocol module arg check
2930         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "mod_arg" );
2931         // unit_test[xx] parse_rs_func normal case 7 (CMD_ADD_RS ipv6) realserver endpoint check
2932         boost::asio::ip::tcp::endpoint    rs_ep = string_to_endpoint<boost::asio::ip::tcp>( "[2001::10]:8080" );
2933         BOOST_CHECK_EQUAL( adm.get_request().vs_element.realserver_vector.front().tcp_endpoint, rs_ep );
2934         // unit_test[xx] parse_rs_func normal case 7 (CMD_ADD_RS ipv6) weight check
2935         BOOST_CHECK_EQUAL( adm.get_request().vs_element.realserver_vector.front().weight, 10 );
2936     }
2937
2938     // parse_rs_func error case 1 (CMD_ADD_RS protocol module not specified)
2939     {
2940         l7vsadm_test    adm;
2941         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_ADD_RS;
2942         int        argc    = 6;
2943         char*    argv[]    = {    "l7vsadm_test",
2944                             "-a",
2945                             "-t",
2946                             "10.144.169.87:22100",
2947                             "-r",
2948                             "10.144.169.86:8080"
2949                             };
2950
2951         bool ret = adm.parse_rs_func_wp( cmd, argc, argv );
2952
2953         // unit_test[251] parse_rs_func error case 1 (CMD_ADD_RS protocol module not specified) return value check
2954         BOOST_CHECK_EQUAL( ret, false );
2955     }
2956
2957     // parse_rs_func error case 2 (CMD_ADD_RS target address not specified)
2958     {
2959         l7vsadm_test    adm;
2960         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_ADD_RS;
2961         int        argc    = 7;
2962         char*    argv[]    = {    "l7vsadm_test",
2963                             "-a",
2964                             "-m",
2965                             "cinsert",
2966                             "mod_arg",
2967                             "-r",
2968                             "10.144.169.86:8080"
2969                             };
2970
2971         bool ret = adm.parse_rs_func_wp( cmd, argc, argv );
2972
2973         // unit_test[252] parse_rs_func error case 2 (CMD_ADD_RS target address not specified) return value check
2974         BOOST_CHECK_EQUAL( ret, false );
2975     }
2976
2977     // parse_rs_func error case 3 (CMD_ADD_RS realserver address not specified)
2978     {
2979         l7vsadm_test    adm;
2980         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_ADD_RS;
2981         int        argc    = 7;
2982         char*    argv[]    = {    "l7vsadm_test",
2983                             "-a",
2984                             "-t",
2985                             "10.144.169.87:22100",
2986                             "-m",
2987                             "cinsert",
2988                             "mod_arg",
2989                             };
2990
2991         bool ret = adm.parse_rs_func_wp( cmd, argc, argv );
2992
2993         // unit_test[253] parse_rs_func error case 3 (CMD_ADD_RS realserver address not specified) return value check
2994         BOOST_CHECK_EQUAL( ret, false );
2995     }
2996
2997 //ramiel_ipv6 add
2998     // parse_rs_func error case 4 (CMD_ADD_RS realserver any address ipv4 )
2999     {
3000         l7vsadm_test    adm;
3001         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_ADD_RS;
3002         int        argc    = 11;
3003         char*    argv[]    = {    "l7vsadm_test",
3004                             "-a",
3005                             "-t",
3006                             "10.144.169.87:22100",
3007                             "-m",
3008                             "cinsert",
3009                             "mod_arg",
3010                             "-r",
3011                             "0.0.0.0:8080",
3012                             "-w",
3013                             "10"
3014                             };
3015
3016         bool ret = adm.parse_rs_func_wp( cmd, argc, argv );
3017
3018         // unit_test[xx] parse_rs_func error case 4 (CMD_ADD_RS realserver any address ipv4) return value check
3019         BOOST_CHECK_EQUAL( ret, false );
3020     }
3021
3022 //ramiel_ipv6 add
3023     // parse_rs_func error case 5 (CMD_ADD_RS realserver any address ipv6 )
3024     {
3025         l7vsadm_test    adm;
3026         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_ADD_RS;
3027         int        argc    = 11;
3028         char*    argv[]    = {    "l7vsadm_test",
3029                             "-a",
3030                             "-t",
3031                             "10.144.169.87:22100",
3032                             "-m",
3033                             "cinsert",
3034                             "mod_arg",
3035                             "-r",
3036                             "[::]:8080",
3037                             "-w",
3038                             "10"
3039                             };
3040
3041         bool ret = adm.parse_rs_func_wp( cmd, argc, argv );
3042
3043         // unit_test[xx] parse_rs_func error case 5 (CMD_ADD_RS realserver any address ipv6) return value check
3044         BOOST_CHECK_EQUAL( ret, false );
3045     }
3046
3047     BOOST_MESSAGE( "----- parse_rs_func_test end -----" );
3048
3049 }
3050
3051 void    parse_opt_replication_switch_func_test(){
3052     BOOST_MESSAGE( "----- parse_opt_replication_switch_func_test start -----" );
3053
3054     // parse_opt_replication_switch_func normal case 1 (replication start)
3055     {
3056         l7vsadm_test    adm;
3057         int        pos        = 2;
3058         int        argc    = 4;
3059         char*    argv[]    = { "l7vsadm_test", "-R", "-s", "start" };
3060
3061         bool ret = adm.parse_opt_replication_switch_func_wp( pos, argc, argv );
3062
3063         // unit_test[254] parse_opt_replication_switch_func normal case 1 (replication start) return value check
3064         BOOST_CHECK_EQUAL( ret, true );
3065         // unit_test[255] parse_opt_replication_switch_func normal case 1 (replication start) replication command check
3066         BOOST_CHECK_EQUAL( adm.get_request().replication_command, l7vs::l7vsadm_request::REP_START );
3067     }
3068
3069     // parse_opt_replication_switch_func normal case 2 (replication stop)
3070     {
3071         l7vsadm_test    adm;
3072         int        pos        = 2;
3073         int        argc    = 4;
3074         char*    argv[]    = { "l7vsadm_test", "-R", "-s", "stop" };
3075
3076         bool ret = adm.parse_opt_replication_switch_func_wp( pos, argc, argv );
3077
3078         // unit_test[256] parse_opt_replication_switch_func normal case 2 (replication stop) return value check
3079         BOOST_CHECK_EQUAL( ret, true );
3080         // unit_test[257] parse_opt_replication_switch_func normal case 2 (replication stop) replication command check
3081         BOOST_CHECK_EQUAL( adm.get_request().replication_command, l7vs::l7vsadm_request::REP_STOP );
3082     }
3083
3084     // parse_opt_replication_switch_func error case 1 (invalid switch option)
3085     {
3086         l7vsadm_test    adm;
3087         int        pos        = 2;
3088         int        argc    = 4;
3089         char*    argv[]    = { "l7vsadm_test", "-R", "-s", "end" };
3090
3091         bool ret = adm.parse_opt_replication_switch_func_wp( pos, argc, argv );
3092
3093         // unit_test[258] parse_opt_replication_switch_func error case 1 (invalid switch option) return value check
3094         BOOST_CHECK_EQUAL( ret, false );
3095     }
3096
3097     // parse_opt_replication_switch_func error case 2 (no switch option)
3098     {
3099         l7vsadm_test    adm;
3100         int        pos        = 2;
3101         int        argc    = 3;
3102         char*    argv[]    = { "l7vsadm_test", "-R", "-s" };
3103
3104         bool ret = adm.parse_opt_replication_switch_func_wp( pos, argc, argv );
3105
3106         // unit_test[259] parse_opt_replication_switch_func error case 2 (no switch option) return value check
3107         BOOST_CHECK_EQUAL( ret, false );
3108     }
3109
3110     BOOST_MESSAGE( "----- parse_opt_replication_switch_func_test end -----" );
3111
3112 }
3113
3114 void    parse_opt_replication_force_func_test(){
3115     BOOST_MESSAGE( "----- parse_opt_replication_force_func_test start -----" );
3116
3117     // parse_opt_replication_force_func normal case 1
3118     {
3119         l7vsadm_test    adm;
3120         int        pos        = 2;
3121         int        argc    = 3;
3122         char*    argv[]    = { "l7vsadm_test", "-R", "-f" };
3123
3124         bool ret = adm.parse_opt_replication_force_func_wp( pos, argc, argv );
3125
3126         // unit_test[260] parse_opt_replication_force_func normal case 1 return value check
3127         BOOST_CHECK_EQUAL( ret, true );
3128         // unit_test[261] parse_opt_replication_force_func normal case 1 replication command check
3129         BOOST_CHECK_EQUAL( adm.get_request().replication_command, l7vs::l7vsadm_request::REP_FORCE );
3130     }
3131
3132     BOOST_MESSAGE( "----- parse_opt_replication_force_func_test end -----" );
3133
3134 }
3135
3136 void    parse_opt_replication_dump_func_test(){
3137     BOOST_MESSAGE( "----- parse_opt_replication_dump_func_test start -----" );
3138
3139     // parse_opt_replication_dump_func normal case 1
3140     {
3141         l7vsadm_test    adm;
3142         int        pos        = 2;
3143         int        argc    = 3;
3144         char*    argv[]    = { "l7vsadm_test", "-R", "-d" };
3145
3146         bool ret = adm.parse_opt_replication_dump_func_wp( pos, argc, argv );
3147
3148         // unit_test[262] parse_opt_replication_dump_func normal case 1 return value check
3149         BOOST_CHECK_EQUAL( ret, true );
3150         // unit_test[263] parse_opt_replication_dump_func normal case 1 replication command check
3151         BOOST_CHECK_EQUAL( adm.get_request().replication_command, l7vs::l7vsadm_request::REP_DUMP );
3152     }
3153
3154     BOOST_MESSAGE( "----- parse_opt_replication_dump_func_test end -----" );
3155
3156 }
3157
3158 void    parse_replication_func_test(){
3159     BOOST_MESSAGE( "----- parse_replication_func_test start -----" );
3160
3161     // parse_replication_func normal case 1 (replication start)
3162     {
3163         l7vsadm_test    adm;
3164         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_REPLICATION;
3165         int        argc    = 4;
3166         char*    argv[]    = { "l7vsadm_test", "-R", "-s", "start" };
3167
3168         bool ret = adm.parse_replication_func_wp( cmd, argc, argv );
3169
3170         // unit_test[264] parse_replication_func normal case 1 (replication start) return value check
3171         BOOST_CHECK_EQUAL( ret, true );
3172         // unit_test[265] parse_replication_func normal case 1 (replication start) request command check
3173         BOOST_CHECK_EQUAL( adm.get_request().command, l7vs::l7vsadm_request::CMD_REPLICATION );
3174         // unit_test[266] parse_replication_func normal case 1 (replication start) replication command check
3175         BOOST_CHECK_EQUAL( adm.get_request().replication_command, l7vs::l7vsadm_request::REP_START );
3176     }
3177
3178     // parse_replication_func normal case 2 (replication stop)
3179     {
3180         l7vsadm_test    adm;
3181         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_REPLICATION;
3182         int        argc    = 4;
3183         char*    argv[]    = { "l7vsadm_test", "-R", "-s", "stop" };
3184
3185         bool ret = adm.parse_replication_func_wp( cmd, argc, argv );
3186
3187         // unit_test[267] parse_replication_func normal case 2 (replication stop) return value check
3188         BOOST_CHECK_EQUAL( ret, true );
3189         // unit_test[268] parse_replication_func normal case 2 (replication stop) request command check
3190         BOOST_CHECK_EQUAL( adm.get_request().command, l7vs::l7vsadm_request::CMD_REPLICATION );
3191         // unit_test[269] parse_replication_func normal case 2 (replication stop) replication command check
3192         BOOST_CHECK_EQUAL( adm.get_request().replication_command, l7vs::l7vsadm_request::REP_STOP );
3193     }
3194
3195     // parse_replication_func normal case 3 (replication force)
3196     {
3197         l7vsadm_test    adm;
3198         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_REPLICATION;
3199         int        argc    = 3;
3200         char*    argv[]    = { "l7vsadm_test", "-R", "-f" };
3201
3202         bool ret = adm.parse_replication_func_wp( cmd, argc, argv );
3203
3204         // unit_test[270] parse_replication_func normal case 3 (replication force) return value check
3205         BOOST_CHECK_EQUAL( ret, true );
3206         // unit_test[271] parse_replication_func normal case 3 (replication force) request command check
3207         BOOST_CHECK_EQUAL( adm.get_request().command, l7vs::l7vsadm_request::CMD_REPLICATION );
3208         // unit_test[272] parse_replication_func normal case 3 (replication force) replication command check
3209         BOOST_CHECK_EQUAL( adm.get_request().replication_command, l7vs::l7vsadm_request::REP_FORCE );
3210     }
3211
3212     // parse_replication_func normal case 4 (replication dump)
3213     {
3214         l7vsadm_test    adm;
3215         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_REPLICATION;
3216         int        argc    = 3;
3217         char*    argv[]    = { "l7vsadm_test", "-R", "-d" };
3218
3219         bool ret = adm.parse_replication_func_wp( cmd, argc, argv );
3220
3221         // unit_test[273] parse_replication_func normal case 4 (replication dump) return value check
3222         BOOST_CHECK_EQUAL( ret, true );
3223         // unit_test[274] parse_replication_func normal case 4 (replication dump) request command check
3224         BOOST_CHECK_EQUAL( adm.get_request().command, l7vs::l7vsadm_request::CMD_REPLICATION );
3225         // unit_test[275] parse_replication_func normal case 4 (replication dump) replication command check
3226         BOOST_CHECK_EQUAL( adm.get_request().replication_command, l7vs::l7vsadm_request::REP_DUMP );
3227     }
3228
3229     // parse_replication_func error case 1 (replication command duplicate)
3230     {
3231         l7vsadm_test    adm;
3232         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_REPLICATION;
3233         int        argc    = 4;
3234         char*    argv[]    = { "l7vsadm_test", "-R", "-f", "-d" };
3235
3236         bool ret = adm.parse_replication_func_wp( cmd, argc, argv );
3237
3238         // unit_test[276] parse_replication_func error case 1 (command duplicate) return value check
3239         BOOST_CHECK_EQUAL( ret, false );
3240     }
3241
3242     // parse_replication_func error case 2 (no replication command)
3243     {
3244         l7vsadm_test    adm;
3245         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_REPLICATION;
3246         int        argc    = 2;
3247         char*    argv[]    = { "l7vsadm_test", "-R" };
3248
3249         bool ret = adm.parse_replication_func_wp( cmd, argc, argv );
3250
3251         // unit_test[277] parse_replication_func error case 2 (no replication command) return value check
3252         BOOST_CHECK_EQUAL( ret, false );
3253     }
3254
3255     BOOST_MESSAGE( "----- parse_replication_func_test end -----" );
3256
3257 }
3258
3259 void    parse_opt_log_category_func_test(){
3260     BOOST_MESSAGE( "----- parse_opt_log_category_func_test start -----" );
3261
3262     // parse_opt_log_category_func normal case 1
3263     {
3264         l7vsadm_test    adm;
3265         int        pos        = 2;
3266         int        argc    = 4;
3267         char*    argv[]    = { "l7vsadm_test", "-L", "-c", "l7vsd_network" };
3268
3269         bool ret = adm.parse_opt_log_category_func_wp( pos, argc, argv );
3270
3271         // unit_test[278] parse_opt_log_category_func normal case 1 return value check
3272         BOOST_CHECK_EQUAL( ret, true );
3273         // unit_test[279] parse_opt_log_category_func normal case 1 logcategory check
3274         BOOST_CHECK_EQUAL( adm.get_request().log_category, l7vs::LOG_CAT_L7VSD_NETWORK );
3275     }
3276
3277     // parse_opt_log_category_func error case 1 (invalid logcategory value)
3278     {
3279         l7vsadm_test    adm;
3280         int        pos        = 2;
3281         int        argc    = 4;
3282         char*    argv[]    = { "l7vsadm_test", "-L", "-c", "l7vsd" };
3283
3284         bool ret = adm.parse_opt_log_category_func_wp( pos, argc, argv );
3285
3286         // unit_test[280] parse_opt_log_category_func error case 1 (invalid logcategory value) return value check
3287         BOOST_CHECK_EQUAL( ret, false );
3288     }
3289
3290     // parse_opt_log_category_func error case 2 (no logcategory value)
3291     {
3292         l7vsadm_test    adm;
3293         int        pos        = 2;
3294         int        argc    = 3;
3295         char*    argv[]    = { "l7vsadm_test", "-L", "-c" };
3296
3297         bool ret = adm.parse_opt_log_category_func_wp( pos, argc, argv );
3298
3299         // unit_test[281] parse_opt_log_category_func error case 2 (no logcategory value) return value check
3300         BOOST_CHECK_EQUAL( ret, false );
3301     }
3302
3303     BOOST_MESSAGE( "----- parse_opt_log_category_func_test end -----" );
3304
3305 }
3306
3307 void    parse_opt_log_level_func_test(){
3308     BOOST_MESSAGE( "----- parse_opt_log_level_func_test start -----" );
3309
3310     // parse_opt_log_level_func normal case 1
3311     {
3312         l7vsadm_test    adm;
3313         int        pos        = 2;
3314         int        argc    = 4;
3315         char*    argv[]    = { "l7vsadm_test", "-L", "-l", "error" };
3316
3317         bool ret = adm.parse_opt_log_level_func_wp( pos, argc, argv );
3318
3319         // unit_test[282] parse_opt_log_level_func normal case 1 return value check
3320         BOOST_CHECK_EQUAL( ret, true );
3321         // unit_test[283] parse_opt_log_level_func normal case 1 loglevel check
3322         BOOST_CHECK_EQUAL( adm.get_request().log_level, l7vs::LOG_LV_ERROR );
3323     }
3324
3325     // parse_opt_log_level_func error case 1 (invalid loglevel value)
3326     {
3327         l7vsadm_test    adm;
3328         int        pos        = 2;
3329         int        argc    = 4;
3330         char*    argv[]    = { "l7vsadm_test", "-L", "-l", "l7vsd" };
3331
3332         bool ret = adm.parse_opt_log_level_func_wp( pos, argc, argv );
3333
3334         // unit_test[284] parse_opt_log_level_func error case 1 (invalid loglevel value) return value check
3335         BOOST_CHECK_EQUAL( ret, false );
3336     }
3337
3338     // parse_opt_log_level_func error case 2 (no loglevel value)
3339     {
3340         l7vsadm_test    adm;
3341         int        pos        = 2;
3342         int        argc    = 3;
3343         char*    argv[]    = { "l7vsadm_test", "-L", "-l" };
3344
3345         bool ret = adm.parse_opt_log_level_func_wp( pos, argc, argv );
3346
3347         // unit_test[285] parse_opt_log_level_func error case 2 (no loglevel value) return value check
3348         BOOST_CHECK_EQUAL( ret, false );
3349     }
3350
3351     BOOST_MESSAGE( "----- parse_opt_log_level_func_test end -----" );
3352
3353 }
3354
3355 void    parse_log_func_test(){
3356     BOOST_MESSAGE( "----- parse_log_func_test start -----" );
3357
3358     // parse_log_func normal case 1
3359     {
3360         l7vsadm_test    adm;
3361         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_LOG;
3362         int        argc    = 6;
3363         char*    argv[]    = {    "l7vsadm_test",
3364                             "-L",
3365                             "-c",
3366                             "l7vsd_network",
3367                             "-l",
3368                             "debug"
3369                             };
3370
3371         bool ret = adm.parse_log_func_wp( cmd, argc, argv );
3372
3373         // unit_test[286] parse_log_func normal case 1 return value check
3374         BOOST_CHECK_EQUAL( ret, true );
3375         // unit_test[287] parse_log_func normal case 1 request command check
3376         BOOST_CHECK_EQUAL( adm.get_request().command, l7vs::l7vsadm_request::CMD_LOG );
3377         // unit_test[288] parse_log_func normal case 1 logcategory check
3378         BOOST_CHECK_EQUAL( adm.get_request().log_category, l7vs::LOG_CAT_L7VSD_NETWORK );
3379         // unit_test[289] parse_log_func normal case 1 logcategory check
3380         BOOST_CHECK_EQUAL( adm.get_request().log_level, l7vs::LOG_LV_DEBUG );
3381     }
3382
3383     // parse_log_func error case 1 (no logcategory)
3384     {
3385         l7vsadm_test    adm;
3386         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_LOG;
3387         int        argc    = 4;
3388         char*    argv[]    = {    "l7vsadm_test",
3389                             "-L",
3390                             "-l",
3391                             "debug"
3392                             };
3393
3394         bool ret = adm.parse_log_func_wp( cmd, argc, argv );
3395
3396         // unit_test[290] parse_log_func error case 1 (no logcategory) return value check
3397         BOOST_CHECK_EQUAL( ret, false );
3398     }
3399
3400     // parse_log_func error case 2 (no loglevel)
3401     {
3402         l7vsadm_test    adm;
3403         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_LOG;
3404         int        argc    = 4;
3405         char*    argv[]    = {    "l7vsadm_test",
3406                             "-L",
3407                             "-c",
3408                             "l7vsd_network"
3409                             };
3410
3411         bool ret = adm.parse_log_func_wp( cmd, argc, argv );
3412
3413         // unit_test[291] parse_log_func error case 2 (no loglevel) return value check
3414         BOOST_CHECK_EQUAL( ret, false );
3415     }
3416
3417     BOOST_MESSAGE( "----- parse_log_func_test end -----" );
3418
3419 }
3420
3421 void    parse_opt_snmp_log_category_func_test(){
3422     BOOST_MESSAGE( "----- parse_opt_snmp_log_category_func_test start -----" );
3423
3424     // parse_opt_snmp_log_category_func normal case 1
3425     {
3426         l7vsadm_test    adm;
3427         int        pos        = 2;
3428         int        argc    = 4;
3429         char*    argv[]    = { "l7vsadm_test", "-S", "-c", "snmpagent_start_stop" };
3430
3431         bool ret = adm.parse_opt_snmp_log_category_func_wp( pos, argc, argv );
3432
3433         // unit_test[292] parse_opt_snmp_log_category_func normal case 1 return value check
3434         BOOST_CHECK_EQUAL( ret, true );
3435         // unit_test[293] parse_opt_snmp_log_category_func normal case 1 logcategory check
3436         BOOST_CHECK_EQUAL( adm.get_request().snmp_log_category, l7vs::LOG_CAT_SNMPAGENT_START_STOP );
3437     }
3438
3439     // parse_opt_snmp_log_category_func error case 1 (invalid logcategory value)
3440     {
3441         l7vsadm_test    adm;
3442         int        pos        = 2;
3443         int        argc    = 4;
3444         char*    argv[]    = { "l7vsadm_test", "-S", "-c", "snmpagent" };
3445
3446         bool ret = adm.parse_opt_snmp_log_category_func_wp( pos, argc, argv );
3447
3448         // unit_test[294] parse_opt_snmp_log_category_func error case 1 (invalid logcategory value) return value check
3449         BOOST_CHECK_EQUAL( ret, false );
3450     }
3451
3452     // parse_opt_snmp_log_category_func error case 2 (no logcategory value)
3453     {
3454         l7vsadm_test    adm;
3455         int        pos        = 2;
3456         int        argc    = 3;
3457         char*    argv[]    = { "l7vsadm_test", "-S", "-c" };
3458
3459         bool ret = adm.parse_opt_snmp_log_category_func_wp( pos, argc, argv );
3460
3461         // unit_test[295] parse_opt_snmp_log_category_func error case 2 (no logcategory value) return value check
3462         BOOST_CHECK_EQUAL( ret, false );
3463     }
3464
3465     BOOST_MESSAGE( "----- parse_opt_snmp_log_category_func_test end -----" );
3466
3467 }
3468
3469 void    parse_opt_snmp_log_level_func_test(){
3470     BOOST_MESSAGE( "----- parse_opt_snmp_log_level_func_test start -----" );
3471
3472     // parse_opt_snmp_log_level_func normal case 1
3473     {
3474         l7vsadm_test    adm;
3475         int        pos        = 2;
3476         int        argc    = 4;
3477         char*    argv[]    = { "l7vsadm_test", "-S", "-l", "info" };
3478
3479         bool ret = adm.parse_opt_snmp_log_level_func_wp( pos, argc, argv );
3480
3481         // unit_test[296] parse_opt_snmp_log_level_func normal case 1 return value check
3482         BOOST_CHECK_EQUAL( ret, true );
3483         // unit_test[297] parse_opt_snmp_log_level_func normal case 1 loglevel check
3484         BOOST_CHECK_EQUAL( adm.get_request().snmp_log_level, l7vs::LOG_LV_INFO );
3485     }
3486
3487     // parse_opt_snmp_log_level_func error case 1 (invalid loglevel value)
3488     {
3489         l7vsadm_test    adm;
3490         int        pos        = 2;
3491         int        argc    = 4;
3492         char*    argv[]    = { "l7vsadm_test", "-S", "-l", "snmpagent" };
3493
3494         bool ret = adm.parse_opt_snmp_log_level_func_wp( pos, argc, argv );
3495
3496         // unit_test[298] parse_opt_snmp_log_level_func error case 1 (invalid loglevel value) return value check
3497         BOOST_CHECK_EQUAL( ret, false );
3498     }
3499
3500     // parse_opt_snmp_log_level_func error case 2 (no loglevel value)
3501     {
3502         l7vsadm_test    adm;
3503         int        pos        = 2;
3504         int        argc    = 3;
3505         char*    argv[]    = { "l7vsadm_test", "-S", "-l" };
3506
3507         bool ret = adm.parse_opt_snmp_log_level_func_wp( pos, argc, argv );
3508
3509         // unit_test[299] parse_opt_snmp_log_level_func error case 2 (no loglevel value) return value check
3510         BOOST_CHECK_EQUAL( ret, false );
3511     }
3512
3513     BOOST_MESSAGE( "----- parse_opt_snmp_log_level_func_test end -----" );
3514
3515 }
3516
3517 void    parse_snmp_func_test(){
3518     BOOST_MESSAGE( "----- parse_snmp_func_test start -----" );
3519
3520     // parse_snmp_func normal case 1
3521     {
3522         l7vsadm_test    adm;
3523         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_SNMP;
3524         int        argc    = 6;
3525         char*    argv[]    = {    "l7vsadm_test",
3526                             "-S",
3527                             "-c",
3528                             "snmpagent_start_stop",
3529                             "-l",
3530                             "warn"
3531                             };
3532
3533         bool ret = adm.parse_snmp_func_wp( cmd, argc, argv );
3534
3535         // unit_test[300] parse_snmp_func normal case 1 return value check
3536         BOOST_CHECK_EQUAL( ret, true );
3537         // unit_test[301] parse_snmp_func normal case 1 request command check
3538         BOOST_CHECK_EQUAL( adm.get_request().command, l7vs::l7vsadm_request::CMD_SNMP );
3539         // unit_test[302] parse_snmp_func normal case 1 logcategory check
3540         BOOST_CHECK_EQUAL( adm.get_request().snmp_log_category, l7vs::LOG_CAT_SNMPAGENT_START_STOP );
3541         // unit_test[303] parse_snmp_func normal case 1 logcategory check
3542         BOOST_CHECK_EQUAL( adm.get_request().snmp_log_level, l7vs::LOG_LV_WARN );
3543     }
3544
3545     // parse_snmp_func error case 1 (no logcategory)
3546     {
3547         l7vsadm_test    adm;
3548         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_SNMP;
3549         int        argc    = 4;
3550         char*    argv[]    = {    "l7vsadm_test",
3551                             "-S",
3552                             "-l",
3553                             "debug"
3554                             };
3555
3556         bool ret = adm.parse_snmp_func_wp( cmd, argc, argv );
3557
3558         // unit_test[304] parse_snmp_func error case 1 (no logcategory) return value check
3559         BOOST_CHECK_EQUAL( ret, false );
3560     }
3561
3562     // parse_snmp_func error case 2 (no loglevel)
3563     {
3564         l7vsadm_test    adm;
3565         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_SNMP;
3566         int        argc    = 4;
3567         char*    argv[]    = {    "l7vsadm_test",
3568                             "-S",
3569                             "-c",
3570                             "snmpagent_start_stop"
3571                             };
3572
3573         bool ret = adm.parse_snmp_func_wp( cmd, argc, argv );
3574
3575         // unit_test[305] parse_snmp_func error case 2 (no loglevel) return value check
3576         BOOST_CHECK_EQUAL( ret, false );
3577     }
3578
3579     BOOST_MESSAGE( "----- parse_snmp_func_test end -----" );
3580
3581 }
3582
3583 void    parse_opt_parameter_reload_func_test(){
3584     BOOST_MESSAGE( "----- parse_opt_parameter_reload_func_test start -----" );
3585
3586     // parse_opt_parameter_reload_func normal case 1
3587     {
3588         l7vsadm_test    adm;
3589         int        pos        = 2;
3590         int        argc    = 4;
3591         char*    argv[]    = { "l7vsadm_test", "-P", "-r", "replication" };
3592
3593         bool ret = adm.parse_opt_parameter_reload_func_wp( pos, argc, argv );
3594
3595         // unit_test[306] parse_opt_parameter_reload_func normal case 1 return value check
3596         BOOST_CHECK_EQUAL( ret, true );
3597         // unit_test[307] parse_opt_parameter_reload_func normal case 1 reload_component check
3598         BOOST_CHECK_EQUAL( adm.get_request().reload_param, l7vs::PARAM_COMP_REPLICATION );
3599     }
3600
3601     // parse_opt_parameter_reload_func error case 1 (invalid reload_component value)
3602     {
3603         l7vsadm_test    adm;
3604         int        pos        = 2;
3605         int        argc    = 4;
3606         char*    argv[]    = { "l7vsadm_test", "-P", "-r", "lsock" };
3607
3608         bool ret = adm.parse_opt_parameter_reload_func_wp( pos, argc, argv );
3609
3610         // unit_test[308] parse_opt_parameter_reload_func error case 1 (invalid reload_component value) return value check
3611         BOOST_CHECK_EQUAL( ret, false );
3612     }
3613
3614     // parse_opt_parameter_reload_func error case 2 (no reload_component value)
3615     {
3616         l7vsadm_test    adm;
3617         int        pos        = 2;
3618         int        argc    = 3;
3619         char*    argv[]    = { "l7vsadm_test", "-P", "-r" };
3620
3621         bool ret = adm.parse_opt_parameter_reload_func_wp( pos, argc, argv );
3622
3623         // unit_test[309] parse_opt_parameter_reload_func error case 2 (no reload_component value) return value check
3624         BOOST_CHECK_EQUAL( ret, false );
3625     }
3626
3627     BOOST_MESSAGE( "----- parse_opt_parameter_reload_func_test end -----" );
3628
3629 }
3630
3631 void    parse_parameter_func_test(){
3632     BOOST_MESSAGE( "----- parse_parameter_func_test start -----" );
3633
3634     // parse_parameter_func normal case 1
3635     {
3636         l7vsadm_test    adm;
3637         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_PARAMETER;
3638         int        argc    = 4;
3639         char*    argv[]    = {    "l7vsadm_test",
3640                             "-P",
3641                             "-r",
3642                             "logger"
3643                             };
3644
3645         bool ret = adm.parse_parameter_func_wp( cmd, argc, argv );
3646
3647         // unit_test[310] parse_parameter_func normal case 1 return value check
3648         BOOST_CHECK_EQUAL( ret, true );
3649         // unit_test[311] parse_parameter_func normal case 1 request command check
3650         BOOST_CHECK_EQUAL( adm.get_request().command, l7vs::l7vsadm_request::CMD_PARAMETER );
3651         // unit_test[312] parse_parameter_func normal case 1 reload_component check
3652         BOOST_CHECK_EQUAL( adm.get_request().reload_param, l7vs::PARAM_COMP_LOGGER );
3653     }
3654
3655     // parse_parameter_func error case 1 (no reload_component)
3656     {
3657         l7vsadm_test    adm;
3658         l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_PARAMETER;
3659         int        argc    = 2;
3660         char*    argv[]    = {    "l7vsadm_test",
3661                             "-P"
3662                             };
3663
3664         bool ret = adm.parse_parameter_func_wp( cmd, argc, argv );
3665
3666         // unit_test[313] parse_parameter_func error case 1 (no reload_component) return value check
3667         BOOST_CHECK_EQUAL( ret, false );
3668     }
3669
3670     BOOST_MESSAGE( "----- parse_parameter_func_test end -----" );
3671
3672 }
3673
3674 void    parse_opt_vs_fwdmode_func_test(){
3675     BOOST_MESSAGE( "----- parse_opt_vs_fwdmode_func_test start -----" );
3676
3677     // parse_opt_vs_fwdmode_func normal case 1 (masq)
3678     {
3679         l7vsadm_test  adm;
3680         int      pos  = 2;
3681         int      argc = 3;
3682         char*    argv1[] = { "l7vsadm_test", "-A", "-M" };
3683         char*    argv2[] = { "l7vsadm_test", "-A", "--masq" };
3684         bool     ret;
3685
3686         ret = adm.parse_opt_vs_fwdmode_func_wp( pos, argc, argv1 );
3687         BOOST_CHECK_EQUAL( ret, true );
3688         BOOST_CHECK_EQUAL( adm.get_request().vs_element.sorry_fwdmode, 1 );
3689
3690         ret = adm.parse_opt_vs_fwdmode_func_wp( pos, argc, argv2 );
3691         BOOST_CHECK_EQUAL( ret, true );
3692         BOOST_CHECK_EQUAL( adm.get_request().vs_element.sorry_fwdmode, 1 );
3693     }
3694
3695     // parse_opt_vs_fwdmode_func normal case 2 (tproxy)
3696     {
3697         l7vsadm_test  adm;
3698         int      pos  = 2;
3699         int      argc = 3;
3700         char*    argv1[] = { "l7vsadm_test", "-A", "-T" };
3701         char*    argv2[] = { "l7vsadm_test", "-A", "--tproxy" };
3702         bool     ret;
3703
3704         adm.get_request().vs_element.realserver_vector.push_back( l7vs::realserver_element() );
3705
3706         ret = adm.parse_opt_vs_fwdmode_func_wp( pos, argc, argv1 );
3707         BOOST_CHECK_EQUAL( ret, true );
3708         BOOST_CHECK_EQUAL( adm.get_request().vs_element.sorry_fwdmode, 2 );
3709
3710         ret = adm.parse_opt_vs_fwdmode_func_wp( pos, argc, argv2 );
3711         BOOST_CHECK_EQUAL( ret, true );
3712         BOOST_CHECK_EQUAL( adm.get_request().vs_element.sorry_fwdmode, 2 );
3713     }
3714
3715     BOOST_MESSAGE( "----- parse_opt_vs_fwdmode_func_test end -----" );
3716
3717 }
3718
3719 void    parse_opt_rs_fwdmode_func_test(){
3720     BOOST_MESSAGE( "----- parse_opt_rs_fwdmode_func_test start -----" );
3721
3722     // parse_opt_rs_fwdmode_func normal case 1 (masq)
3723     {
3724         l7vsadm_test  adm;
3725         int      pos  = 2;
3726         int      argc = 3;
3727         char*    argv1[] = { "l7vsadm_test", "-a", "-M" };
3728         char*    argv2[] = { "l7vsadm_test", "-a", "--masq" };
3729         bool     ret;
3730
3731         adm.get_request().vs_element.realserver_vector.push_back( l7vs::realserver_element() );
3732
3733         ret = adm.parse_opt_rs_fwdmode_func_wp( pos, argc, argv1 );
3734         BOOST_CHECK_EQUAL( ret, true );
3735         BOOST_CHECK_EQUAL( adm.get_request().vs_element.realserver_vector.front().fwdmode, 1 );
3736
3737         ret = adm.parse_opt_rs_fwdmode_func_wp( pos, argc, argv2 );
3738         BOOST_CHECK_EQUAL( ret, true );
3739         BOOST_CHECK_EQUAL( adm.get_request().vs_element.realserver_vector.front().fwdmode, 1 );
3740     }
3741
3742     // parse_opt_rs_fwdmode_func normal case 2 (tproxy)
3743     {
3744         l7vsadm_test  adm;
3745         int      pos  = 2;
3746         int      argc = 3;
3747         char*    argv1[] = { "l7vsadm_test", "-a", "-T" };
3748         char*    argv2[] = { "l7vsadm_test", "-a", "--tproxy" };
3749         bool     ret;
3750
3751         adm.get_request().vs_element.realserver_vector.push_back( l7vs::realserver_element() );
3752
3753         ret = adm.parse_opt_rs_fwdmode_func_wp( pos, argc, argv1 );
3754         BOOST_CHECK_EQUAL( ret, true );
3755         BOOST_CHECK_EQUAL( adm.get_request().vs_element.realserver_vector.front().fwdmode, 2 );
3756
3757         ret = adm.parse_opt_rs_fwdmode_func_wp( pos, argc, argv2 );
3758         BOOST_CHECK_EQUAL( ret, true );
3759         BOOST_CHECK_EQUAL( adm.get_request().vs_element.realserver_vector.front().fwdmode, 2 );
3760     }
3761
3762     BOOST_MESSAGE( "----- parse_opt_rs_fwdmode_func_test end -----" );
3763
3764 }
3765
3766 void    execute_test(){
3767     BOOST_MESSAGE( "----- execute_test start -----" );
3768
3769     // execute normal case 1 (no option)
3770     {
3771         l7vsadm_test    adm;
3772         int        argc    = 1;
3773         char*    argv[]    = {    "l7vsadm_test" };
3774
3775         test_request = l7vs::l7vsadm_request();
3776         test_response = l7vs::l7vsd_response();
3777         test_response.status = l7vs::l7vsd_response::RESPONSE_OK;
3778         test_response.virtualservice_status_list.push_back( l7vs::virtualservice_element() );
3779         test_response.virtualservice_status_list.push_back( l7vs::virtualservice_element() );
3780         typedef std::list< l7vs::virtualservice_element >    vse_list_type;
3781         for(    vse_list_type::iterator itr = test_response.virtualservice_status_list.begin();
3782                 itr != test_response.virtualservice_status_list.end();
3783                 ++itr ){
3784             itr->protocol_module_name = "protomod";
3785             itr->schedule_module_name = "sched";
3786             itr->realserver_vector.push_back( l7vs::realserver_element() );
3787             itr->realserver_vector.push_back( l7vs::realserver_element() );
3788         }
3789
3790         accept_ready = false;
3791         boost::thread    thd1( &server_thread );
3792         {
3793             // accept ready wait
3794             //boost::mutex::scoped_lock    lock( accept_mutex );
3795             //accept_condition.wait( lock );
3796             for(;;) { if(accept_ready)    break; }
3797         }
3798         bool ret = adm.execute_wp( argc, argv );
3799         thd1.join();
3800
3801         // unit_test[314] execute normal case 1 (no option) return value check
3802         BOOST_CHECK_EQUAL( ret, true );
3803         // unit_test[315] execute normal case 1 (no option) request command check
3804         BOOST_CHECK_EQUAL( test_request.command, l7vs::l7vsadm_request::CMD_LIST );
3805         // unit_test[316] execute normal case 1 (no option) response value check
3806         BOOST_CHECK_EQUAL( adm.get_response().virtualservice_status_list.size(), 2U );
3807     }
3808
3809
3810     // execute normal case 2 (list operation)
3811     {
3812         l7vsadm_test    adm;
3813         int        argc    = 2;
3814         char*    argv[]    = {    "l7vsadm_test",
3815                             "-l"
3816                             };
3817
3818         test_request = l7vs::l7vsadm_request();
3819         test_response = l7vs::l7vsd_response();
3820         test_response.status = l7vs::l7vsd_response::RESPONSE_OK;
3821         test_response.virtualservice_status_list.push_back( l7vs::virtualservice_element() );
3822         test_response.virtualservice_status_list.push_back( l7vs::virtualservice_element() );
3823         typedef std::list< l7vs::virtualservice_element >    vse_list_type;
3824         for(    vse_list_type::iterator itr = test_response.virtualservice_status_list.begin();
3825                 itr != test_response.virtualservice_status_list.end();
3826                 ++itr ){
3827             itr->protocol_module_name = "protomod";
3828             itr->schedule_module_name = "sched";
3829             itr->realserver_vector.push_back( l7vs::realserver_element() );
3830             itr->realserver_vector.push_back( l7vs::realserver_element() );
3831         }
3832
3833         accept_ready = false;
3834         boost::thread    thd1( &server_thread );
3835         {
3836             //boost::mutex::scoped_lock    lock( accept_mutex );
3837             //accept_condition.wait( lock );
3838             for(;;) { if(accept_ready)    break; }
3839         }
3840         bool ret = adm.execute_wp( argc, argv );
3841         thd1.join();
3842
3843         // unit_test[317] execute normal case 2 (list operation) return value check
3844         BOOST_CHECK_EQUAL( ret, true );
3845         // unit_test[318] execute normal case 2 (list operation) request command check
3846         BOOST_CHECK_EQUAL( test_request.command, l7vs::l7vsadm_request::CMD_LIST );
3847         // unit_test[319] execute normal case 2 (list operation) response value check
3848         BOOST_CHECK_EQUAL( adm.get_response().virtualservice_status_list.size(), 2U );
3849     }
3850
3851     // execute normal case 3 (list operation numeric)
3852     {
3853         l7vsadm_test    adm;
3854         int        argc    = 3;
3855         char*    argv[]    = {    "l7vsadm_test",
3856                             "-l",
3857                             "-n"
3858                             };
3859
3860         test_request = l7vs::l7vsadm_request();
3861         test_response = l7vs::l7vsd_response();
3862         test_response.status = l7vs::l7vsd_response::RESPONSE_OK;
3863         test_response.virtualservice_status_list.push_back( l7vs::virtualservice_element() );
3864         test_response.virtualservice_status_list.push_back( l7vs::virtualservice_element() );
3865         typedef std::list< l7vs::virtualservice_element >    vse_list_type;
3866         for(    vse_list_type::iterator itr = test_response.virtualservice_status_list.begin();
3867                 itr != test_response.virtualservice_status_list.end();
3868                 ++itr ){
3869             itr->protocol_module_name = "protomod";
3870             itr->schedule_module_name = "sched";
3871             itr->realserver_vector.push_back( l7vs::realserver_element() );
3872             itr->realserver_vector.push_back( l7vs::realserver_element() );
3873         }
3874
3875         accept_ready = false;
3876         boost::thread    thd1( &server_thread );
3877         {
3878             //boost::mutex::scoped_lock    lock( accept_mutex );
3879             //accept_condition.wait( lock );
3880             for(;;) { if(accept_ready)    break; }
3881         }
3882         bool ret = adm.execute_wp( argc, argv );
3883         thd1.join();
3884
3885         // unit_test[320] execute normal case 3 (list operation numeric) return value check
3886         BOOST_CHECK_EQUAL( ret, true );
3887         // unit_test[321] execute normal case 3 (list operation numeric) request command check
3888         BOOST_CHECK_EQUAL( test_request.command, l7vs::l7vsadm_request::CMD_LIST );
3889         // unit_test[322] execute normal case 3 (list operation numeric) response value check
3890         BOOST_CHECK_EQUAL( adm.get_response().virtualservice_status_list.size(), 2U );
3891
3892     }
3893
3894     // execute normal case 4 (list operation key)
3895     {
3896         l7vsadm_test    adm;
3897         int        argc    = 2;
3898         char*    argv[]    = {    "l7vsadm_test",
3899                             "-K"
3900                             };
3901
3902         test_request = l7vs::l7vsadm_request();
3903         test_response = l7vs::l7vsd_response();
3904         test_response.status = l7vs::l7vsd_response::RESPONSE_OK;
3905         test_response.virtualservice_status_list.push_back( l7vs::virtualservice_element() );
3906         test_response.virtualservice_status_list.push_back( l7vs::virtualservice_element() );
3907         typedef std::list< l7vs::virtualservice_element >    vse_list_type;
3908         for(    vse_list_type::iterator itr = test_response.virtualservice_status_list.begin();
3909                 itr != test_response.virtualservice_status_list.end();
3910                 ++itr ){
3911             itr->protocol_module_name = "protomod";
3912             itr->schedule_module_name = "sched";
3913             itr->realserver_vector.push_back( l7vs::realserver_element() );
3914             itr->realserver_vector.push_back( l7vs::realserver_element() );
3915         }
3916
3917         accept_ready = false;
3918         boost::thread    thd1( &server_thread );
3919         {
3920             //boost::mutex::scoped_lock    lock( accept_mutex );
3921             //accept_condition.wait( lock );
3922             for(;;) { if(accept_ready)    break; }
3923         }
3924         bool ret = adm.execute_wp( argc, argv );
3925         thd1.join();
3926
3927         // unit_test[323] execute normal case 4 (list operation key) return value check
3928         BOOST_CHECK_EQUAL( ret, true );
3929         // unit_test[324] execute normal case 4 (list operation key) request command check
3930         BOOST_CHECK_EQUAL( test_request.command, l7vs::l7vsadm_request::CMD_LIST_KEY );
3931         // unit_test[325] execute normal case 4 (list operation key) response value check
3932         BOOST_CHECK_EQUAL( adm.get_response().virtualservice_status_list.size(), 2U );
3933     }
3934
3935     // execute normal case 5 (list operation verbose)
3936     {
3937         l7vsadm_test    adm;
3938         int        argc    = 2;
3939         char*    argv[]    = {    "l7vsadm_test",
3940                             "-V"
3941                             };
3942
3943         test_request = l7vs::l7vsadm_request();
3944         test_response = l7vs::l7vsd_response();
3945         test_response.status = l7vs::l7vsd_response::RESPONSE_OK;
3946         test_response.virtualservice_status_list.push_back( l7vs::virtualservice_element() );
3947         test_response.virtualservice_status_list.push_back( l7vs::virtualservice_element() );
3948         typedef std::list< l7vs::virtualservice_element >    vse_list_type;
3949         for(    vse_list_type::iterator itr = test_response.virtualservice_status_list.begin();
3950                 itr != test_response.virtualservice_status_list.end();
3951                 ++itr ){
3952             itr->protocol_module_name = "protomod";
3953             itr->schedule_module_name = "sched";
3954             itr->realserver_vector.push_back( l7vs::realserver_element() );
3955             itr->realserver_vector.push_back( l7vs::realserver_element() );
3956         }
3957
3958         accept_ready = false;
3959         boost::thread    thd1( &server_thread );
3960         {
3961             //boost::mutex::scoped_lock    lock( accept_mutex );
3962             //accept_condition.wait( lock );
3963             for(;;) { if(accept_ready)    break; }
3964         }
3965         bool ret = adm.execute_wp( argc, argv );
3966         thd1.join();
3967
3968         // unit_test[326] execute normal case 5 (list operation verbose) return value check
3969         BOOST_CHECK_EQUAL( ret, true );
3970         // unit_test[327] execute normal case 5 (list operation verbose) request command check
3971         BOOST_CHECK_EQUAL( test_request.command, l7vs::l7vsadm_request::CMD_LIST_VERBOSE );
3972         // unit_test[328] execute normal case 5 (list operation verbose) response value check
3973         BOOST_CHECK_EQUAL( adm.get_response().virtualservice_status_list.size(), 2U );
3974     }
3975
3976     // execute normal case 6 (vs operation add-vs)
3977     {
3978         l7vsadm_test    adm;
3979         int        argc    = 17;
3980         char*    argv[]    = {    "l7vsadm_test",
3981                             "-A",
3982                             "-t",
3983                             "10.144.169.87:22100",
3984                             "-m",
3985                             "cinsert",
3986                             "mod_arg",
3987                             "-s",
3988                             "lc",
3989                             "-u",
3990                             "50",
3991                             "-b",
3992                             "10.144.169.86:8080",
3993                             "-Q",
3994                             "100M",
3995                             "-q",
3996                             "200M"
3997                             };
3998
3999         test_request = l7vs::l7vsadm_request();
4000         test_response = l7vs::l7vsd_response();
4001         test_response.status = l7vs::l7vsd_response::RESPONSE_OK;
4002
4003         accept_ready = false;
4004         boost::thread    thd1( &server_thread );
4005         {
4006             //boost::mutex::scoped_lock    lock( accept_mutex );
4007             //accept_condition.wait( lock );
4008             for(;;) { if(accept_ready)    break; }
4009         }
4010         bool ret = adm.execute_wp( argc, argv );
4011         thd1.join();
4012
4013         // unit_test[329] execute normal case 6 (vs operation add-vs) return value check
4014         BOOST_CHECK_EQUAL( ret, true );
4015         // unit_test[330] execute normal case 6 (vs operation add-vs) request command check
4016         BOOST_CHECK_EQUAL( test_request.command, l7vs::l7vsadm_request::CMD_ADD_VS );
4017         // unit_test[331] execute normal case 6 (vs operation add-vs) tcp_accept_endpoint check
4018         boost::asio::ip::tcp::endpoint    tcp_acc_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.87:22100" );
4019         BOOST_CHECK_EQUAL( test_request.vs_element.tcp_accept_endpoint, tcp_acc_ep );
4020         // unit_test[332] execute normal case 6 (vs operation add-vs) protocol module name check
4021         BOOST_CHECK_EQUAL( test_request.vs_element.protocol_module_name, "cinsert" );
4022         // unit_test[333] execute normal case 6 (vs operation add-vs) protocol module arg check
4023         BOOST_CHECK_EQUAL( test_request.vs_element.protocol_args.front(), "mod_arg" );
4024         // unit_test[334] execute normal case 6 (vs operation add-vs) schedule module name check
4025         BOOST_CHECK_EQUAL( test_request.vs_element.schedule_module_name, "lc" );
4026         // unit_test[335] execute normal case 6 (vs operation add-vs) sorry_maxconnection check
4027         BOOST_CHECK_EQUAL( test_request.vs_element.sorry_maxconnection, 50 );
4028         // unit_test[336] execute normal case 6 (vs operation add-vs) sorry_endpoint check
4029         boost::asio::ip::tcp::endpoint    sorry_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.86:8080" );
4030         BOOST_CHECK_EQUAL( test_request.vs_element.sorry_endpoint, sorry_ep );
4031         // unit_test[337] execute normal case 6 (vs operation add-vs) qos_upstream check
4032         BOOST_CHECK_EQUAL( test_request.vs_element.qos_upstream, ( 100000000ULL / 8 ) );
4033         // unit_test[338] execute normal case 6 (vs operation add-vs) qos_downstream check
4034         BOOST_CHECK_EQUAL( test_request.vs_element.qos_downstream, ( 200000000ULL / 8 ) );
4035     }
4036
4037     // execute normal case 7 (vs operation edit-vs)
4038     {
4039         l7vsadm_test    adm;
4040         int        argc    = 19;
4041         char*    argv[]    = {    "l7vsadm_test",
4042                             "-E",
4043                             "-t",
4044                             "10.144.169.87:22100",
4045                             "-m",
4046                             "cinsert",
4047                             "mod_arg",
4048                             "-s",
4049                             "rr",
4050                             "-u",
4051                             "50",
4052                             "-b",
4053                             "10.144.169.86:8080",
4054                             "-f",
4055                             "1",
4056                             "-Q",
4057                             "100M",
4058                             "-q",
4059                             "200M"
4060                             };
4061
4062         test_request = l7vs::l7vsadm_request();
4063         test_response = l7vs::l7vsd_response();
4064         test_response.status = l7vs::l7vsd_response::RESPONSE_OK;
4065
4066         accept_ready = false;
4067         boost::thread    thd1( &server_thread );
4068         {
4069             //boost::mutex::scoped_lock    lock( accept_mutex );
4070             //accept_condition.wait( lock );
4071             for(;;) { if(accept_ready)    break; }
4072         }
4073         bool ret = adm.execute_wp( argc, argv );
4074         thd1.join();
4075
4076         // unit_test[339] execute normal case 7 (vs operation edit-vs) return value check
4077         BOOST_CHECK_EQUAL( ret, true );
4078         // unit_test[340] execute normal case 7 (vs operation edit-vs) request command check
4079         BOOST_CHECK_EQUAL( test_request.command, l7vs::l7vsadm_request::CMD_EDIT_VS );
4080         // unit_test[341] execute normal case 7 (vs operation edit-vs) tcp_accept_endpoint check
4081         boost::asio::ip::tcp::endpoint    tcp_acc_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.87:22100" );
4082         BOOST_CHECK_EQUAL( test_request.vs_element.tcp_accept_endpoint, tcp_acc_ep );
4083         // unit_test[342] execute normal case 7 (vs operation edit-vs) protocol module name check
4084         BOOST_CHECK_EQUAL( test_request.vs_element.protocol_module_name, "cinsert" );
4085         // unit_test[343] execute normal case 7 (vs operation edit-vs) protocol module arg check
4086         BOOST_CHECK_EQUAL( test_request.vs_element.protocol_args.front(), "mod_arg" );
4087         // unit_test[344] execute normal case 7 (vs operation edit-vs) schedule module name check
4088         BOOST_CHECK_EQUAL( test_request.vs_element.schedule_module_name, "rr" );
4089         // unit_test[345] execute normal case 7 (vs operation edit-vs) sorry_maxconnection check
4090         BOOST_CHECK_EQUAL( test_request.vs_element.sorry_maxconnection, 50 );
4091         // unit_test[346] execute normal case 7 (vs operation edit-vs) sorry_endpoint check
4092         boost::asio::ip::tcp::endpoint    sorry_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.86:8080" );
4093         BOOST_CHECK_EQUAL( test_request.vs_element.sorry_endpoint, sorry_ep );
4094         // unit_test[347] execute normal case 7 (vs operation edit-vs) sorry_flag check
4095         BOOST_CHECK_EQUAL( adm.get_request().vs_element.sorry_flag, true );
4096         // unit_test[348] execute normal case 7 (vs operation edit-vs) qos_upstream check
4097         BOOST_CHECK_EQUAL( test_request.vs_element.qos_upstream, ( 100000000ULL / 8 ) );
4098         // unit_test[349] execute normal case 7 (vs operation edit-vs) qos_downstream check
4099         BOOST_CHECK_EQUAL( test_request.vs_element.qos_downstream, ( 200000000ULL / 8 ) );
4100     }
4101
4102     // execute normal case 8 (vs operation del-vs)
4103     {
4104         l7vsadm_test    adm;
4105         int        argc    = 7;
4106         char*    argv[]    = {    "l7vsadm_test",
4107                             "-D",
4108                             "-t",
4109                             "10.144.169.87:22100",
4110                             "-m",
4111                             "cinsert",
4112                             "mod_arg"
4113                             };
4114
4115         test_request = l7vs::l7vsadm_request();
4116         test_response = l7vs::l7vsd_response();
4117         test_response.status = l7vs::l7vsd_response::RESPONSE_OK;
4118
4119         accept_ready = false;
4120         boost::thread    thd1( &server_thread );
4121         {
4122             //boost::mutex::scoped_lock    lock( accept_mutex );
4123             //accept_condition.wait( lock );
4124             for(;;) { if(accept_ready)    break; }
4125         }
4126         bool ret = adm.execute_wp( argc, argv );
4127         thd1.join();
4128
4129         // unit_test[350] execute normal case 8 (vs operation del-vs) return value check
4130         BOOST_CHECK_EQUAL( ret, true );
4131         // unit_test[351] execute normal case 8 (vs operation del-vs) request command check
4132         BOOST_CHECK_EQUAL( test_request.command, l7vs::l7vsadm_request::CMD_DEL_VS );
4133         // unit_test[352] execute normal case 8 (vs operation del-vs) tcp_accept_endpoint check
4134         boost::asio::ip::tcp::endpoint    tcp_acc_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.87:22100" );
4135         BOOST_CHECK_EQUAL( adm.get_request().vs_element.tcp_accept_endpoint, tcp_acc_ep );
4136         // unit_test[353] execute normal case 8 (vs operation del-vs) protocol module name check
4137         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
4138         // unit_test[354] execute normal case 8 (vs operation del-vs) protocol module arg check
4139         BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "mod_arg" );
4140     }
4141
4142     // execute normal case 9 (vs operation flush-vs)
4143     {
4144         l7vsadm_test    adm;
4145         int        argc    = 2;
4146         char*    argv[]    = {    "l7vsadm_test",
4147                             "-C"
4148                             };
4149
4150         test_request = l7vs::l7vsadm_request();
4151         test_response = l7vs::l7vsd_response();
4152         test_response.status = l7vs::l7vsd_response::RESPONSE_OK;
4153
4154         accept_ready = false;
4155         boost::thread    thd1( &server_thread );
4156         {
4157             //boost::mutex::scoped_lock    lock( accept_mutex );
4158             //accept_condition.wait( lock );
4159             for(;;) { if(accept_ready)    break; }
4160         }
4161         bool ret = adm.execute_wp( argc, argv );
4162         thd1.join();
4163
4164         // unit_test[355] execute normal case 9 (vs operation flush-vs) return value check
4165         BOOST_CHECK_EQUAL( ret, true );
4166         // unit_test[356] execute normal case 9 (vs operation flush-vs) request command check
4167         BOOST_CHECK_EQUAL( test_request.command, l7vs::l7vsadm_request::CMD_FLUSH_VS );
4168     }
4169
4170     // execute normal case 10 (rs operation add-rs)
4171     {
4172         l7vsadm_test    adm;
4173         int        argc    = 11;
4174         char*    argv[]    = {    "l7vsadm_test",
4175                             "-a",
4176                             "-t",
4177                             "10.144.169.87:22100",
4178                             "-m",
4179                             "cinsert",
4180                             "mod_arg",
4181                             "-r",
4182                             "10.144.169.86:8080",
4183                             "-w",
4184                             "10"
4185                             };
4186
4187         test_request = l7vs::l7vsadm_request();
4188         test_response = l7vs::l7vsd_response();
4189         test_response.status = l7vs::l7vsd_response::RESPONSE_OK;
4190
4191         accept_ready = false;
4192         boost::thread    thd1( &server_thread );
4193         {
4194             //boost::mutex::scoped_lock    lock( accept_mutex );
4195             //accept_condition.wait( lock );
4196             for(;;) { if(accept_ready)    break; }
4197         }
4198         bool ret = adm.execute_wp( argc, argv );
4199         thd1.join();
4200
4201         // unit_test[357] execute normal case 10 (rs operation add-rs) return value check
4202         BOOST_CHECK_EQUAL( ret, true );
4203         // unit_test[358] execute normal case 10 (rs operation add-rs) request command check
4204         BOOST_CHECK_EQUAL( test_request.command, l7vs::l7vsadm_request::CMD_ADD_RS );
4205         // unit_test[359] execute normal case 10 (rs operation add-rs) tcp_accept_endpoint check
4206         boost::asio::ip::tcp::endpoint    tcp_acc_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.87:22100" );
4207         BOOST_CHECK_EQUAL( test_request.vs_element.tcp_accept_endpoint, tcp_acc_ep );
4208         // unit_test[360] execute normal case 10 (rs operation add-rs) protocol module name check
4209         BOOST_CHECK_EQUAL( test_request.vs_element.protocol_module_name, "cinsert" );
4210         // unit_test[361] execute normal case 10 (rs operation add-rs) protocol module arg check
4211         BOOST_CHECK_EQUAL( test_request.vs_element.protocol_args.front(), "mod_arg" );
4212         // unit_test[362] execute normal case 10 (rs operation add-rs) realserver endpoint check
4213         boost::asio::ip::tcp::endpoint    rs_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.86:8080" );
4214         BOOST_CHECK_EQUAL( test_request.vs_element.realserver_vector.front().tcp_endpoint, rs_ep );
4215         // unit_test[363] execute normal case 10 (rs operation add-rs) weight check
4216         BOOST_CHECK_EQUAL( test_request.vs_element.realserver_vector.front().weight, 10 );
4217     }
4218
4219     // execute normal case 11 (rs operation edit-rs)
4220     {
4221         l7vsadm_test    adm;
4222         int        argc    = 11;
4223         char*    argv[]    = {    "l7vsadm_test",
4224                             "-e",
4225                             "-t",
4226                             "10.144.169.87:22100",
4227                             "-m",
4228                             "cinsert",
4229                             "mod_arg",
4230                             "-r",
4231                             "10.144.169.86:8080",
4232                             "-w",
4233                             "20"
4234                             };
4235
4236         test_request = l7vs::l7vsadm_request();
4237         test_response = l7vs::l7vsd_response();
4238         test_response.status = l7vs::l7vsd_response::RESPONSE_OK;
4239
4240         accept_ready = false;
4241         boost::thread    thd1( &server_thread );
4242         {
4243             //boost::mutex::scoped_lock    lock( accept_mutex );
4244             //accept_condition.wait( lock );
4245             for(;;) { if(accept_ready)    break; }
4246         }
4247         bool ret = adm.execute_wp( argc, argv );
4248         thd1.join();
4249
4250         // unit_test[364] execute normal case 11 (rs operation edit-rs) return value check
4251         BOOST_CHECK_EQUAL( ret, true );
4252         // unit_test[365] execute normal case 11 (rs operation edit-rs) request command check
4253         BOOST_CHECK_EQUAL( test_request.command, l7vs::l7vsadm_request::CMD_EDIT_RS );
4254         // unit_test[366] execute normal case 11 (rs operation edit-rs) tcp_accept_endpoint check
4255         boost::asio::ip::tcp::endpoint    tcp_acc_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.87:22100" );
4256         BOOST_CHECK_EQUAL( test_request.vs_element.tcp_accept_endpoint, tcp_acc_ep );
4257         // unit_test[367] execute normal case 11 (rs operation edit-rs) protocol module name check
4258         BOOST_CHECK_EQUAL( test_request.vs_element.protocol_module_name, "cinsert" );
4259         // unit_test[368] execute normal case 11 (rs operation edit-rs) protocol module arg check
4260         BOOST_CHECK_EQUAL( test_request.vs_element.protocol_args.front(), "mod_arg" );
4261         // unit_test[369] execute normal case 11 (rs operation edit-rs) realserver endpoint check
4262         boost::asio::ip::tcp::endpoint    rs_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.86:8080" );
4263         BOOST_CHECK_EQUAL( test_request.vs_element.realserver_vector.front().tcp_endpoint, rs_ep );
4264         // unit_test[370] execute normal case 11 (rs operation edit-rs) weight check
4265         BOOST_CHECK_EQUAL( test_request.vs_element.realserver_vector.front().weight, 20 );
4266     }
4267
4268     // execute normal case 12 (rs operation del-rs)
4269     {
4270         l7vsadm_test    adm;
4271         int        argc    = 9;
4272         char*    argv[]    = {    "l7vsadm_test",
4273                             "-d",
4274                             "-t",
4275                             "10.144.169.87:22100",
4276                             "-m",
4277                             "cinsert",
4278                             "mod_arg",
4279                             "-r",
4280                             "10.144.169.86:8080"
4281                             };
4282
4283         test_request = l7vs::l7vsadm_request();
4284         test_response = l7vs::l7vsd_response();
4285         test_response.status = l7vs::l7vsd_response::RESPONSE_OK;
4286
4287         accept_ready = false;
4288         boost::thread    thd1( &server_thread );
4289         {
4290             //boost::mutex::scoped_lock    lock( accept_mutex );
4291             //accept_condition.wait( lock );
4292             for(;;) { if(accept_ready)    break; }
4293         }
4294         bool ret = adm.execute_wp( argc, argv );
4295         thd1.join();
4296
4297         // unit_test[371] execute normal case 12 (rs operation del-rs) return value check
4298         BOOST_CHECK_EQUAL( ret, true );
4299         // unit_test[372] execute normal case 12 (rs operation del-rs) request command check
4300         BOOST_CHECK_EQUAL( test_request.command, l7vs::l7vsadm_request::CMD_DEL_RS );
4301         // unit_test[373] execute normal case 12 (rs operation del-rs) tcp_accept_endpoint check
4302         boost::asio::ip::tcp::endpoint    tcp_acc_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.87:22100" );
4303         BOOST_CHECK_EQUAL( test_request.vs_element.tcp_accept_endpoint, tcp_acc_ep );
4304         // unit_test[374] execute normal case 12 (rs operation del-rs) protocol module name check
4305         BOOST_CHECK_EQUAL( test_request.vs_element.protocol_module_name, "cinsert" );
4306         // unit_test[375] execute normal case 12 (rs operation del-rs) protocol module arg check
4307         BOOST_CHECK_EQUAL( test_request.vs_element.protocol_args.front(), "mod_arg" );
4308         // unit_test[376] execute normal case 12 (rs operation del-rs) realserver endpoint check
4309         boost::asio::ip::tcp::endpoint    rs_ep = string_to_endpoint<boost::asio::ip::tcp>( "10.144.169.86:8080" );
4310         BOOST_CHECK_EQUAL( test_request.vs_element.realserver_vector.front().tcp_endpoint, rs_ep );
4311     }
4312
4313     // execute normal case 13 (replication operation)
4314     {
4315         l7vsadm_test    adm;
4316         int        argc    = 4;
4317         char*    argv[]    = {    "l7vsadm_test",
4318                             "-R",
4319                             "-s",
4320                             "start"
4321                             };
4322
4323         test_request = l7vs::l7vsadm_request();
4324         test_response = l7vs::l7vsd_response();
4325         test_response.status = l7vs::l7vsd_response::RESPONSE_OK;
4326
4327         accept_ready = false;
4328         boost::thread    thd1( &server_thread );
4329         {
4330             //boost::mutex::scoped_lock    lock( accept_mutex );
4331             //accept_condition.wait( lock );
4332             for(;;) { if(accept_ready)    break; }
4333         }
4334         bool ret = adm.execute_wp( argc, argv );
4335         thd1.join();
4336
4337         // unit_test[377] execute normal case 13 (replication operation) return value check
4338         BOOST_CHECK_EQUAL( ret, true );
4339         // unit_test[378] execute normal case 13 (replication operation) request command check
4340         BOOST_CHECK_EQUAL( test_request.command, l7vs::l7vsadm_request::CMD_REPLICATION );
4341         // unit_test[379] execute normal case 13 (replication operation) replication command check
4342         BOOST_CHECK_EQUAL( test_request.replication_command, l7vs::l7vsadm_request::REP_START );
4343     }
4344
4345     // execute normal case 14 (log operation)
4346     {
4347         l7vsadm_test    adm;
4348         int        argc    = 6;
4349         char*    argv[]    = {    "l7vsadm_test",
4350                             "-L",
4351                             "-c",
4352                             "l7vsd_network",
4353                             "-l",
4354                             "debug"
4355                             };
4356
4357         test_request = l7vs::l7vsadm_request();
4358         test_response = l7vs::l7vsd_response();
4359         test_response.status = l7vs::l7vsd_response::RESPONSE_OK;
4360
4361         accept_ready = false;
4362         boost::thread    thd1( &server_thread );
4363         {
4364             //boost::mutex::scoped_lock    lock( accept_mutex );
4365             //accept_condition.wait( lock );
4366             for(;;) { if(accept_ready)    break; }
4367         }
4368         bool ret = adm.execute_wp( argc, argv );
4369         thd1.join();
4370
4371         // unit_test[380] execute normal case 14 (log operation) return value check
4372         BOOST_CHECK_EQUAL( ret, true );
4373         // unit_test[381] execute normal case 14 (log operation) request command check
4374         BOOST_CHECK_EQUAL( test_request.command, l7vs::l7vsadm_request::CMD_LOG );
4375         // unit_test[382] execute normal case 14 (log operation) logcategory check
4376         BOOST_CHECK_EQUAL( test_request.log_category, l7vs::LOG_CAT_L7VSD_NETWORK );
4377         // unit_test[383] execute normal case 14 (log operation) logcategory check
4378         BOOST_CHECK_EQUAL( test_request.log_level, l7vs::LOG_LV_DEBUG );
4379     }
4380
4381     // execute normal case 15 (snmp log operation)
4382     {
4383         l7vsadm_test    adm;
4384         int        argc    = 6;
4385         char*    argv[]    = {    "l7vsadm_test",
4386                             "-S",
4387                             "-c",
4388                             "snmpagent_start_stop",
4389                             "-l",
4390                             "warn"
4391                             };
4392
4393         test_request = l7vs::l7vsadm_request();
4394         test_response = l7vs::l7vsd_response();
4395         test_response.status = l7vs::l7vsd_response::RESPONSE_OK;
4396
4397         accept_ready = false;
4398         boost::thread    thd1( &server_thread );
4399         {
4400             //boost::mutex::scoped_lock    lock( accept_mutex );
4401             //accept_condition.wait( lock );
4402             for(;;) { if(accept_ready)    break; }
4403         }
4404         bool ret = adm.execute_wp( argc, argv );
4405         thd1.join();
4406
4407         // unit_test[384] execute normal case 15 (snmp log operation) return value check
4408         BOOST_CHECK_EQUAL( ret, true );
4409         // unit_test[385] execute normal case 15 (snmp log operation) request command check
4410         BOOST_CHECK_EQUAL( test_request.command, l7vs::l7vsadm_request::CMD_SNMP );
4411         // unit_test[386] execute normal case 15 (snmp log operation) logcategory check
4412         BOOST_CHECK_EQUAL( test_request.snmp_log_category, l7vs::LOG_CAT_SNMPAGENT_START_STOP );
4413         // unit_test[387] execute normal case 15 (snmp log operation) logcategory check
4414         BOOST_CHECK_EQUAL( test_request.snmp_log_level, l7vs::LOG_LV_WARN );
4415     }
4416
4417     // execute normal case 16 (parameter operation)
4418     {
4419         l7vsadm_test    adm;
4420         int        argc    = 4;
4421         char*    argv[]    = {    "l7vsadm_test",
4422                             "-P",
4423                             "-r",
4424                             "logger"
4425                             };
4426
4427         test_request = l7vs::l7vsadm_request();
4428         test_response = l7vs::l7vsd_response();
4429         test_response.status = l7vs::l7vsd_response::RESPONSE_OK;
4430
4431         accept_ready = false;
4432         boost::thread    thd1( &server_thread );
4433         {
4434             //boost::mutex::scoped_lock    lock( accept_mutex );
4435             //accept_condition.wait( lock );
4436             for(;;) { if(accept_ready)    break; }
4437         }
4438         bool ret = adm.execute_wp( argc, argv );
4439         thd1.join();
4440
4441         // unit_test[388] execute normal case 16 (parameter operation) return value check
4442         BOOST_CHECK_EQUAL( ret, true );
4443         // unit_test[389] execute normal case 16 (parameter operation) request command check
4444         BOOST_CHECK_EQUAL( test_request.command, l7vs::l7vsadm_request::CMD_PARAMETER );
4445         // unit_test[390] execute normal case 16 (parameter operation) reload_component check
4446         BOOST_CHECK_EQUAL( test_request.reload_param, l7vs::PARAM_COMP_LOGGER );
4447     }
4448
4449     // execute normal case 17 (help operation)
4450     {
4451         l7vsadm_test    adm;
4452         int        argc    = 2;
4453         char*    argv[]    = {    "l7vsadm_test",
4454                             "-h"
4455                             };
4456
4457         test_request = l7vs::l7vsadm_request();
4458         test_response = l7vs::l7vsd_response();
4459
4460         bool ret = adm.execute_wp( argc, argv );
4461
4462         // unit_test[391] execute normal case 17 (help operation) return value check
4463         BOOST_CHECK_EQUAL( ret, true );
4464         // unit_test[392] execute normal case 17 (help operation) request command check
4465         BOOST_CHECK_EQUAL( adm.get_request().command, l7vs::l7vsadm_request::CMD_HELP );
4466     }
4467
4468     // execute error case 1 (invalid operation)
4469     {
4470         l7vsadm_test    adm;
4471         int        argc    = 2;
4472         char*    argv[]    = {    "l7vsadm_test",
4473                             "-Z"
4474                             };
4475
4476         test_request = l7vs::l7vsadm_request();
4477         test_response = l7vs::l7vsd_response();
4478
4479         bool ret = adm.execute_wp( argc, argv );
4480
4481         // unit_test[393] execute 1 (invalid operation) return value check
4482         BOOST_CHECK_EQUAL( ret, false );
4483     }
4484
4485     BOOST_MESSAGE( "----- execute_test end -----" );
4486
4487 }
4488
4489 void    l7vsadm_test::file_lock_class_test(){
4490     BOOST_MESSAGE( "----- file_lock_class_test start -----" );
4491
4492     char file_path[256];
4493     memset(file_path, 0, sizeof(file_path));
4494     readlink("/proc/self/exe", file_path, sizeof(file_path));
4495
4496     {
4497         l7vs::error_code    err;
4498
4499         // unit_test[394] file_lock_class normal case 1 (first lock) error check
4500         l7vs::l7vsadm::file_lock    lock( file_path, err );
4501         BOOST_CHECK( !err );
4502
4503         // unit_test[395] file_lock_class normal case 1 (first lock) locable check
4504         bool ret = lock.try_lock();
4505         BOOST_CHECK( ret );
4506
4507         l7vs::error_code    err2;
4508         // unit_test[396] file_lock_class normal case 2 (second lock) error check
4509         l7vs::l7vsadm::file_lock    lock2( file_path, err2 );
4510         BOOST_CHECK( !err );
4511
4512         // unit_test[397] file_lock_class normal case 2 (second lock) unlocable check
4513         ret = lock2.try_lock();
4514         BOOST_CHECK( !ret );
4515     }
4516
4517     {
4518         l7vs::error_code    err;
4519
4520         // unit_test[398] file_lock_class normal case 3 (relock) error check
4521         l7vs::l7vsadm::file_lock    lock( file_path, err );
4522         BOOST_CHECK( !err );
4523
4524         // unit_test[399] file_lock_class normal case 3 (relock) locable check
4525         bool ret = lock.try_lock();
4526         BOOST_CHECK( ret );
4527     }
4528
4529     BOOST_MESSAGE( "----- file_lock_class_test end -----" );
4530
4531 }
4532
4533
4534 test_suite*    init_unit_test_suite( int argc, char* argv[] ){
4535     test_suite* ts = BOOST_TEST_SUITE( "l7vsd class test" );
4536
4537     l7vs::Logger    logger_instance;
4538     l7vs::Parameter    parameter_instance;
4539     logger_instance.loadConf();
4540
4541     ts->add( BOOST_TEST_CASE( &parse_list_func_test ) );
4542
4543     ts->add( BOOST_TEST_CASE( &parse_opt_vs_target_func_test ) );
4544     ts->add( BOOST_TEST_CASE( &parse_opt_vs_module_func_test ) );
4545     ts->add( BOOST_TEST_CASE( &parse_opt_vs_scheduler_func_test ) );
4546     ts->add( BOOST_TEST_CASE( &parse_opt_vs_upper_func_test ) );
4547     ts->add( BOOST_TEST_CASE( &parse_opt_vs_bypass_func_test ) );
4548     ts->add( BOOST_TEST_CASE( &parse_opt_vs_qosup_func_test ) );
4549     ts->add( BOOST_TEST_CASE( &parse_opt_vs_qosdown_func_test ) );
4550     ts->add( BOOST_TEST_CASE( &parse_opt_vs_udp_func_test ) );
4551
4552     ts->add( BOOST_TEST_CASE( &parse_opt_vs_ssl_file_func_test ) );
4553     ts->add( BOOST_TEST_CASE( &parse_opt_vs_access_log_func_test ) );
4554     ts->add( BOOST_TEST_CASE( &parse_opt_vs_access_log_logrotate_func_test ) );
4555     ts->add( BOOST_TEST_CASE( &parse_opt_vs_socket_func_test ) );
4556
4557     ts->add( BOOST_TEST_CASE( &parse_vs_func_test ) );
4558
4559     ts->add( BOOST_TEST_CASE( &parse_opt_rs_weight_func_test ) );
4560     ts->add( BOOST_TEST_CASE( &parse_opt_rs_realserver_func_test ) );
4561     ts->add( BOOST_TEST_CASE( &parse_rs_func_test ) );
4562
4563     ts->add( BOOST_TEST_CASE( &parse_opt_replication_switch_func_test ) );
4564     ts->add( BOOST_TEST_CASE( &parse_opt_replication_force_func_test ) );
4565     ts->add( BOOST_TEST_CASE( &parse_opt_replication_dump_func_test ) );
4566     ts->add( BOOST_TEST_CASE( &parse_replication_func_test ) );
4567
4568     ts->add( BOOST_TEST_CASE( &parse_opt_log_category_func_test ) );
4569     ts->add( BOOST_TEST_CASE( &parse_opt_log_level_func_test ) );
4570     ts->add( BOOST_TEST_CASE( &parse_log_func_test ) );
4571
4572     ts->add( BOOST_TEST_CASE( &parse_opt_snmp_log_category_func_test ) );
4573     ts->add( BOOST_TEST_CASE( &parse_opt_snmp_log_level_func_test ) );
4574     ts->add( BOOST_TEST_CASE( &parse_snmp_func_test ) );
4575
4576     ts->add( BOOST_TEST_CASE( &parse_opt_parameter_reload_func_test ) );
4577     ts->add( BOOST_TEST_CASE( &parse_parameter_func_test ) );
4578
4579     ts->add( BOOST_TEST_CASE( &parse_opt_vs_fwdmode_func_test ) );
4580     ts->add( BOOST_TEST_CASE( &parse_opt_rs_fwdmode_func_test ) );
4581
4582     ts->add( BOOST_TEST_CASE( &execute_test ) );
4583
4584     ts->add( BOOST_TEST_CASE( &l7vsadm_test::file_lock_class_test ) );
4585
4586     framework::master_test_suite().add( ts );
4587
4588     return 0;
4589 }