l7vsd/unit_tests/session_test/tcp_realserver_connect_socket_list/tcp_realserver_connect_socket_list_test.cpp

   1
   2 #define    TEST_CASE
   3
   4 #include <boost/test/included/unit_test.hpp>
   5 #include <boost/thread/thread.hpp>
   6
   7 #include "logger.h"
   8
   9 #define TCP_SOCKET_H
  10
  11 // tcp_socket test class
  12 namespace l7vs{
  13     class tcp_socket : private boost::noncopyable{
  14         public:
  15             tcp_socket(){};
  16             ~tcp_socket(){};
  17             int socket_id;
  18     };
  19 }
  20
  21 #include "../../../src/tcp_realserver_connect_socket_list.cpp"
  22
  23 using namespace boost::unit_test_framework;
  24
  25 class common_test : public l7vs::tcp_realserver_connect_socket_list{
  26     public:
  27         common_test(){};
  28         ~common_test(){};
  29         std::list< l7vs::tcp_realserver_connect_socket_list::list_element >& get_list(){
  30             return  connect_list;
  31         }
  32 };
  33
  34 //--test case--
  35 // construcor test
  36 void construcor_test(){
  37
  38
  39     BOOST_MESSAGE( "----- construcor test start -----" );
  40
  41     common_test test_obj;
  42
  43     BOOST_MESSAGE( "----- construcor test end -----" );
  44 }
  45
  46
  47 void push_back_test(){
  48     BOOST_MESSAGE( "----- push back test start -----" );
  49
  50     typedef std::list< l7vs::tcp_realserver_connect_socket_list::list_element > list_type;
  51
  52     common_test test_obj;
  53
  54     list_type& test_list = test_obj.get_list();
  55
  56     l7vs::tcp_realserver_connect_socket_list::list_element chk_element;
  57
  58     // ## push back test [1]
  59     std::cout << "push back test [1] " << std::endl;
  60     BOOST_CHECK(test_list.empty());
  61     for(int i = 0; i < (int)USHRT_MAX;i++){
  62         boost::shared_ptr<l7vs::tcp_socket> push_socket(new l7vs::tcp_socket);
  63         l7vs::tcp_realserver_connect_socket_list::list_element push_element;
  64         push_element.second = push_socket;
  65         push_socket->socket_id = i;
  66         push_element.first.port((unsigned short)i);
  67         test_obj.push_back(push_element);
  68     }
  69
  70     BOOST_CHECK(!test_list.empty());
  71     BOOST_CHECK_EQUAL(test_list.size() , (unsigned long)USHRT_MAX);
  72
  73     for(int i = 0; i < (int)USHRT_MAX;i++){
  74         chk_element = test_list.front();
  75         BOOST_CHECK_EQUAL(i , chk_element.second->socket_id);
  76         BOOST_CHECK_EQUAL((unsigned short)i , chk_element.first.port());
  77         test_list.pop_front();
  78     }
  79
  80     test_list.clear();
  81
  82     BOOST_MESSAGE( "----- push back test end -----" );
  83 }
  84 void get_socket_test(){
  85     BOOST_MESSAGE( "----- get socket test start -----" );
  86
  87     typedef std::list< l7vs::tcp_realserver_connect_socket_list::list_element > list_type;
  88
  89     common_test test_obj;
  90
  91     list_type& test_list = test_obj.get_list();
  92
  93     l7vs::tcp_realserver_connect_socket_list::list_element chk_element;
  94
  95     // ## get socket test [1] empty list
  96     std::cout << "get socket test [1] empty list" << std::endl;
  97     BOOST_CHECK(test_obj.get_socket() == chk_element);
  98
  99     // ## get socket test [2] push list
 100     std::cout << "get socket test [2] push list" << std::endl;
 101     BOOST_CHECK(test_list.empty());
 102     for(int i = 0; i < (int)USHRT_MAX;i++){
 103         boost::shared_ptr<l7vs::tcp_socket> push_socket(new l7vs::tcp_socket);
 104         l7vs::tcp_realserver_connect_socket_list::list_element push_element;
 105         push_element.second = push_socket;
 106         push_socket->socket_id = i;
 107         push_element.first.port((unsigned short)i);
 108         test_list.push_back(push_element);
 109     }
 110
 111     BOOST_CHECK(!test_list.empty());
 112     BOOST_CHECK_EQUAL(test_list.size() , (unsigned long)USHRT_MAX);
 113
 114     for(int i = 0; i < (int)USHRT_MAX;i++){
 115         chk_element = test_obj.get_socket();
 116         BOOST_CHECK_EQUAL(i , chk_element.second->socket_id);
 117         BOOST_CHECK_EQUAL((unsigned short)i , chk_element.first.port());
 118     }
 119
 120     BOOST_CHECK(test_list.empty());
 121
 122     BOOST_MESSAGE( "----- get socket test end -----" );
 123 }
 124 void empty_test(){
 125     BOOST_MESSAGE( "----- empty test start -----" );
 126
 127     typedef std::list< l7vs::tcp_realserver_connect_socket_list::list_element > list_type;
 128
 129     common_test test_obj;
 130
 131     list_type& test_list = test_obj.get_list();
 132
 133     l7vs::tcp_realserver_connect_socket_list::list_element chk_element;
 134
 135     // ## empty test [1] empty list
 136     std::cout << "empty test [1] empty list" << std::endl;
 137     BOOST_CHECK(test_obj.empty());
 138
 139     // ## empty test [2] push list
 140     std::cout << "empty test [2] push list" << std::endl;
 141     for(int i = 0; i < (int)USHRT_MAX;i++){
 142         boost::shared_ptr<l7vs::tcp_socket> push_socket(new l7vs::tcp_socket);
 143         l7vs::tcp_realserver_connect_socket_list::list_element push_element;
 144         push_element.second = push_socket;
 145         push_socket->socket_id = i;
 146         push_element.first.port((unsigned short)i);
 147         test_list.push_back(push_element);
 148         BOOST_CHECK(!test_obj.empty());
 149     }
 150
 151     // ## empty test [3] pop list
 152     std::cout << "empty test [3] pop list" << std::endl;
 153     for(int i = 0; i < (int)USHRT_MAX;i++){
 154         BOOST_CHECK(!test_obj.empty());
 155         test_list.pop_front();
 156     }
 157
 158     // ## empty test [4] all pop list
 159     std::cout << "empty test [4] all pop list" << std::endl;
 160     BOOST_CHECK(test_obj.empty());
 161
 162     BOOST_MESSAGE( "----- empty test end -----" );
 163 }
 164
 165 // push_back_lock_test
 166 class push_back_lock_test_class : public l7vs::tcp_realserver_connect_socket_list{
 167     public:
 168         boost::thread::id befor_thread_id;
 169         boost::thread::id after_thread_id;
 170         push_back_lock_test_class(){
 171         };
 172         ~push_back_lock_test_class(){
 173         };
 174         void push_back(l7vs::tcp_realserver_connect_socket_list::list_element realserver_socket){
 175             befor_thread_id = boost::this_thread::get_id();
 176             l7vs::tcp_realserver_connect_socket_list::push_back(realserver_socket);
 177             after_thread_id = boost::this_thread::get_id();
 178         };
 179         void mutex_lock(){
 180             list_mutex.wrlock();
 181         };
 182         void mutex_unlock(){
 183             list_mutex.unlock();
 184         };
 185
 186         boost::mutex test_thread_wait;
 187
 188         void test_run(){
 189             boost::mutex::scoped_lock scope_lock(test_thread_wait);
 190             l7vs::tcp_realserver_connect_socket_list::list_element push_element;
 191             push_back(push_element);
 192             connect_list.pop_front();
 193         };
 194
 195 };
 196 void push_back_lock_test(){
 197     BOOST_MESSAGE( "----- push backe lock test start -----" );
 198
 199     push_back_lock_test_class test_obj;
 200
 201     test_obj.test_thread_wait.lock();
 202     boost::thread::id proc_id = boost::this_thread::get_id();
 203     test_obj.befor_thread_id = proc_id;
 204     test_obj.after_thread_id = proc_id;
 205     test_obj.mutex_lock();
 206
 207     boost::thread test_thread(boost::bind(&push_back_lock_test_class::test_run,&test_obj));
 208
 209     BOOST_CHECK(test_obj.befor_thread_id == proc_id);
 210     BOOST_CHECK(test_obj.after_thread_id == proc_id);
 211
 212     boost::thread::id test_id = test_thread.get_id();
 213
 214     BOOST_CHECK(test_id != proc_id);
 215
 216     // test start
 217     test_obj.test_thread_wait.unlock();
 218     sleep(1);
 219
 220     // ## push back lock test [1] thread block test (mutex lock)
 221     std::cout << "push back lock test [1] thread block test (mutex lock)" << std::endl;
 222     BOOST_CHECK(test_obj.befor_thread_id == test_id);
 223     BOOST_CHECK(test_obj.after_thread_id == proc_id);
 224
 225     test_obj.mutex_unlock();
 226     sleep(1);
 227
 228     // ## push back lock test [2] thread run test (mutex unlock)
 229     std::cout << "push back lock test [2] thread run test (mutex unlock)" << std::endl;
 230     BOOST_CHECK(test_obj.befor_thread_id == test_id);
 231     BOOST_CHECK(test_obj.after_thread_id == test_id);
 232
 233
 234     BOOST_MESSAGE( "----- push back lock test end -----" );
 235 }
 236
 237 // get_socket_lock_test
 238 class get_socket_lock_test_class : public l7vs::tcp_realserver_connect_socket_list{
 239     public:
 240         boost::thread::id befor_thread_id;
 241         boost::thread::id after_thread_id;
 242         get_socket_lock_test_class(){
 243         };
 244         ~get_socket_lock_test_class(){
 245         };
 246         void get_socket(){
 247             befor_thread_id = boost::this_thread::get_id();
 248             l7vs::tcp_realserver_connect_socket_list::get_socket();
 249             after_thread_id = boost::this_thread::get_id();
 250         };
 251         void mutex_lock(){
 252             list_mutex.wrlock();
 253         };
 254         void mutex_unlock(){
 255             list_mutex.unlock();
 256         };
 257
 258         boost::mutex test_thread_wait;
 259
 260         void test_run(){
 261             boost::mutex::scoped_lock scope_lock(test_thread_wait);
 262             get_socket();
 263         };
 264
 265 };
 266 void get_socket_lock_test(){
 267
 268     BOOST_MESSAGE( "----- get socket lock test start -----" );
 269
 270     get_socket_lock_test_class test_obj;
 271
 272     test_obj.test_thread_wait.lock();
 273     boost::thread::id proc_id = boost::this_thread::get_id();
 274     test_obj.befor_thread_id = proc_id;
 275     test_obj.after_thread_id = proc_id;
 276     test_obj.mutex_lock();
 277
 278     boost::thread test_thread(boost::bind(&get_socket_lock_test_class::test_run,&test_obj));
 279
 280     BOOST_CHECK(test_obj.befor_thread_id == proc_id);
 281     BOOST_CHECK(test_obj.after_thread_id == proc_id);
 282
 283     boost::thread::id test_id = test_thread.get_id();
 284
 285     BOOST_CHECK(test_id != proc_id);
 286
 287     // test start
 288     test_obj.test_thread_wait.unlock();
 289     sleep(1);
 290
 291     // ## get socket lock test [1] thread block test (mutex lock)
 292     std::cout << "get socket lock test [1] thread block test (mutex lock)" << std::endl;
 293     BOOST_CHECK(test_obj.befor_thread_id == test_id);
 294     BOOST_CHECK(test_obj.after_thread_id == proc_id);
 295
 296     test_obj.mutex_unlock();
 297     sleep(1);
 298
 299     // ## get socket lock test [2] thread run test (mutex unlock)
 300     std::cout << "get socket lock test [2] thread run test (mutex unlock)" << std::endl;
 301     BOOST_CHECK(test_obj.befor_thread_id == test_id);
 302     BOOST_CHECK(test_obj.after_thread_id == test_id);
 303
 304     BOOST_MESSAGE( "----- get socket lock test end -----" );
 305 }
 306
 307 test_suite*    init_unit_test_suite( int argc, char* argv[] ){
 308
 309     test_suite* ts = BOOST_TEST_SUITE( "l7vs::tcp_realserver_connect_socket_list class test" );
 310
 311     ts->add( BOOST_TEST_CASE( &construcor_test ) );
 312     ts->add( BOOST_TEST_CASE( &push_back_test ) );
 313     ts->add( BOOST_TEST_CASE( &push_back_lock_test ) );
 314     ts->add( BOOST_TEST_CASE( &get_socket_test ) );
 315     ts->add( BOOST_TEST_CASE( &get_socket_lock_test ) );
 316     ts->add( BOOST_TEST_CASE( &empty_test ) );
 317
 318     framework::master_test_suite().add( ts );
 319
 320     return NULL;
 321 }