OSDN Git Service

l7vsadm unit_test 実施
authortakamaru <takamaru@1ed66053-1c2d-0410-8867-f7571e6e31d3>
Fri, 11 Dec 2009 12:15:55 +0000 (12:15 +0000)
committertakamaru <takamaru@1ed66053-1c2d-0410-8867-f7571e6e31d3>
Fri, 11 Dec 2009 12:15:55 +0000 (12:15 +0000)
git-svn-id: http://10.144.169.20/repos/um/branches/l7vsd-3.x-ramiel@9013 1ed66053-1c2d-0410-8867-f7571e6e31d3

l7vsd/include/l7vsadm.h
l7vsd/src/l7vsadm.cpp
l7vsd/unit_tests/l7vsadm_test/l7vsadm_test.cpp

index fc13f7f..dc76a61 100644 (file)
@@ -238,12 +238,14 @@ protected:
     bool    parse_opt_vs_qosdown_func( int&, int, char*[] );
     //! virtualservice option udp func.
     bool    parse_opt_vs_udp_func( int&, int, char*[] );
-    //! virtualservice option ssl function
-    bool    parse_opt_vs_ssl_func( int&, int, char*[] );
+    //! virtualservice option ssl file function
+    bool    parse_opt_vs_ssl_file_func( int&, int, char*[] );
+    //! virtualservice option access log function
+    bool    parse_opt_vs_access_log_func( int&, int, char*[] );
     //! virtualservice option access log logrotate function
     bool    parse_opt_vs_access_log_logrotate_func( int&, int, char*[] );
     //! virtualservice option socket option function
-    bool    parse_opt_vs_socket_option_func( int&, int, char*[] );
+    bool    parse_opt_vs_socket_func( int&, int, char*[] );
     // realserver option function
     //! realserver weight set
     bool    parse_opt_rs_weight_func( int&, int, char*[] );
index 89c741b..b9cef53 100644 (file)
@@ -37,6 +37,7 @@
 #include "protocol_module_control.h"
 #include "schedule_module_control.h"
 #include "virtualservice_element.h"
+#include "logger_access_manager.h"
 
 // global function prototype
 static void    sig_exit_handler(int sig);
@@ -175,6 +176,15 @@ bool    l7vs::l7vsadm::parse_vs_func( l7vs::l7vsadm_request::COMMAND_CODE_TAG cm
         Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 8, buf, __FILE__, __LINE__ );
         return false;
     }
+
+    if( ( l7vsadm_request::CMD_ADD_VS == cmd ) &&
+        ( request.vs_element.access_log_flag == 1 ) && ( request.vs_element.access_log_file_name.length() == 0 ) ){
+        std::string    buf("access log file is not specified.");
+        l7vsadm_err.setter( true, buf );
+        Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 999, buf, __FILE__, __LINE__ );
+        return false;
+        
+    }
     return true;
 }
 //
@@ -665,12 +675,12 @@ bool    l7vs::l7vsadm::parse_opt_vs_udp_func( int& pos, int argc, char* argv[] )
     }
     return true;
 }
-//! virtualservice option ssl function
+//! virtualservice option ssl_file function
 //! @param[in]    argument position
 //! @param[in]    argument count
 //! @param[in]    argument value
-bool    l7vs::l7vsadm::parse_opt_vs_ssl_func( int& pos, int argc, char* argv[] ){
-    Logger    logger( LOG_CAT_L7VSADM_COMMON, 999, "l7vsadm::parse_opt_vs_ssl_func", __FILE__, __LINE__ );
+bool    l7vs::l7vsadm::parse_opt_vs_ssl_file_func( int& pos, int argc, char* argv[] ){
+    Logger    logger( LOG_CAT_L7VSADM_COMMON, 999, "l7vsadm::parse_opt_vs_ssl_file_func", __FILE__, __LINE__ );
 
     if( ++pos >= argc ){
         std::string    buf("ssl config filename is not specified.");
@@ -698,6 +708,43 @@ bool    l7vs::l7vsadm::parse_opt_vs_ssl_func( int& pos, int argc, char* argv[] )
     return true;
 }
 
+//! virtualservice option access log function
+//! @param[in]    argument position
+//! @param[in]    argument count
+//! @param[in]    argument value
+bool    l7vs::l7vsadm::parse_opt_vs_access_log_func( int& pos, int argc, char* argv[] ){
+    Logger    logger( LOG_CAT_L7VSADM_COMMON, 999, "l7vsadm::parse_opt_vs_access_log_func", __FILE__, __LINE__ );
+
+    if( ++pos >= argc ){
+        //don't target access log flag
+        std::string    buf("access log flag value is not specified.");
+        l7vsadm_err.setter( true, buf );
+        Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 999, buf, __FILE__, __LINE__ );
+        return false;
+    }
+    try{
+        int    tmp = boost::lexical_cast< int >( argv[pos] );
+        if( ( 0 != tmp ) && ( 1 != tmp ) ){
+            std::string    buf("invalid access log flag value.");
+            l7vsadm_err.setter( true, buf );
+            Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 999, buf, __FILE__, __LINE__ );
+            return false;
+        }
+        if( 0 == tmp )
+            request.vs_element.access_log_flag = INT_MAX;    // clear value
+        else
+            request.vs_element.access_log_flag = 1;
+    }
+    catch( boost::bad_lexical_cast& e ){
+        // don't convert argv[pos] is
+        std::string    buf("invalid access log flag value.");
+        l7vsadm_err.setter( true, buf );
+        Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 999, buf, __FILE__, __LINE__ );
+        return false;
+    }
+    return true;    //
+}
+
 //! virtualservice option access_log_logrotate function
 //! @param[in]    argument position
 //! @param[in]    argument count
