l7vsd/unit_tests/module_controls_test/schedule_module_control/schedule_module_control_thread_test.cpp

   1
   2 #include <iostream>
   3 #include <dlfcn.h>
   4 #include <boost/test/included/unit_test.hpp>
   5 #include "schedule_module_control.h"
   6 #include "schedule_module_control_test.h"
   7 #include "logger.h"
   8 #include "parameter.h"
   9
  10 using namespace l7vs;
  11 using namespace boost::unit_test;
  12
  13 std::vector<l7vs::schedule_module_base*> test1_vec;
  14 std::vector<l7vs::schedule_module_base*> test2_vec;
  15 #define THREAD_LOOP_COUNT 100
  16 void    thread1(){
  17     BOOST_TEST_MESSAGE( "thread1 start" );
  18     schedule_module_control_testclass& control = schedule_module_control_testclass::getInstance();
  19     test1_vec.clear();
  20     l7vs::schedule_module_base*        schedule1 = NULL;
  21     for( int i = 0; i < THREAD_LOOP_COUNT; i++ ){
  22         try{
  23             schedule1 = control.load_module( PM1 );
  24         }
  25         catch(...){
  26             BOOST_ERROR( "exception : load_module thread1" );
  27         }
  28         test1_vec.push_back(schedule1);
  29     }
  30     BOOST_CHECK_EQUAL( test1_vec.size(), (size_t)THREAD_LOOP_COUNT );
  31
  32     std::vector<l7vs::schedule_module_base*>::iterator test1_it = test1_vec.begin();
  33     for( int i = 0; i < THREAD_LOOP_COUNT; i++ ){
  34         control.unload_module(*test1_it);
  35         test1_it = test1_vec.erase(test1_it);
  36         test1_it = test1_vec.begin();
  37     }
  38     BOOST_CHECK_EQUAL( test1_vec.size(), (size_t)0 );
  39     BOOST_TEST_MESSAGE( "thread1 stop" );
  40 }
  41
  42 void    thread2(){
  43     BOOST_TEST_MESSAGE( "thread2 start" );
  44     schedule_module_control_testclass& control = schedule_module_control_testclass::getInstance();
  45     test2_vec.clear();
  46     l7vs::schedule_module_base*        schedule2 = NULL;
  47     for( int i = 0; i < THREAD_LOOP_COUNT; i++ ){
  48         try{
  49             schedule2 = control.load_module( PM2 );
  50         }
  51         catch(...){
  52             BOOST_ERROR( "exception : load_module thread2" );
  53         }
  54         test2_vec.push_back(schedule2);
  55     }
  56     BOOST_CHECK_EQUAL( test2_vec.size(), (size_t)THREAD_LOOP_COUNT );
  57
  58     std::vector<l7vs::schedule_module_base*>::iterator test2_it = test2_vec.begin();
  59     for( int i = 0; i < THREAD_LOOP_COUNT; i++ ){
  60         control.unload_module(*test2_it);
  61         test2_it = test2_vec.erase(test2_it);
  62         test2_it = test2_vec.begin();
  63     }
  64     BOOST_CHECK_EQUAL( test2_vec.size(), (size_t)0 );
  65     BOOST_TEST_MESSAGE( "thread2 stop" );
  66 }
  67
  68 void    thread3(){
  69     BOOST_TEST_MESSAGE( "thread3 start" );
  70     schedule_module_control_testclass& control = schedule_module_control_testclass::getInstance();
  71     test1_vec.clear();
  72     l7vs::schedule_module_base*        schedule1 = NULL;
  73     for( int i = 0; i < THREAD_LOOP_COUNT; i++ ){
  74         try{
  75             schedule1 = control.load_module( PM1 );
  76         }
  77         catch(...){
  78             BOOST_ERROR( "exception : load_module thread3" );
  79         }
  80         test1_vec.push_back(schedule1);
  81     }
  82     BOOST_CHECK_EQUAL( test1_vec.size(), (size_t)THREAD_LOOP_COUNT );
  83     BOOST_TEST_MESSAGE( "thread3 stop" );
  84 }
  85
  86 void    thread4(){
  87     BOOST_TEST_MESSAGE( "thread4 start" );
  88     schedule_module_control_testclass& control = schedule_module_control_testclass::getInstance();
  89     test2_vec.clear();
  90     l7vs::schedule_module_base*        schedule2 = NULL;
  91     for( int i = 0; i < THREAD_LOOP_COUNT; i++ ){
  92         try{
  93             schedule2 = control.load_module( PM1 );
  94         }
  95         catch(...){
  96             BOOST_ERROR( "exception : load_module thread4" );
  97         }
  98         test2_vec.push_back(schedule2);
  99     }
 100     BOOST_CHECK_EQUAL( test2_vec.size(), (size_t)THREAD_LOOP_COUNT );
 101     BOOST_TEST_MESSAGE( "thread4 stop" );
 102 }
 103
 104 void    thread5(){
 105     BOOST_TEST_MESSAGE( "thread5 start" );
 106     schedule_module_control_testclass& control = schedule_module_control_testclass::getInstance();
 107     BOOST_CHECK_EQUAL( test1_vec.size(), (size_t)THREAD_LOOP_COUNT );
 108     std::vector<l7vs::schedule_module_base*>::iterator test1_it = test1_vec.begin();
 109 #if 1
 110     for( int i = 0; i < THREAD_LOOP_COUNT; i++ ){
 111         control.unload_module(*test1_it);
 112         test1_vec.erase(test1_it);
 113         test1_it = test1_vec.begin();
 114     }
 115 #else
 116     for( test1_it = test1_vec.begin(); test1_it != test1_vec.end(); test1_it++ ){
 117         control.unload_module(*test1_it);
 118     }
 119     test1_vec.clear();
 120 #endif
 121     BOOST_TEST_MESSAGE( "thread5 stop" );
 122 }
 123
 124 void    thread6(){
 125     BOOST_TEST_MESSAGE( "thread6 start" );
 126     schedule_module_control_testclass& control = schedule_module_control_testclass::getInstance();
 127     BOOST_CHECK_EQUAL( test2_vec.size(), (size_t)THREAD_LOOP_COUNT );
 128     std::vector<l7vs::schedule_module_base*>::iterator test2_it = test2_vec.begin();
 129 #if 1
 130     for( int i = 0; i < THREAD_LOOP_COUNT; i++ ){
 131         control.unload_module(*test2_it);
 132         test2_vec.erase(test2_it);
 133         test2_it = test2_vec.begin();
 134     }
 135 #else
 136     for( test2_it = test2_vec.begin(); test2_it != test2_vec.end(); test2_it++ ){
 137         control.unload_module(*test2_it);
 138     }
 139     test2_vec.clear();
 140 #endif
 141     BOOST_TEST_MESSAGE( "thread6 stop" );
 142 }
 143
 144 void    thread7(){
 145     BOOST_TEST_MESSAGE( "thread7 start" );
 146     schedule_module_control_testclass& control = schedule_module_control_testclass::getInstance();
 147     test1_vec.clear();
 148     l7vs::schedule_module_base*        schedule1 = NULL;
 149     for( int i = 0; i < THREAD_LOOP_COUNT; i++ ){
 150         try{
 151             schedule1 = control.load_module( PM1 );
 152         }
 153         catch(...){
 154             BOOST_ERROR( "exception : load_module thread7" );
 155         }
 156         test1_vec.push_back(schedule1);
 157     }
 158     BOOST_CHECK_EQUAL( test1_vec.size(), (size_t)THREAD_LOOP_COUNT );
 159
 160     std::vector<l7vs::schedule_module_base*>::iterator test1_it = test1_vec.begin();
 161     for( int i = 0; i < THREAD_LOOP_COUNT; i++ ){
 162         control.unload_module(*test1_it);
 163         test1_it = test1_vec.erase(test1_it);
 164         test1_it = test1_vec.begin();
 165     }
 166     BOOST_CHECK_EQUAL( test1_vec.size(), (size_t)0 );
 167     BOOST_TEST_MESSAGE( "thread7 stop" );
 168 }
 169
 170 void    thread8(){
 171     BOOST_TEST_MESSAGE( "thread8 start" );
 172     schedule_module_control_testclass& control = schedule_module_control_testclass::getInstance();
 173     test2_vec.clear();
 174     l7vs::schedule_module_base*        schedule2 = NULL;
 175     for( int i = 0; i < THREAD_LOOP_COUNT; i++ ){
 176         try{
 177             schedule2 = control.load_module( PM1 );
 178         }
 179         catch(...){
 180             BOOST_ERROR( "exception : load_module thread8" );
 181         }
 182         test2_vec.push_back(schedule2);
 183     }
 184     BOOST_CHECK_EQUAL( test2_vec.size(), (size_t)THREAD_LOOP_COUNT );
 185
 186     std::vector<l7vs::schedule_module_base*>::iterator test2_it = test2_vec.begin();
 187     for( int i = 0; i < THREAD_LOOP_COUNT; i++ ){
 188         control.unload_module(*test2_it);
 189         test2_it = test2_vec.erase(test2_it);
 190         test2_it = test2_vec.begin();
 191     }
 192     BOOST_CHECK_EQUAL( test2_vec.size(), (size_t)0 );
 193     BOOST_TEST_MESSAGE( "thread8 stop" );
 194 }
 195
 196 void    thread9(){
 197     BOOST_TEST_MESSAGE( "thread9 start" );
 198     schedule_module_control_testclass& control = schedule_module_control_testclass::getInstance();
 199     l7vs::schedule_module_base*        schedule1 = NULL;
 200     for( int i = 0; i < THREAD_LOOP_COUNT; i++ ){
 201         try{
 202             schedule1 = control.load_module( PM1 );
 203         }
 204         catch(...){
 205             BOOST_ERROR( "exception : load_module thread9" );
 206         }
 207         control.unload_module( schedule1 );
 208     }
 209     BOOST_TEST_MESSAGE( "thread9 stop" );
 210 }
 211
 212 void    thread10(){
 213     BOOST_TEST_MESSAGE( "thread10 start" );
 214     schedule_module_control_testclass& control = schedule_module_control_testclass::getInstance();
 215     l7vs::schedule_module_base*        schedule2 = NULL;
 216     for( int i = 0; i < THREAD_LOOP_COUNT; i++ ){
 217         try{
 218             schedule2 = control.load_module( PM2 );
 219         }
 220         catch(...){
 221             BOOST_ERROR( "exception : load_module thread10" );
 222         }
 223         control.unload_module( schedule2 );
 224     }
 225     BOOST_TEST_MESSAGE( "thread10 stop" );
 226 }
 227
 228 void    load2_unload2_thread( int id, const std::string& modulename ){
 229     schedule_module_control_testclass& control = schedule_module_control_testclass::getInstance();
 230     l7vs::schedule_module_base*        schedule1 = NULL;
 231     schedule1 = control.load_module2( id, modulename );
 232     control.unload_module2( id, schedule1 );
 233
 234     control.finalize();
 235 }
 236
 237 void    load_unload2_thread( int id, const std::string& modulename ){
 238     schedule_module_control_testclass& control = schedule_module_control_testclass::getInstance();
 239     l7vs::schedule_module_base*        schedule1 = NULL;
 240     schedule1 = control.load_module( modulename );
 241     control.unload_module2( id, schedule1 );
 242
 243     control.finalize();
 244 }
 245
 246 void    load2_unload_thread( int id, const std::string& modulename ){
 247     schedule_module_control_testclass& control = schedule_module_control_testclass::getInstance();
 248     l7vs::schedule_module_base*        schedule1 = NULL;
 249     schedule1 = control.load_module2( id, modulename );
 250     control.unload_module( schedule1 );
 251
 252     control.finalize();
 253 }
 254
 255 void    schedule_module_control_test_thread1(){
 256     schedule_module_control_testclass& control = schedule_module_control_testclass::getInstance();
 257     control.initialize( "." );
 258
 259     schedule_module_control::name_module_info_map& loadmodulemap = control.get_loadmodule_map();
 260     BOOST_CHECK_EQUAL( loadmodulemap.size(), (size_t)0 );
 261 #if 1
 262     // unit_test[1] スレッド１はPM1のロードとアンロード、スレッド２はPM2のロードとアンロードを行い、最終的にロードモジュールのマップのサイズが0となっていることを確認する
 263     boost::thread    thd1( &thread1 );
 264     boost::thread    thd2( &thread2 );
 265     thd1.join();
 266     thd2.join();
 267     BOOST_CHECK_EQUAL( loadmodulemap.size(), (size_t)0 );
 268 #endif
 269     control.finalize();
 270 }
 271
 272 void    schedule_module_control_test_thread2(){
 273     schedule_module_control_testclass& control = schedule_module_control_testclass::getInstance();
 274     control.initialize( "." );
 275
 276     schedule_module_control::name_module_info_map& loadmodulemap = control.get_loadmodule_map();
 277     BOOST_CHECK_EQUAL( loadmodulemap.size(), (size_t)0 );
 278 #if 1
 279     // unit_test[2] スレッド１はPM1のロード、スレッド２はPM1のロードを行い、最終的にロードモジュールのマップのサイズが1となっていることを確認する
 280     boost::thread    thd1( &thread3 );
 281     boost::thread    thd2( &thread4 );
 282     thd1.join();
 283     thd2.join();
 284     BOOST_CHECK_EQUAL( loadmodulemap.size(), (size_t)1 );
 285
 286     // unit_test[3] スレッド３はPM1のアンロード、スレッド４はPM1のアンロードを行い、最終的にロードモジュールのマップのサイズが0となっていることを確認する
 287     boost::thread    thd3( &thread5 );
 288     boost::thread    thd4( &thread6 );
 289     thd3.join();
 290     thd4.join();
 291     BOOST_CHECK_EQUAL( loadmodulemap.size(), (size_t)0 );
 292 #endif
 293     control.finalize();
 294 }
 295
 296 void    schedule_module_control_test_thread3(){
 297     schedule_module_control_testclass& control = schedule_module_control_testclass::getInstance();
 298     control.initialize( "." );
 299
 300     schedule_module_control::name_module_info_map& loadmodulemap = control.get_loadmodule_map();
 301     BOOST_CHECK_EQUAL( loadmodulemap.size(), (size_t)0 );
 302     // unit_test[4] スレッド１はPM1のロードとアンロード、スレッド２はPM1のロードとアンロードを行い、最終的にロードモジュールのマップのサイズが0となっていることを確認する
 303     boost::thread    thd1( &thread7 );
 304     boost::thread    thd2( &thread8 );
 305     thd1.join();
 306     thd2.join();
 307     BOOST_CHECK_EQUAL( loadmodulemap.size(), (size_t)0 );
 308     control.finalize();
 309 }
 310
 311 void    schedule_module_control_test_thread4(){
 312     schedule_module_control_testclass& control = schedule_module_control_testclass::getInstance();
 313     control.initialize( "." );
 314
 315     schedule_module_control::name_module_info_map& loadmodulemap = control.get_loadmodule_map();
 316     BOOST_CHECK_EQUAL( loadmodulemap.size(), (size_t)0 );
 317     // unit_test[5] スレッド１はPM1のロード/アンロード、スレッド２はPM2のロード/アンロードをそれぞれセットで行い、最終的にロードモジュールのマップのサイズが0となっていることを確認する
 318     boost::thread    thd1( &thread9 );
 319     boost::thread    thd2( &thread10 );
 320     thd1.join();
 321     thd2.join();
 322     loadmodulemap = control.get_loadmodule_map();
 323     BOOST_CHECK_EQUAL( loadmodulemap.size(), (size_t)0 );
 324     control.finalize();
 325 }
 326
 327 void    schedule_module_control_test_thread5(){
 328     schedule_module_control_testclass& control = schedule_module_control_testclass::getInstance();
 329     control.initialize( "." );
 330     schedule_module_control::name_module_info_map& loadmodulemap = control.get_loadmodule_map();
 331     loadmodulemap = control.get_loadmodule_map();
 332     BOOST_CHECK_EQUAL( loadmodulemap.size(), (size_t)0 );
 333
 334     // unit_test[6] load_moduleを複数スレッドからアクセスした場合の動作チェック（同じモジュールを指定した場合）
 335     boost::thread    thd1( boost::bind( &load2_unload2_thread, 1, PM1 ) );
 336     boost::thread    thd2( boost::bind( &load2_unload2_thread, 2, PM1 ) );
 337     boost::thread    thd3( boost::bind( &load2_unload2_thread, 3, PM1 ) );
 338     boost::thread    thd4( boost::bind( &load2_unload2_thread, 4, PM1 ) );
 339     boost::thread    thd5( boost::bind( &load2_unload2_thread, 5, PM1 ) );
 340
 341     sleep(1);
 342     loadmodulemap = control.get_loadmodule_map();
 343     BOOST_CHECK_EQUAL( loadmodulemap.size(), (size_t)0 );
 344     BOOST_MESSAGE( "notify_all" );
 345     control.load_condition.notify_all();
 346
 347     sleep(1);
 348     loadmodulemap = control.get_loadmodule_map();
 349     BOOST_CHECK_EQUAL( loadmodulemap.size(), (size_t)1 );
 350     // unit_test[7] unload_moduleを複数スレッドからアクセスした場合の動作チェック（同じモジュールを指定した場合）
 351     BOOST_MESSAGE( "notify_all" );
 352     control.load_condition.notify_all();
 353
 354     thd1.join();
 355     thd2.join();
 356     thd3.join();
 357     thd4.join();
 358     thd5.join();
 359
 360     loadmodulemap = control.get_loadmodule_map();
 361     BOOST_CHECK_EQUAL( loadmodulemap.size(), (size_t)0 );
 362
 363     // unit_test[8] load_moduleとunload_moduleを複数スレッドからアクセスした場合の動作チェック（同じモジュールを指定した場合）
 364     boost::thread    thd6( boost::bind( &load2_unload_thread, 6, PM1 ) );
 365     boost::thread    thd7( boost::bind( &load_unload2_thread, 7, PM1 ) );
 366
 367     sleep(1);
 368     loadmodulemap = control.get_loadmodule_map();
 369     BOOST_CHECK_EQUAL( loadmodulemap.size(), (size_t)1 );
 370     BOOST_MESSAGE( "notify_all" );
 371     control.load_condition.notify_all();
 372
 373     thd6.join();
 374     thd7.join();
 375
 376     loadmodulemap = control.get_loadmodule_map();
 377     BOOST_CHECK_EQUAL( loadmodulemap.size(), (size_t)0 );
 378
 379     // unit_test[9] load_moduleを複数スレッドからアクセスした場合の動作チェック（それぞれ別のモジュールを指定した場合）
 380     boost::thread    thd8( boost::bind( &load2_unload2_thread, 8, PM1 ) );
 381     boost::thread    thd9( boost::bind( &load2_unload2_thread, 9, PM2 ) );
 382
 383     sleep(1);
 384     loadmodulemap = control.get_loadmodule_map();
 385     BOOST_CHECK_EQUAL( loadmodulemap.size(), (size_t)0 );
 386     BOOST_MESSAGE( "notify_all" );
 387     control.load_condition.notify_all();
 388
 389     sleep(1);
 390     loadmodulemap = control.get_loadmodule_map();
 391     BOOST_CHECK_EQUAL( loadmodulemap.size(), (size_t)2 );
 392     // unit_test[10] unload_moduleを複数スレッドからアクセスした場合の動作チェック（それぞれ別のモジュールを指定した場合）
 393     BOOST_MESSAGE( "notify_all" );
 394     control.load_condition.notify_all();
 395
 396     thd8.join();
 397     thd9.join();
 398
 399     loadmodulemap = control.get_loadmodule_map();
 400     BOOST_CHECK_EQUAL( loadmodulemap.size(), (size_t)0 );
 401
 402     // unit_test[11] load_moduleとunload_moduleを複数スレッドからアクセスした場合の動作チェック（それぞれ別のモジュールを指定した場合）
 403     boost::thread    thd10( boost::bind( &load2_unload_thread, 10, PM1 ) );
 404     boost::thread    thd11( boost::bind( &load_unload2_thread, 11, PM2 ) );
 405
 406     sleep(1);
 407     loadmodulemap = control.get_loadmodule_map();
 408     BOOST_CHECK_EQUAL( loadmodulemap.size(), (size_t)1 );
 409     BOOST_MESSAGE( "notify_all" );
 410     control.load_condition.notify_all();
 411
 412     thd10.join();
 413     thd11.join();
 414
 415     loadmodulemap = control.get_loadmodule_map();
 416     BOOST_CHECK_EQUAL( loadmodulemap.size(), (size_t)0 );
 417     control.finalize();
 418 }
 419
 420 test_suite*    init_unit_test_suite( int argc, char* argv[] ){
 421
 422 //    Logger logger;
 423 //    l7vs::Parameter param;
 424
 425     // create unit test suite
 426     test_suite* ts = BOOST_TEST_SUITE( "schedule_module_control_thread_test" );
 427
 428     // add test case to test suite
 429     ts->add( BOOST_TEST_CASE( &schedule_module_control_test_thread1 ) );
 430     ts->add( BOOST_TEST_CASE( &schedule_module_control_test_thread2 ) );
 431     ts->add( BOOST_TEST_CASE( &schedule_module_control_test_thread3 ) );
 432     ts->add( BOOST_TEST_CASE( &schedule_module_control_test_thread4 ) );
 433     ts->add( BOOST_TEST_CASE( &schedule_module_control_test_thread5 ) );
 434
 435     framework::master_test_suite().add( ts );
 436
 437     return 0;
 438 }