@@ -742,7 +789,9 @@ bool    l7vs::l7vsadm::parse_opt_vs_access_log_logrotate_func( int& pos, int arg
         if( 0 == ( arguments_vector.size() % 2 ) ){
             for( unsigned int i = 0; i < ( arguments_vector.size() - 1 ); ++i ){
                 std::pair< virtualservice_element::access_log_rotate_arguments_map_type::iterator, bool > ret =
-                arguments_map.insert( virtualservice_element::access_log_rotate_arguments_pair_type( arguments_vector[i], arguments_vector[i+1] ) );
+                arguments_map.insert(
+                    virtualservice_element::access_log_rotate_arguments_pair_type(
+                        arguments_vector[i], arguments_vector[i+1] ) );
                 if( !ret.second ){
                     std::string buf("access log rotation argument is duplicated.");
                     l7vsadm_err.setter( true, buf );
@@ -757,8 +806,7 @@ bool    l7vs::l7vsadm::parse_opt_vs_access_log_logrotate_func( int& pos, int arg
             Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 999, buf, __FILE__, __LINE__ );
             return false;
         }
-        //bool ret = logger_access_manager::getInstance().access_log_logrotate_parameter_check( arguments_map );
-        bool ret = true;
+        bool ret = logger_access_manager::getInstance().access_log_logrotate_parameter_check( arguments_map );
         if( !ret ){
             std::string buf("access log rotation argument error.");
             l7vsadm_err.setter( true, buf );
@@ -776,11 +824,12 @@ bool    l7vs::l7vsadm::parse_opt_vs_access_log_logrotate_func( int& pos, int arg
     return true;
 }
 
-//! virtualservice option socket option function
+//! virtualservice option socket function
 //! @param[in]    argument position
 //! @param[in]    argument count
 //! @param[in]    argument value
-bool    l7vs::l7vsadm::parse_opt_vs_socket_option_func( int& pos, int argc, char* argv[] ){
+bool    l7vs::l7vsadm::parse_opt_vs_socket_func( int& pos, int argc, char* argv[] ){
+    Logger    logger( LOG_CAT_L7VSADM_COMMON, 999, "l7vsadm::parse_opt_vs_socket_func", __FILE__, __LINE__ );
 
     if( ++pos >= argc ){
         std::string    buf("socket_option is not specified.");
@@ -790,15 +839,18 @@ bool    l7vs::l7vsadm::parse_opt_vs_socket_option_func( int& pos, int argc, char
     }
 
     bool is_set_defer_accept = false;
+    bool is_set_nodelay = false;
+    bool is_set_cork = false;
+    bool is_set_quickack = false;
 
     request.vs_element.socket_option_tcp_defer_accept = 0;
     request.vs_element.socket_option_tcp_nodelay = 0;
     request.vs_element.socket_option_tcp_cork = 0;
     request.vs_element.socket_option_tcp_quickack = 0;
 
-    std::string socket_option_str = argv[pos];
+    std::string socket_option_string = argv[pos];
     std::vector< std::string > socket_options;
-    boost::split( socket_options, socket_option_str, boost::algorithm::is_any_of( "," ) );
+    boost::split( socket_options, socket_option_string, boost::algorithm::is_any_of( "," ) );
 
     BOOST_FOREACH( std::string option, socket_options ){
         if( option == "deferaccept" ){
@@ -811,23 +863,63 @@ bool    l7vs::l7vsadm::parse_opt_vs_socket_option_func( int& pos, int argc, char
                 std::stringstream buf;
                 buf << "socket option deferaccept is duplicated.";
                 l7vsadm_err.setter( true, buf.str() );
-                Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 0, buf.str(), __FILE__, __LINE__ );
+                Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 999, buf.str(), __FILE__, __LINE__ );
                 return false;
             }
         }
-        else if(option == "" ) {
-
+        else if(option == "nodelay" ) {
+            if( !is_set_nodelay ){
+                is_set_nodelay = true;
+                request.vs_element.socket_option_tcp_nodelay = 1;
+            }
+            else{
+                // nodelay is duplicated
+                std::stringstream buf;
+                buf << "socket option nodelay is duplicated.";
+                l7vsadm_err.setter( true, buf.str() );
+                Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 999, buf.str(), __FILE__, __LINE__ );
+                return false;
+            }
+        }
+        else if(option == "cork" ) {
+            if( !is_set_cork ){
+                is_set_cork = true;
+                request.vs_element.socket_option_tcp_cork = 1;
+            }
+            else{
+                // cork is duplicated
+                std::stringstream buf;
+                buf << "socket option cork is duplicated.";
+                l7vsadm_err.setter( true, buf.str() );
+                Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 999, buf.str(), __FILE__, __LINE__ );
+                return false;
+            }
+        }
+        else if( option == "quickackon" || option == "quickackoff" ) {
+            if( !is_set_quickack ){
+                is_set_quickack = true;
+                request.vs_element.socket_option_tcp_quickack = ( ( option == "quickackon" ) ? 1 : 2 );
+            }
+            else{
+                // quickack is duplicated
+                std::stringstream buf;
+                buf << "socket option quickack is duplicated.";
+                l7vsadm_err.setter( true, buf.str() );
+                Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 999, buf.str(), __FILE__, __LINE__ );
+                return false;
+            }
         }
         else{
             // unknown socket option
             std::stringstream buf;
             buf << "unknown socket option.";
             l7vsadm_err.setter( true, buf.str() );
-            Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 0, buf.str(), __FILE__, __LINE__ );
+            Logger::putLogError( LOG_CAT_L7VSADM_PARSE, 999, buf.str(), __FILE__, __LINE__ );
             return false;
         }
     }
 
+    request.vs_element.socket_option_string = socket_option_string;
     return true;
 
 }
@@ -1400,21 +1492,21 @@ bool    l7vs::l7vsadm::parse_help_func( l7vs::l7vsadm_request::COMMAND_CODE_TAG
 
     std::cout <<
     "Commands:\n"
-    "  --add-service     -A        add virtual service with options\n"
-    "  --edit-service    -E        edit virtual service with options\n"
-    "  --delete-service  -D        delete virtual service with options\n"
-    "  --flush           -C        flush virtual service\n"
-    "  --add-server      -a        add real server with options\n"
-    "  --edit-server     -e        edit real server with options\n"
-    "  --delete-server   -d        delete real server with options\n"
-    "  --replication     -R        control replication-function\n"
-    "  --log             -L        control logger-function\n"
-    "  --snmp            -S        control SNMP Agent-function\n"
-    "  --parameter       -P        control parameter-function\n"
-    "  --list            -l        list the table\n"
-    "  --verbose         -V        list the table in verbose format\n"
-    "  --key             -K        list the table in key setting format\n"
-    "  --help            -h        show usage\n"
+    "  --add-service      -A        add virtual service with options\n"
+    "  --edit-service     -E        edit virtual service with options\n"
+    "  --delete-service   -D        delete virtual service with options\n"
+    "  --flush            -C        flush virtual service\n"
+    "  --add-server       -a        add real server with options\n"
+    "  --edit-server      -e        edit real server with options\n"
+    "  --delete-server    -d        delete real server with options\n"
+    "  --replication      -R        control replication-function\n"
+    "  --log              -L        control logger-function\n"
+    "  --snmp             -S        control SNMP Agent-function\n"
+    "  --parameter        -P        control parameter-function\n"
+    "  --list             -l        list the table\n"
+    "  --verbose          -V        list the table in verbose format\n"
+    "  --key              -K        list the table in key setting format\n"
+    "  --help             -h        show usage\n"
     << std::endl;
 
     std::cout <<
@@ -1619,7 +1711,6 @@ void    l7vs::l7vsadm::disp_list_verbose(){
     buf << "     Access_log_file\n";
     buf << "     Access_log_rotate option\n";
     buf << "  -> RemoteAddress:Port           Forward Weight ActiveConn InactConn\n";
-    buf << "  -> RemoteAddress:Port           Forward Weight ActiveConn InactConn\n";
     BOOST_FOREACH( virtualservice_element vse, response.virtualservice_status_list ){
         std::string    vsepstr;
         if( vse.udpmode )
@@ -1742,8 +1833,15 @@ l7vs::l7vsadm::l7vsadm()
     vs_option_dic["--qos-down"]     = boost::bind( &l7vsadm::parse_opt_vs_qosdown_func, this, _1, _2, _3 );
     vs_option_dic["-p"]             = boost::bind( &l7vsadm::parse_opt_vs_udp_func, this, _1, _2, _3 );
     vs_option_dic["--udp"]          = boost::bind( &l7vsadm::parse_opt_vs_udp_func, this, _1, _2, _3 );
-    vs_option_dic["-z"]             = boost::bind( &l7vsadm::parse_opt_vs_ssl_func, this, _1, _2, _3 );
-    vs_option_dic["--ssl-proxy"]    = boost::bind( &l7vsadm::parse_opt_vs_ssl_func, this, _1, _2, _3 );
+    vs_option_dic["-z"]             = boost::bind( &l7vsadm::parse_opt_vs_ssl_file_func, this, _1, _2, _3 );
+    vs_option_dic["--ssl-proxy"]    = boost::bind( &l7vsadm::parse_opt_vs_ssl_file_func, this, _1, _2, _3 );
+    vs_option_dic["-O"]             = boost::bind( &l7vsadm::parse_opt_vs_socket_func, this, _1, _2, _3 );
+    vs_option_dic["--sockopt"]      = boost::bind( &l7vsadm::parse_opt_vs_socket_func, this, _1, _2, _3 );
+    vs_option_dic["-L"]             = boost::bind( &l7vsadm::parse_opt_vs_access_log_func, this, _1, _2, _3 );
+    vs_option_dic["--access-log"]   = boost::bind( &l7vsadm::parse_opt_vs_access_log_func, this, _1, _2, _3 );
+    vs_option_dic["-a"]             = boost::bind( &l7vsadm::parse_opt_vs_access_log_logrotate_func, this, _1, _2, _3 );
+    vs_option_dic["--access-log-name"]
+                                    = boost::bind( &l7vsadm::parse_opt_vs_access_log_logrotate_func, this, _1, _2, _3 );
     // create realserver option dictionary
     rs_option_dic["-t"]             = boost::bind( &l7vsadm::parse_opt_vs_target_func, this, _1, _2, _3 );
     rs_option_dic["--target"]       = boost::bind( &l7vsadm::parse_opt_vs_target_func, this, _1, _2, _3 );
@@ -2195,7 +2293,7 @@ bool    l7vs::l7vsadm::execute( int argc, char* argv[] ){
                     std::stringstream   buf;
                     buf << boost::format( "connect() failed: %s.") % err.message();
                     l7vsadm_err.setter( true, buf.str() );
-                    Logger::putLogError( LOG_CAT_L7VSADM_COMMON, 0, buf.str(), __FILE__, __LINE__ );
+                    Logger::putLogError( LOG_CAT_L7VSADM_COMMON, 999, buf.str(), __FILE__, __LINE__ );
                     break;
                 }
 
index f23651e..627e1ae 100644 (file)
@@ -12,6 +12,7 @@
 #include "schedule_module_stub.h"
 #include "protocol_module_control_stub.h"
 #include "schedule_module_control_stub.h"
+#include "logger_access_manager_stub.h"
 
 #include "../../src/l7vsadm.cpp"
 
@@ -66,6 +67,18 @@ public:
     bool    parse_opt_vs_udp_func_wp( int& pos, int argc, char* argv[] )
     { return parse_opt_vs_udp_func( pos, argc, argv ); }
 
+    bool    parse_opt_vs_ssl_file_func_wp( int& pos, int argc, char* argv[] )
+    { return parse_opt_vs_ssl_file_func( pos, argc, argv ); }
+
+    bool    parse_opt_vs_access_log_func_wp( int& pos, int argc, char* argv[] )
+    { return parse_opt_vs_access_log_func( pos, argc, argv ); }
+
+    bool    parse_opt_vs_access_log_logrotate_func_wp( int& pos, int argc, char* argv[] )
+    { return parse_opt_vs_access_log_logrotate_func( pos, argc, argv ); }
+
+    bool    parse_opt_vs_socket_func_wp( int& pos, int argc, char* argv[] )
+    { return parse_opt_vs_socket_func( pos, argc, argv ); }
+
     bool    parse_vs_func_wp( l7vs::l7vsadm_request::COMMAND_CODE_TAG cmd, int argc, char* argv[] )
     { return parse_vs_func( cmd, argc, argv ); }
 
@@ -1509,6 +1522,454 @@ void    parse_opt_vs_udp_func_test(){
 
 }
 
+void    parse_opt_vs_ssl_file_func_test(){
+    BOOST_MESSAGE( "----- parse_opt_vs_ssl_file_func_test start -----" );
+
+    // parse_opt_vs_ssl_file_func normal case 1
+    {
+        l7vsadm_test    adm;
+        int     pos         = 2;
+        int     argc        = 4;
+        char*   argv[]      = { "l7vsadm_test", "-A", "-z", "./sslfile.cf" };
+    
+        bool ret = adm.parse_opt_vs_ssl_file_func_wp( pos, argc, argv );
+
+        // unit_test[xx] parse_opt_vs_ssl_file_func normal case 1 return value check
+        BOOST_CHECK_EQUAL( ret, true );    
+        // unit_test[xx] parse_opt_vs_ssl_file_func normal case 1 filename check
+        BOOST_CHECK_EQUAL( adm.get_request().vs_element.ssl_file_name, "./sslfile.cf" );
+    }
+
+    // pser_opt_vs_ssl_file_func error case 1 (filename not specified)
+    {
+        l7vsadm_test    adm;
+        int     pos         = 2;
+        int     argc        = 3;
+        char*   argv[]      = { "l7vsadm_test", "-A", "-z"};
+    
+        bool ret = adm.parse_opt_vs_ssl_file_func_wp( pos, argc, argv );
+
+        // unit_test[xx] parse_opt_vs_ssl_file_func error case 1 return value check
+        BOOST_CHECK_EQUAL( ret, false );    
+    }
+
+    // pser_opt_vs_ssl_file_func error case 2 (filename too long)
+    {
+        std::string filename;
+        filename.resize( L7VS_FILENAME_LEN + 1, 'a' );
+
+        l7vsadm_test    adm;
+        int     pos         = 2;
+        int     argc        = 4;
+        char*   argv[]      = { "l7vsadm_test", "-A", "-z", const_cast< char* >( filename.c_str() )  };
+    
+        bool ret = adm.parse_opt_vs_ssl_file_func_wp( pos, argc, argv );
+
+        // unit_test[xx] parse_opt_vs_ssl_file_func error case 2 return value check
+        BOOST_CHECK_EQUAL( ret, false );    
+    }
+
+    // pser_opt_vs_ssl_file_func error case 3 (file cannnot open)
+    {
+        l7vsadm_test    adm;
+        int     pos         = 2;
+        int     argc        = 4;
+        char*   argv[]      = { "l7vsadm_test", "-A", "-z", "./test.dat"};
+    
+        bool ret = adm.parse_opt_vs_ssl_file_func_wp( pos, argc, argv );
+
+        // unit_test[xx] parse_opt_vs_ssl_file_func error case 3 return value check
+        BOOST_CHECK_EQUAL( ret, false );    
+    }
+
+    BOOST_MESSAGE( "----- parse_opt_vs_ssl_file_func_test end -----" );
+
+}
+
+void    parse_opt_vs_access_log_func_test(){
+    BOOST_MESSAGE( "----- parse_opt_vs_access_log_func_test start -----" );
+
+    // parse_opt_vs_access_log_func normal case 1
+    {
+        l7vsadm_test    adm;
+        int     pos         = 2;
+        int     argc        = 4;
+        char*   argv[]      = { "l7vsadm_test", "-A", "-L", "1" };
+    
+        bool ret = adm.parse_opt_vs_access_log_func_wp( pos, argc, argv );
+
+        // unit_test[xx] parse_opt_vs_access_log_func normal case 1 return value check
+        BOOST_CHECK_EQUAL( ret, true );    
+        // unit_test[xx] parse_opt_vs_access_log_func normal case 1 filename check
+        BOOST_CHECK_EQUAL( adm.get_request().vs_element.access_log_flag, 1 );
+    }
+
+    // pser_opt_vs_access_log_func error case 1 (access_log_flag not specified)
+    {
+        l7vsadm_test    adm;
+        int     pos         = 2;
+        int     argc        = 3;
+        char*   argv[]      = { "l7vsadm_test", "-A", "-L"};
+    
+        bool ret = adm.parse_opt_vs_access_log_func_wp( pos, argc, argv );
+
+        // unit_test[xx] parse_opt_vs_access_log_func error case 1 return value check
+        BOOST_CHECK_EQUAL( ret, false );    
+    }
+
+    // pser_opt_vs_access_log_func error case 2 (invalid range access log flag value)
+    {
+        l7vsadm_test    adm;
+        int     pos         = 2;
+        int     argc        = 4;
+        char*   argv[]      = { "l7vsadm_test", "-A", "-z", "2"};
+    
+        bool ret = adm.parse_opt_vs_access_log_func_wp( pos, argc, argv );
+
+        // unit_test[xx] parse_opt_vs_access_log_func error case 2 return value check
+        BOOST_CHECK_EQUAL( ret, false );    
+    }
+
+    // pser_opt_vs_access_log_func error case 3 (invalied charactor access log flag value)
+    {
+        l7vsadm_test    adm;
+        int     pos         = 2;
+        int     argc        = 4;
+        char*   argv[]      = { "l7vsadm_test", "-A", "-z", "a"};
+    
+        bool ret = adm.parse_opt_vs_access_log_func_wp( pos, argc, argv );
+
+        // unit_test[xx] parse_opt_vs_access_log_func error case 3 return value check
+        BOOST_CHECK_EQUAL( ret, false );    
+    }
+
+    BOOST_MESSAGE( "----- parse_opt_vs_access_log_func_test end -----" );
+
+}
+
+void    parse_opt_vs_access_log_logrotate_func_test(){
+    BOOST_MESSAGE( "----- parse_opt_vs_access_log_logrotate_func_test start -----" );
+
+    // parse_opt_vs_access_log_logrotate_func normal case 1 (end with access log rotate option)
+    {
+        l7vsadm_test    adm;
+        int        pos     = 2;
+        int        argc    = 6;
+        char*    argv[]    = { "l7vsadm_test", "-A", "-a", "/var/log/l7vs/access.log", "--option", "zzz" };
+        l7vs::logger_access_manager::access_log_logrotate_parameter_check_called = false;
+        l7vs::logger_access_manager::access_log_logrotate_parameter_check_fail = false;
+    
+        bool ret = adm.parse_opt_vs_access_log_logrotate_func_wp( pos, argc, argv );
+
+        // unit_test[xx] parse_opt_vs_access_log_logrotate_func normal case 1 return value check
+        BOOST_CHECK_EQUAL( ret, true );    
+        // unit_test[xx] parse_opt_vs_access_log_logrotate_func normal case 1 check_parameter call check
+        BOOST_CHECK_EQUAL( l7vs::logger_access_manager::access_log_logrotate_parameter_check_called, true );
+        // unit_test[xx] parse_opt_vs_access_log_logrotate_func normal case 1 access log file name check
+        BOOST_CHECK_EQUAL( adm.get_request().vs_element.access_log_file_name, "/var/log/l7vs/access.log" );
+        // unit_test[xx] parse_opt_vs_access_log_logrotate_func normal case 1 rotate argument check
+        std::map< std::string, std::string >::iterator it =  adm.get_request().vs_element.access_log_rotate_arguments.find("--option");
+        BOOST_CHECK( it != adm.get_request().vs_element.access_log_rotate_arguments.end() );
+        BOOST_CHECK( it->second == "zzz" );
+    }
+
+
+    // parse_opt_vs_access_log_logrotate_func normal case 2 (end with next vs option)
+    {
+        l7vsadm_test    adm;
+        int        pos     = 2;
+        int        argc    = 7;
+        char*    argv[]    = { "l7vsadm_test", "-A", "-a", "/var/log/l7vs/access.log", "--option", "zzz", "-t" };
+        l7vs::logger_access_manager::access_log_logrotate_parameter_check_called = false;
+        l7vs::logger_access_manager::access_log_logrotate_parameter_check_fail = false;
+    
+        bool ret = adm.parse_opt_vs_access_log_logrotate_func_wp( pos, argc, argv );
+
+        // unit_test[xx] parse_opt_vs_access_log_logrotate_func normal case 2 return value check
+        BOOST_CHECK_EQUAL( ret, true );    
+        // unit_test[xx] parse_opt_vs_access_log_logrotate_func normal case 2 check_parameter call check
+        BOOST_CHECK_EQUAL( l7vs::logger_access_manager::access_log_logrotate_parameter_check_called, true );
+        // unit_test[xx] parse_opt_vs_access_log_logrotate_func normal case 2 access log file name check
+        BOOST_CHECK_EQUAL( adm.get_request().vs_element.access_log_file_name, "/var/log/l7vs/access.log" );
+        // unit_test[xx] parse_opt_vs_access_log_logrotate_func normal case 2 rotate argument check
+        std::map< std::string, std::string >::iterator it =  adm.get_request().vs_element.access_log_rotate_arguments.find("--option");
+        BOOST_CHECK( it != adm.get_request().vs_element.access_log_rotate_arguments.end() );
+        BOOST_CHECK( it->second == "zzz" );
+    }
+
+    // parse_opt_vs_access_log_logrotate_func normal case 3 (no rotate arg)
+    {
+        l7vsadm_test    adm;
+        int        pos     = 2;
+        int        argc    = 5;
+        char*    argv[]    = { "l7vsadm_test", "-A", "-a", "/var/log/l7vs/access.log", "-t" };
+        l7vs::logger_access_manager::access_log_logrotate_parameter_check_called = false;
+        l7vs::logger_access_manager::access_log_logrotate_parameter_check_fail = false;
+    
+        bool ret = adm.parse_opt_vs_access_log_logrotate_func_wp( pos, argc, argv );
+
+        // unit_test[xx] parse_opt_vs_access_log_logrotate_func normal case 3 return value check
+        BOOST_CHECK_EQUAL( ret, true );    
+        // unit_test[xx] parse_opt_vs_access_log_logrotate_func normal case 3 check_parameter call check
+        BOOST_CHECK_EQUAL( l7vs::logger_access_manager::access_log_logrotate_parameter_check_called, false );
+        // unit_test[xx] parse_opt_vs_access_log_logrotate_func normal case 3 access log file name check
+        BOOST_CHECK_EQUAL( adm.get_request().vs_element.access_log_file_name, "/var/log/l7vs/access.log" );
+    }
+
+    // parse_opt_access_log_logrotate_func error case 1 (no access_log_file name)
+    {
+        l7vsadm_test    adm;
+        int        pos     = 2;
+        int        argc    = 3;
+        char*    argv[]    = { "l7vsadm_test", "-A", "-a" };
+        l7vs::logger_access_manager::access_log_logrotate_parameter_check_called = false;
+        l7vs::logger_access_manager::access_log_logrotate_parameter_check_fail = false;
+    
+        bool ret = adm.parse_opt_vs_access_log_logrotate_func_wp( pos, argc, argv );
+
+        // unit_test[xx] parse_opt_vs_access_log_logrotate_func error case 1 return value check
+        BOOST_CHECK_EQUAL( ret, false );    
+
+    }
+
+    // parse_opt_access_log_logrotate_func error case 2 (access_log_file name too long)
+    {
+        std::string filename;
+        filename.resize( L7VS_FILENAME_LEN, 'a');
+        filename = "/" + filename;
+
+        l7vsadm_test    adm;
+        int        pos     = 2;
+        int        argc    = 4;
+        char*    argv[]    = { "l7vsadm_test", "-A", "-a", const_cast< char* >( filename.c_str() ) };
+        l7vs::logger_access_manager::access_log_logrotate_parameter_check_called = false;
+        l7vs::logger_access_manager::access_log_logrotate_parameter_check_fail = false;
+    
+        bool ret = adm.parse_opt_vs_access_log_logrotate_func_wp( pos, argc, argv );
+
+        // unit_test[xx] parse_opt_vs_access_log_logrotate_func error case 2 return value check
+        BOOST_CHECK_EQUAL( ret, false );    
+    }
+
+    // parse_opt_access_log_logrotate_func error case 3 (access_log_file name not fullpath)
+    {
+        l7vsadm_test    adm;
+        int        pos     = 2;
+        int        argc    = 4;
+        char*    argv[]    = { "l7vsadm_test", "-A", "-a", "access.log" };
+        l7vs::logger_access_manager::access_log_logrotate_parameter_check_called = false;
+        l7vs::logger_access_manager::access_log_logrotate_parameter_check_fail = false;
+    
+        bool ret = adm.parse_opt_vs_access_log_logrotate_func_wp( pos, argc, argv );
+
+        // unit_test[xx] parse_opt_vs_access_log_logrotate_func error case 3 return value check
+        BOOST_CHECK_EQUAL( ret, false );    
+    }
+
+    // parse_opt_access_log_logrotate_func error case 4 (rotate argument check error)
+    {
+        l7vsadm_test    adm;
+        int        pos     = 2;
+        int        argc    = 6;
+        char*    argv[]    = { "l7vsadm_test", "-A", "-a", "/var/log/l7vs/access.log", "--option", "zzz" };
+        l7vs::logger_access_manager::access_log_logrotate_parameter_check_called = false;
+        l7vs::logger_access_manager::access_log_logrotate_parameter_check_fail = true;
+    
+        bool ret = adm.parse_opt_vs_access_log_logrotate_func_wp( pos, argc, argv );
+
+        // unit_test[xx] parse_opt_vs_access_log_logrotate_func error case 4 return value check
+        BOOST_CHECK_EQUAL( ret, false );    
+    }
+
+    // parse_opt_access_log_logrotate_func error case 5 (rotate argument is not pair)
+    {
+        l7vsadm_test    adm;
+        int        pos     = 2;
+        int        argc    = 5;
+        char*    argv[]    = { "l7vsadm_test", "-A", "-a", "/var/log/l7vs/access.log", "--option" };
+        l7vs::logger_access_manager::access_log_logrotate_parameter_check_called = false;
+        l7vs::logger_access_manager::access_log_logrotate_parameter_check_fail = false;
+    
+        bool ret = adm.parse_opt_vs_access_log_logrotate_func_wp( pos, argc, argv );
+
+        // unit_test[xx] parse_opt_vs_access_log_logrotate_func error case 5 return value check
+        BOOST_CHECK_EQUAL( ret, false );    
+    }
+
+    // parse_opt_access_log_logrotate_func error case 6 (rotate argument is duplicated)
+    {
+        l7vsadm_test    adm;
+        int        pos     = 2;
+        int        argc    = 8;
+        char*    argv[]    = { "l7vsadm_test", "-A", "-a", "/var/log/l7vs/access.log", "--option", "zzz", "--option", "xxx" };
+        l7vs::logger_access_manager::access_log_logrotate_parameter_check_called = false;
+        l7vs::logger_access_manager::access_log_logrotate_parameter_check_fail = false;
+    
+        bool ret = adm.parse_opt_vs_access_log_logrotate_func_wp( pos, argc, argv );
+
+        // unit_test[xx] parse_opt_vs_access_log_logrotate_func error case 6 return value check
+        BOOST_CHECK_EQUAL( ret, false );    
+    }
+
+    BOOST_MESSAGE( "----- parse_opt_vs_access_log_logrotate_func_test end -----" );
+
+}
+
+void    parse_opt_vs_socket_func_test(){
+    BOOST_MESSAGE( "----- parse_opt_vs_socket_func_test start -----" );
+
+    // parse_opt_vs_socket_func normal case 1
+    {
+        l7vsadm_test    adm;
+        int     pos         = 2;
+        int     argc        = 4;
+        char*   argv[]      = { "l7vsadm_test", "-A", "-O", "deferaccept,nodelay,cork,quickackoff" };
+    
+        bool ret = adm.parse_opt_vs_socket_func_wp( pos, argc, argv );
+
+        // unit_test[xx] parse_opt_vs_socket_func normal case 1 return value check
+        BOOST_CHECK_EQUAL( ret, true );    
+        // unit_test[xx] parse_opt_vs_socket_func normal case 1 option check
+        BOOST_CHECK_EQUAL( adm.get_request().vs_element.socket_option_tcp_defer_accept, 1 );
+        BOOST_CHECK_EQUAL( adm.get_request().vs_element.socket_option_tcp_nodelay, 1 );
+        BOOST_CHECK_EQUAL( adm.get_request().vs_element.socket_option_tcp_cork, 1 );
+        BOOST_CHECK_EQUAL( adm.get_request().vs_element.socket_option_tcp_quickack, 2 );
+        BOOST_CHECK_EQUAL( adm.get_request().vs_element.socket_option_string, "deferaccept,nodelay,cork,quickackoff" );
+    }
+
+    // parse_opt_vs_socket_func normal case 2
+    {
+        l7vsadm_test    adm;
+        int     pos         = 2;
+        int     argc        = 4;
+        char*   argv[]      = { "l7vsadm_test", "-A", "-O", "nodelay" };
+    
+        bool ret = adm.parse_opt_vs_socket_func_wp( pos, argc, argv );
+
+        // unit_test[xx] parse_opt_vs_socket_func normal case 3 return value check
+        BOOST_CHECK_EQUAL( ret, true );    
+        // unit_test[xx] parse_opt_vs_socket_func normal case 3 option check
+        BOOST_CHECK_EQUAL( adm.get_request().vs_element.socket_option_tcp_defer_accept, 0 );
+        BOOST_CHECK_EQUAL( adm.get_request().vs_element.socket_option_tcp_nodelay, 1 );
+        BOOST_CHECK_EQUAL( adm.get_request().vs_element.socket_option_tcp_cork, 0 );
+        BOOST_CHECK_EQUAL( adm.get_request().vs_element.socket_option_tcp_quickack, 0 );
+        BOOST_CHECK_EQUAL( adm.get_request().vs_element.socket_option_string, "nodelay" );
+    }
+
+    // parse_opt_vs_socket_func normal case 3
+    {
+        l7vsadm_test    adm;
+        int     pos         = 2;
+        int     argc        = 4;
+        char*   argv[]      = { "l7vsadm_test", "-A", "-O", "deferaccept,quickackon" };
+    
+        bool ret = adm.parse_opt_vs_socket_func_wp( pos, argc, argv );
+
+        // unit_test[xx] parse_opt_vs_socket_func normal case 3 return value check
+        BOOST_CHECK_EQUAL( ret, true );    
+        // unit_test[xx] parse_opt_vs_socket_func normal case 3 option check
+        BOOST_CHECK_EQUAL( adm.get_request().vs_element.socket_option_tcp_defer_accept, 1 );
+        BOOST_CHECK_EQUAL( adm.get_request().vs_element.socket_option_tcp_nodelay, 0 );
+        BOOST_CHECK_EQUAL( adm.get_request().vs_element.socket_option_tcp_cork, 0 );
+        BOOST_CHECK_EQUAL( adm.get_request().vs_element.socket_option_tcp_quickack, 1 );
+        BOOST_CHECK_EQUAL( adm.get_request().vs_element.socket_option_string, "deferaccept,quickackon" );
+    }
+
+    // pser_opt_vs_socket_func error case 1 (socket option not specified)
+    {
+        l7vsadm_test    adm;
+        int     pos         = 2;
+        int     argc        = 3;
+        char*   argv[]      = { "l7vsadm_test", "-A", "-O"};
+    
+        bool ret = adm.parse_opt_vs_socket_func_wp( pos, argc, argv );
+
+        // unit_test[xx] parse_opt_vs_socket_func error case 1 return value check
+        BOOST_CHECK_EQUAL( ret, false );    
+    }
+
+    // pser_opt_vs_socket_func error case 2 (unknown socket option)
+    {
+        l7vsadm_test    adm;
+        int     pos         = 2;
+        int     argc        = 4;
+        char*   argv[]      = { "l7vsadm_test", "-A", "-O", "deferaccept,nodelay,cork,quickackoff,zzz" };
+    
+        bool ret = adm.parse_opt_vs_socket_func_wp( pos, argc, argv );
+
+        // unit_test[xx] parse_opt_vs_socket_func error case 2 return value check
+        BOOST_CHECK_EQUAL( ret, false );    
+    }
+
+    // pser_opt_vs_socket_func error case 3 (deferaccept duplicated)
+    {
+        l7vsadm_test    adm;
+        int     pos         = 2;
+        int     argc        = 4;
+        char*   argv[]      = { "l7vsadm_test", "-A", "-O", "deferaccept,nodelay,cork,quickackoff,deferaccept" };
+    
+        bool ret = adm.parse_opt_vs_socket_func_wp( pos, argc, argv );
+
+        // unit_test[xx] parse_opt_vs_socket_func error case 3 return value check
+        BOOST_CHECK_EQUAL( ret, false );    
+    }
+
+    // pser_opt_vs_socket_func error case 4 (nodelay duplicated)
+    {
+        l7vsadm_test    adm;
+        int     pos         = 2;
+        int     argc        = 4;
+        char*   argv[]      = { "l7vsadm_test", "-A", "-O", "deferaccept,nodelay,cork,quickackoff,nodelay" };
+    
+        bool ret = adm.parse_opt_vs_socket_func_wp( pos, argc, argv );
+
+        // unit_test[xx] parse_opt_vs_socket_func error case 4 return value check
+        BOOST_CHECK_EQUAL( ret, false );    
+    }
+
+    // pser_opt_vs_socket_func error case 5 (cork duplicated)
+    {
+        l7vsadm_test    adm;
+        int     pos         = 2;
+        int     argc        = 4;
+        char*   argv[]      = { "l7vsadm_test", "-A", "-O", "deferaccept,nodelay,cork,quickackoff,cork" };
+    
+        bool ret = adm.parse_opt_vs_socket_func_wp( pos, argc, argv );
+
+        // unit_test[xx] parse_opt_vs_socket_func error case 5 return value check
+        BOOST_CHECK_EQUAL( ret, false );    
+    }
+
+    // pser_opt_vs_socket_func error case 6 (quickack duplicated 1)
+    {
+        l7vsadm_test    adm;
+        int     pos         = 2;
+        int     argc        = 4;
+        char*   argv[]      = { "l7vsadm_test", "-A", "-O", "deferaccept,nodelay,cork,quickackoff,quickackoff" };
+    
+        bool ret = adm.parse_opt_vs_socket_func_wp( pos, argc, argv );
+
+        // unit_test[xx] parse_opt_vs_socket_func error case 6 return value check
+        BOOST_CHECK_EQUAL( ret, false );    
+    }
+
+    // pser_opt_vs_socket_func error case 7 (quickack duplicated 2)
+    {
+        l7vsadm_test    adm;
+        int     pos         = 2;
+        int     argc        = 4;
+        char*   argv[]      = { "l7vsadm_test", "-A", "-O", "deferaccept,nodelay,cork,quickackoff,quickackon" };
+    
+        bool ret = adm.parse_opt_vs_socket_func_wp( pos, argc, argv );
+
+        // unit_test[xx] parse_opt_vs_socket_func error case 7 return value check
+        BOOST_CHECK_EQUAL( ret, false );    
+    }
+
+    BOOST_MESSAGE( "----- parse_opt_vs_socket_func_test end -----" );
+
+}
+
 void    parse_vs_func_test(){
     BOOST_MESSAGE( "----- parse_vs_func_test start -----" );
 
@@ -1926,7 +2387,7 @@ void    parse_vs_func_test(){
                             "cinsert",
                             "mod_arg",
                             "-u",
-                            "-1",
+                            "-1"
                             };
     
         bool ret = adm.parse_vs_func_wp( cmd, argc, argv );
@@ -1935,6 +2396,28 @@ void    parse_vs_func_test(){
         BOOST_CHECK_EQUAL( ret, false );    
     }
 
+    // parse_vs_func error case 4 (access log on but not specified access log fil name)
+    {
+        l7vsadm_test    adm;
+        l7vs::l7vsadm_request::COMMAND_CODE_TAG    cmd = l7vs::l7vsadm_request::CMD_ADD_VS;
+        int        argc    = 9;
+        char*    argv[]    = {    "l7vsadm_test",
+                            "-A",
+                            "-t",
+                            "10.144.169.87:22100",
+                            "-m",
+                            "cinsert",
+                            "mod_arg",
+                            "-L",
+                            "1"
+                            };
+    
+        bool ret = adm.parse_vs_func_wp( cmd, argc, argv );
+
+        // unit_test[xx] parse_vs_func error case 4  return value check
+        BOOST_CHECK_EQUAL( ret, false );    
+    }
+
     BOOST_MESSAGE( "----- parse_vs_func_test end -----" );
 
 }
@@ -3939,993 +4422,8 @@ void    l7vsadm_test::file_lock_class_test(){
 }
 
 
-void    parse_opt_vs_module_func_socket_option_test(){
-    BOOST_MESSAGE( "----- parse_opt_vs_module_func_socket_option_test start -----" );
-    
-    
-    std::cout << "parse_opt_vs_module_func normal case 01 (da socket option on)" << std::endl;
-    // parse_opt_vs_module_func normal case 01 (da socket option on)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 6;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "-O" , "da:on" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[400] parse_opt_vs_module_func normal case 01 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, true );    
-        // unit_test[401] parse_opt_vs_module_func normal case 01 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, true );
-        // unit_test[402] parse_opt_vs_module_func normal case 01 (end with module option) module name check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
-        // unit_test[403] parse_opt_vs_module_func normal case 01 (socket option) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "-O" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[404] parse_opt_vs_module_func normal case 01 (socket option value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "da:on" );
-        
-    }
-    
-    std::cout << "parse_opt_vs_module_func normal case 02 (nd socket option on)" << std::endl;
-    // parse_opt_vs_module_func normal case 02 (nd socket option on)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 6;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "-O" , "nd:on" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[405] parse_opt_vs_module_func normal case 02 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, true );    
-        // unit_test[406] parse_opt_vs_module_func normal case 02 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, true );
-        // unit_test[407] parse_opt_vs_module_func normal case 02 (end with module option) module name check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
-        // unit_test[408] parse_opt_vs_module_func normal case 02 (socket option) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "-O" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[409] parse_opt_vs_module_func normal case 02 (socket option value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "nd:on" );
-        
-    }
-    
-    std::cout << "parse_opt_vs_module_func normal case 03 (ck socket option on)" << std::endl;
-    // parse_opt_vs_module_func normal case 03 (ck socket option on)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 6;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "-O" , "ck:on" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[410] parse_opt_vs_module_func normal case 03 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, true );    
-        // unit_test[411] parse_opt_vs_module_func normal case 03 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, true );
-        // unit_test[412] parse_opt_vs_module_func normal case 03 (end with module option) module name check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
-        // unit_test[413] parse_opt_vs_module_func normal case 03 (socket option) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "-O" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[414] parse_opt_vs_module_func normal case 03 (socket option value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "ck:on" );
-        
-    }
-    
-    std::cout << "parse_opt_vs_module_func normal case 04 (qa socket option on)" << std::endl;
-    // parse_opt_vs_module_func normal case 04 (qa socket option on)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 6;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "-O" , "qa:on" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[415] parse_opt_vs_module_func normal case 04 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, true );    
-        // unit_test[416] parse_opt_vs_module_func normal case 04 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, true );
-        // unit_test[417] parse_opt_vs_module_func normal case 04 (end with module option) module name check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
-        // unit_test[418] parse_opt_vs_module_func normal case 04 (socket option) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "-O" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[419] parse_opt_vs_module_func normal case 04 (socket option value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "qa:on" );
-        
-    }
-    
-    std::cout << "parse_opt_vs_module_func normal case 05 (qa socket option off)" << std::endl;
-    // parse_opt_vs_module_func normal case 05 (qa socket option off)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 6;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "-O" , "qa:off" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[420] parse_opt_vs_module_func normal case 05 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, true );    
-        // unit_test[421] parse_opt_vs_module_func normal case 05 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, true );
-        // unit_test[422] parse_opt_vs_module_func normal case 05 (end with module option) module name check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
-        // unit_test[423] parse_opt_vs_module_func normal case 05 (socket option) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "-O" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[424] parse_opt_vs_module_func normal case 05 (socket option value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "qa:off" );
-        
-    }
-    
-    std::cout << "parse_opt_vs_module_func normal case 06 (all socket option on)" << std::endl;
-    // parse_opt_vs_module_func normal case 06 (all socket option on)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 6;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "-O" , "da:on,nd:on,ck:on,qa:on" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[425] parse_opt_vs_module_func normal case 06 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, true );    
-        // unit_test[426] parse_opt_vs_module_func normal case 06 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, true );
-        // unit_test[427] parse_opt_vs_module_func normal case 06 (end with module option) module name check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
-        // unit_test[428] parse_opt_vs_module_func normal case 06 (socket option) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "-O" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[429] parse_opt_vs_module_func normal case 06 (socket option value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "da:on,nd:on,ck:on,qa:on" );
-        
-    }
-
-    std::cout << "parse_opt_vs_module_func normal case 07 (all socket option on reverse)" << std::endl;
-    // parse_opt_vs_module_func normal case 07 (all socket option on reverse)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 6;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "--sockopt" , "qa:on,ck:on,nd:on,da:on" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[430] parse_opt_vs_module_func normal case 07 (end with next vs option) return value check
-        BOOST_CHECK_EQUAL( ret, true );    
-        // unit_test[431] parse_opt_vs_module_func normal case 07 (end with next vs option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, true );
-        // unit_test[432] parse_opt_vs_module_func normal case 07 (end with next vs option) module name check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
-        // unit_test[433] parse_opt_vs_module_func normal case 07 (socket option) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "--sockopt" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[434] parse_opt_vs_module_func normal case 07 (socket option value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "qa:on,ck:on,nd:on,da:on" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        
-    }
-    
-    std::cout << "parse_opt_vs_module_func normal case 08 (-C(cookie-name) option)" << std::endl;
-    // parse_opt_vs_module_func normal case 08 (-C(cookie-name) option before)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 8;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "-C" , "ABCDEFG" , "-O" , "da:on,nd:on,ck:on,qa:on" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[435] parse_opt_vs_module_func normal case 08 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, true );    
-        // unit_test[436] parse_opt_vs_module_func normal case 08 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, true );
-        // unit_test[437] parse_opt_vs_module_func normal case 08 (end with module option) module name check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
-        
-        // unit_test[438] parse_opt_vs_module_func normal case 08 (cookie-name) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "-C" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[439] parse_opt_vs_module_func normal case 08 (cookie-name value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "ABCDEFG" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        
-        // unit_test[440] parse_opt_vs_module_func normal case 08 (socket option) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "-O" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[441] parse_opt_vs_module_func normal case 08 (socket option value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "da:on,nd:on,ck:on,qa:on" );
-        
-    }
-    
-    std::cout << "parse_opt_vs_module_func normal case 09 (--cookie-name option)" << std::endl;
-    // parse_opt_vs_module_func normal case 09 (--cookie-name option before)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 8;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "--cookie-name" , "ABCDEFG" , "-O" , "da:on,nd:on,ck:on,qa:on" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[442] parse_opt_vs_module_func normal case 09 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, true );    
-        // unit_test[443] parse_opt_vs_module_func normal case 09 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, true );
-        // unit_test[444] parse_opt_vs_module_func normal case 09 (end with module option) module name check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
-        
-        // unit_test[445] parse_opt_vs_module_func normal case 09 (cookie-name) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "--cookie-name" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[446] parse_opt_vs_module_func normal case 09 (cookie-name value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "ABCDEFG" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        
-        
-        // unit_test[447] parse_opt_vs_module_func normal case 09 (socket option) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "-O" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[448] parse_opt_vs_module_func normal case 09 (socket option value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "da:on,nd:on,ck:on,qa:on" );
-        
-    }
-    
-    std::cout << "parse_opt_vs_module_func normal case 10 (-E(cookie-expire) option)" << std::endl;
-    // parse_opt_vs_module_func normal case 10 (-E(cookie-expire) option before)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 8;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "-E" , "ABCDEFG" , "-O" , "da:on,nd:on,ck:on,qa:on" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[449] parse_opt_vs_module_func normal case 10 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, true );    
-        // unit_test[450] parse_opt_vs_module_func normal case 10 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, true );
-        // unit_test[451] parse_opt_vs_module_func normal case 10 (end with module option) module name check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
-        
-        // unit_test[452] parse_opt_vs_module_func normal case 10 (cookie-expire) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "-E" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[453] parse_opt_vs_module_func normal case 10 (cookie-name value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "ABCDEFG" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        
-        // unit_test[454] parse_opt_vs_module_func normal case 10 (socket option) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "-O" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[455] parse_opt_vs_module_func normal case 10 (socket option value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "da:on,nd:on,ck:on,qa:on" );
-        
-    }
-    
-    std::cout << "parse_opt_vs_module_func normal case 11 (--cookie-expire option)" << std::endl;
-    // parse_opt_vs_module_func normal case 11 (--cookie-expire option before)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 8;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "--cookie-expire" , "ABCDEFG" , "-O" , "da:on,nd:on,ck:on,qa:on" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[456] parse_opt_vs_module_func normal case 11 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, true );    
-        // unit_test[457] parse_opt_vs_module_func normal case 11 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, true );
-        // unit_test[458] parse_opt_vs_module_func normal case 11 (end with module option) module name check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
-        
-        // unit_test[459] parse_opt_vs_module_func normal case 11 (cookie-expire) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "--cookie-expire" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[460] parse_opt_vs_module_func normal case 11 (cookie-name value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "ABCDEFG" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        
-        
-        // unit_test[461] parse_opt_vs_module_func normal case 11 (socket option) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "-O" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[462] parse_opt_vs_module_func normal case 11 (socket option value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "da:on,nd:on,ck:on,qa:on" );
-        
-    }
-    
-    std::cout << "parse_opt_vs_module_func normal case 12 (-F(forwarded-for) option)" << std::endl;
-    // parse_opt_vs_module_func normal case 12 (-F(forwarded-for) option before)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 7;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "-F" , "-O" , "da:on,nd:on,ck:on,qa:on" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[463] parse_opt_vs_module_func normal case 12 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, true );    
-        // unit_test[464] parse_opt_vs_module_func normal case 12 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, true );
-        // unit_test[465] parse_opt_vs_module_func normal case 12 (end with module option) module name check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
-        
-        // unit_test[466] parse_opt_vs_module_func normal case 12 (cookie-expire) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "-F" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        
-        // unit_test[467] parse_opt_vs_module_func normal case 12 (socket option) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "-O" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[468] parse_opt_vs_module_func normal case 12 (socket option value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "da:on,nd:on,ck:on,qa:on" );
-        
-    }
-    
-    std::cout << "parse_opt_vs_module_func normal case 13 (--forwarded-for option)" << std::endl;
-    // parse_opt_vs_module_func normal case 13 (--forwarded-for option before)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 7;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "--forwarded-for" , "-O" , "da:on,nd:on,ck:on,qa:on" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[469] parse_opt_vs_module_func normal case 1 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, true );    
-        // unit_test[470] parse_opt_vs_module_func normal case 13 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, true );
-        // unit_test[471] parse_opt_vs_module_func normal case 13 (end with module option) module name check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
-        
-        // unit_test[472] parse_opt_vs_module_func normal case 13 (cookie-expire) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "--forwarded-for" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        
-        // unit_test[473] parse_opt_vs_module_func normal case 13 (socket option) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "-O" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[474] parse_opt_vs_module_func normal case 13 (socket option value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "da:on,nd:on,ck:on,qa:on" );
-        
-    }
-    
-    
-    std::cout << "parse_opt_vs_module_func normal case 14 (-R(reschedule) option)" << std::endl;
-    // parse_opt_vs_module_func normal case 14 (-R(reschedule) option before)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 7;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "-R" , "-O" , "da:on,nd:on,ck:on,qa:on" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[475] parse_opt_vs_module_func normal case 14 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, true );    
-        // unit_test[476] parse_opt_vs_module_func normal case 14 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, true );
-        // unit_test[477] parse_opt_vs_module_func normal case 14 (end with module option) module name check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
-        
-        // unit_test[478] parse_opt_vs_module_func normal case 14 (cookie-expire) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "-R" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        
-        // unit_test[479] parse_opt_vs_module_func normal case 14 (socket option) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "-O" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[480] parse_opt_vs_module_func normal case 14 (socket option value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "da:on,nd:on,ck:on,qa:on" );
-        
-    }
-    
-    std::cout << "parse_opt_vs_module_func normal case 15 (--reschedule option)" << std::endl;
-    // parse_opt_vs_module_func normal case 15 (--reschedule option before)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 7;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "--reschedule" , "-O" , "da:on,nd:on,ck:on,qa:on" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[481] parse_opt_vs_module_func normal case 15 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, true );    
-        // unit_test[482] parse_opt_vs_module_func normal case 15 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, true );
-        // unit_test[483] parse_opt_vs_module_func normal case 15 (end with module option) module name check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
-        
-        // unit_test[484] parse_opt_vs_module_func normal case 15 (reschedule) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "--reschedule" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        
-        // unit_test[485] parse_opt_vs_module_func normal case 15 (socket option) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "-O" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[486] parse_opt_vs_module_func normal case 15 (socket option value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "da:on,nd:on,ck:on,qa:on" );
-        
-    }
-    
-    std::cout << "parse_opt_vs_module_func normal case 16 (-N(no-reschedule) option)" << std::endl;
-    // parse_opt_vs_module_func normal case 16 (-N(no-reschedule) option before)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 7;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "-N" , "-O" , "da:on,nd:on,ck:on,qa:on" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[487] parse_opt_vs_module_func normal case 16 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, true );    
-        // unit_test[488] parse_opt_vs_module_func normal case 16 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, true );
-        // unit_test[489] parse_opt_vs_module_func normal case 16 (end with module option) module name check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
-        
-        // unit_test[450] parse_opt_vs_module_func normal case 16 (no-reschedule) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "-N" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        
-        // unit_test[451] parse_opt_vs_module_func normal case 16 (socket option) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "-O" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[452] parse_opt_vs_module_func normal case 16 (socket option value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "da:on,nd:on,ck:on,qa:on" );
-        
-    }
-    
-    std::cout << "parse_opt_vs_module_func normal case 17 (--no-reschedule option)" << std::endl;
-    // parse_opt_vs_module_func normal case 17 (--no-reschedule option before)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 7;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "--no-reschedule" , "-O" , "da:on,nd:on,ck:on,qa:on" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[453] parse_opt_vs_module_func normal case 17 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, true );    
-        // unit_test[454] parse_opt_vs_module_func normal case 17 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, true );
-        // unit_test[455] parse_opt_vs_module_func normal case 17 (end with module option) module name check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
-        
-        // unit_test[456] parse_opt_vs_module_func normal case 17 (no-reschedule) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "--no-reschedule" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        
-        // unit_test[457] parse_opt_vs_module_func normal case 17 (socket option) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "-O" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[458] parse_opt_vs_module_func normal case 17 (socket option value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "da:on,nd:on,ck:on,qa:on" );
-        
-    }
-    
-    std::cout << "parse_opt_vs_module_func normal case 18 (-S(sorry-uri) option)" << std::endl;
-    // parse_opt_vs_module_func normal case 18 (-S(sorry-uri) option before)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 8;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "-S" , "ABCDEFG" , "-O" , "da:on,nd:on,ck:on,qa:on" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[459] parse_opt_vs_module_func normal case 18 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, true );    
-        // unit_test[460] parse_opt_vs_module_func normal case 18 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, true );
-        // unit_test[461] parse_opt_vs_module_func normal case 18 (end with module option) module name check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
-        
-//        // unit_test[462] parse_opt_vs_module_func normal case 18 (sorry-uri) module arg check
-//        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "-S" );
-//        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-//        // unit_test[463] parse_opt_vs_module_func normal case 18 (sorry-uri value) module arg check
-//        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "ABCDEFG" );
-//        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-//        
-//        // unit_test[464] parse_opt_vs_module_func normal case 18 (socket option) module arg check
-//        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "-O" );
-//        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-//        // unit_test[465] parse_opt_vs_module_func normal case 18 (socket option value) module arg check
-//        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "da:on,nd:on,ck:on,qa:on" );
-        
-    }
-    
-    std::cout << "parse_opt_vs_module_func normal case 19 (--sorry-uri option)" << std::endl;
-    // parse_opt_vs_module_func normal case 19 (--sorry-uri option before)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 8;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "--sorry-uri" , "ABCDEFG" , "-O" , "da:on,nd:on,ck:on,qa:on" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[466] parse_opt_vs_module_func normal case 19 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, true );
-        // unit_test[467] parse_opt_vs_module_func normal case 19 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, true );
-        // unit_test[468] parse_opt_vs_module_func normal case 19 (end with module option) module name check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
-        
-        // unit_test[469] parse_opt_vs_module_func normal case 19 (sorry-uri) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "--sorry-uri" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[470] parse_opt_vs_module_func normal case 19 (sorry-uri value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "ABCDEFG" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        
-        
-        // unit_test[471] parse_opt_vs_module_func normal case 19 (socket option) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "-O" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[472] parse_opt_vs_module_func normal case 19 (socket option value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "da:on,nd:on,ck:on,qa:on" );
-        
-    }
-    
-    std::cout << "parse_opt_vs_module_func normal case 20 (-T(time-out) option)" << std::endl;
-    // parse_opt_vs_module_func normal case 20 (-T(time-out) option before)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 8;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "-T" , "ABCDEFG" , "-O" , "da:on,nd:on,ck:on,qa:on" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[473] parse_opt_vs_module_func normal case 20 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, true );    
-        // unit_test[474] parse_opt_vs_module_func normal case 20 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, true );
-        // unit_test[475] parse_opt_vs_module_func normal case 20 (end with module option) module name check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
-        
-        // unit_test[476] parse_opt_vs_module_func normal case 20 (time-out) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "-T" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[477] parse_opt_vs_module_func normal case 20 (time-out value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "ABCDEFG" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        
-        // unit_test[478] parse_opt_vs_module_func normal case 20 (socket option) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "-O" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[479] parse_opt_vs_module_func normal case 20 (socket option value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "da:on,nd:on,ck:on,qa:on" );
-        
-    }
-    
-    std::cout << "parse_opt_vs_module_func normal case 21 (--time-out option)" << std::endl;
-    // parse_opt_vs_module_func normal case 21 (--time-out option before)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 8;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "--time-out" , "ABCDEFG" , "-O" , "da:on,nd:on,ck:on,qa:on" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[480] parse_opt_vs_module_func normal case 21 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, true );    
-        // unit_test[481] parse_opt_vs_module_func normal case 21 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, true );
-        // unit_test[482] parse_opt_vs_module_func normal case 21 (end with module option) module name check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
-        
-        // unit_test[483] parse_opt_vs_module_func normal case 21 (time-out) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "--time-out" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[484] parse_opt_vs_module_func normal case 21 (time-out value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "ABCDEFG" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        
-        
-        // unit_test[485] parse_opt_vs_module_func normal case 21 (socket option) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "-O" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[486] parse_opt_vs_module_func normal case 21 (socket option value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "da:on,nd:on,ck:on,qa:on" );
-        
-    }
-    
-    std::cout << "parse_opt_vs_module_func normal case 22 (-M(maxlist) option)" << std::endl;
-    // parse_opt_vs_module_func normal case 22 (-M(maxlist) option before)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 8;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "-M" , "ABCDEFG" , "-O" , "da:on,nd:on,ck:on,qa:on" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[487] parse_opt_vs_module_func normal case 22 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, true );    
-        // unit_test[488] parse_opt_vs_module_func normal case 22 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, true );
-        // unit_test[489] parse_opt_vs_module_func normal case 22 (end with module option) module name check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
-        
-        // unit_test[490] parse_opt_vs_module_func normal case 22 (maxlist) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "-M" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[491] parse_opt_vs_module_func normal case 22 (maxlist value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "ABCDEFG" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        
-        // unit_test[492] parse_opt_vs_module_func normal case 22 (socket option) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "-O" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[493] parse_opt_vs_module_func normal case 22 (socket option value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "da:on,nd:on,ck:on,qa:on" );
-        
-    }
-    
-    std::cout << "parse_opt_vs_module_func normal case 23 (--maxlist option)" << std::endl;
-    // parse_opt_vs_module_func normal case 23 (--maxlist option before)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 8;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "--maxlist" , "ABCDEFG" , "-O" , "da:on,nd:on,ck:on,qa:on" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[494] parse_opt_vs_module_func normal case 23 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, true );    
-        // unit_test[495] parse_opt_vs_module_func normal case 23 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, true );
-        // unit_test[496] parse_opt_vs_module_func normal case 23 (end with module option) module name check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
-        
-        // unit_test[497] parse_opt_vs_module_func normal case 23 (maxlist) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "--maxlist" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[498] parse_opt_vs_module_func normal case 23 (maxlist value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "ABCDEFG" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        
-        
-        // unit_test[499] parse_opt_vs_module_func normal case 23 (socket option) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "-O" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[500] parse_opt_vs_module_func normal case 23 (socket option value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "da:on,nd:on,ck:on,qa:on" );
-        
-    }
-    
-    std::cout << "parse_opt_vs_module_func normal case 24 (other option suffix)" << std::endl;
-    // parse_opt_vs_module_func normal case 24 (other option suffix)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 8;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "-O" , "da:on,nd:on,ck:on,qa:on", "-C" , "ABCDEFG" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[501] parse_opt_vs_module_func normal case 24 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, true );    
-        // unit_test[502] parse_opt_vs_module_func normal case 24 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, true );
-        // unit_test[503] parse_opt_vs_module_func normal case 24 (end with module option) module name check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_module_name, "cinsert" );
-        
-        
-        // unit_test[504] parse_opt_vs_module_func normal case 24 (socket option) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "-O" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[505] parse_opt_vs_module_func normal case 24 (socket option value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "da:on,nd:on,ck:on,qa:on" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        
-        // unit_test[506] parse_opt_vs_module_func normal case 24 (other option) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "-C" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        // unit_test[507] parse_opt_vs_module_func normal case 24 (other option value) module arg check
-        BOOST_CHECK_EQUAL( adm.get_request().vs_element.protocol_args.front(), "ABCDEFG" );
-        adm.get_request().vs_element.protocol_args.erase(adm.get_request().vs_element.protocol_args.begin());
-        
-    }
-    
-    std::cout << "parse_opt_vs_module_func error case 01 (illegal socket option)" << std::endl;
-    // parse_opt_vs_module_func error case 01 (illegal socket option)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 6;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "-O" , "dd:on" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[508] parse_opt_vs_module_func error case 01 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, false );
-        // unit_test[509] parse_opt_vs_module_func error case 01 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, false );
-    }
-    
-    std::cout << "parse_opt_vs_module_func error case 02 (da socket option illegal value)" << std::endl;
-    // parse_opt_vs_module_func error case 02 (da socket option illegal value)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 6;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "-O" , "da:off" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[510] parse_opt_vs_module_func error case 02 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, false );    
-        // unit_test[511] parse_opt_vs_module_func error case 02 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, false );
-        
-    }
-    
-    std::cout << "parse_opt_vs_module_func error case 03 (nd socket option illegal value)" << std::endl;
-    // parse_opt_vs_module_func error case 03 (nd socket option illegal value)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 6;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "-O" , "nd:off" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[511] parse_opt_vs_module_func error case 03 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, false );    
-        // unit_test[512] parse_opt_vs_module_func error case 03 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, false );
-        
-    }
-    
-    std::cout << "parse_opt_vs_module_func error case 04 (ck socket option illegal value)" << std::endl;
-    // parse_opt_vs_module_func error case 04 (ck socket option illegal value)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 6;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "-O" , "ck:off" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[513] parse_opt_vs_module_func error case 04 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, false );    
-        // unit_test[514] parse_opt_vs_module_func error case 04 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, false );
-        
-    }
-    
-    std::cout << "parse_opt_vs_module_func error case 05 (qa socket option illegal value)" << std::endl;
-    // parse_opt_vs_module_func error case 05 (qa socket option illegal value)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 6;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "-O" , "qa:ok" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[515] parse_opt_vs_module_func error case 05 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, false );    
-        // unit_test[516] parse_opt_vs_module_func error case 05 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, false );
-        
-    }
-    
-    std::cout << "parse_opt_vs_module_func error case 06 (duplication socket option)" << std::endl;
-    // parse_opt_vs_module_func error case 06 (duplication socket option)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 8;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "-O" , "da:on" , "--sockopt" , "nd:on" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[517] parse_opt_vs_module_func error case 06 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, false );
-        // unit_test[518] parse_opt_vs_module_func error case 06 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, false );
-    }
-    
-    std::cout << "parse_opt_vs_module_func error case 07 (duplication da socket option)" << std::endl;
-    // parse_opt_vs_module_func error case 07 (duplication da socket option)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 6;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "-O" , "da:on,da:on" ,  };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[519] parse_opt_vs_module_func error case 07 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, false );    
-        // unit_test[520] parse_opt_vs_module_func error case 07 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, false );
-        
-    }
-    
-    std::cout << "parse_opt_vs_module_func error case 08 (duplication nd socket option)" << std::endl;
-    // parse_opt_vs_module_func error case 08 (duplication nd socket option)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 6;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "-O" , "nd:on,nd:on" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[521] parse_opt_vs_module_func error case 08 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, false );    
-        // unit_test[522] parse_opt_vs_module_func error case 08 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, false );
-        
-    }
-    
-    std::cout << "parse_opt_vs_module_func error case 09 (duplication ck socket option)" << std::endl;
-    // parse_opt_vs_module_func error case 09 (duplication ck socket option)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 6;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "-O" , "ck:on,ck:on" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[523] parse_opt_vs_module_func error case 09 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, false );    
-        // unit_test[524] parse_opt_vs_module_func error case 09 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, false );
-        
-    }
-    
-    std::cout << "parse_opt_vs_module_func error case 10 (duplication qa socket option)" << std::endl;
-    // parse_opt_vs_module_func error case 10 (qa socket option illegal value)
-    {
-        l7vsadm_test    adm;
-        int        pos        = 2;
-        int        argc    = 6;
-        char*    argv[]    = { "l7vsadm_test", "-A", "-m", "cinsert", "-O" , "qa:on,qa:on" };
-        l7vs::protocol_module_control::load_module_fail = false;
-        l7vs::protocol_module_stub::check_parameter_called = false;
-        l7vs::protocol_module_stub::check_parameter_fail = false;
-    
-        bool ret = adm.parse_opt_vs_module_func_wp( pos, argc, argv );
-
-        // unit_test[525] parse_opt_vs_module_func error case 10 (end with module option) return value check
-        BOOST_CHECK_EQUAL( ret, false );    
-        // unit_test[526] parse_opt_vs_module_func error case 10 (end with module option) check_parameter call check
-        BOOST_CHECK_EQUAL( l7vs::protocol_module_stub::check_parameter_called, false );
-        
-    }
-    
-    l7vs::protocol_module_control::load_module_fail = false;
-    l7vs::protocol_module_stub::check_parameter_called = false;
-    l7vs::protocol_module_stub::check_parameter_fail = false;
-
-    BOOST_MESSAGE( "----- parse_opt_vs_module_func_socket_option_test end -----" );
-
-}
-
-test_suite*    init_unit_test_suite( int argc, char* argv[] ){
-    test_suite* ts = BOOST_TEST_SUITE( "l7vsd class test" );
+test_suite*    init_unit_test_suite( int argc, char* argv[] ){
+    test_suite* ts = BOOST_TEST_SUITE( "l7vsd class test" );
 
     l7vs::Logger    logger_instance;
     l7vs::Parameter    parameter_instance;
@@ -4941,6 +4439,12 @@ test_suite*    init_unit_test_suite( int argc, char* argv[] ){
     ts->add( BOOST_TEST_CASE( &parse_opt_vs_qosup_func_test ) );
     ts->add( BOOST_TEST_CASE( &parse_opt_vs_qosdown_func_test ) );
     ts->add( BOOST_TEST_CASE( &parse_opt_vs_udp_func_test ) );
+
+    ts->add( BOOST_TEST_CASE( &parse_opt_vs_ssl_file_func_test ) );
+    ts->add( BOOST_TEST_CASE( &parse_opt_vs_access_log_func_test ) );
+    ts->add( BOOST_TEST_CASE( &parse_opt_vs_access_log_logrotate_func_test ) );
+    ts->add( BOOST_TEST_CASE( &parse_opt_vs_socket_func_test ) );
+
     ts->add( BOOST_TEST_CASE( &parse_vs_func_test ) );
 
     ts->add( BOOST_TEST_CASE( &parse_opt_rs_weight_func_test ) );
@@ -4966,8 +4470,6 @@ test_suite*    init_unit_test_suite( int argc, char* argv[] ){
     ts->add( BOOST_TEST_CASE( &execute_test ) );
 
     ts->add( BOOST_TEST_CASE( &l7vsadm_test::file_lock_class_test ) );
-    
-    ts->add( BOOST_TEST_CASE( &parse_opt_vs_module_func_socket_option_test ) );
 
     framework::master_test_suite().add( ts );