l7vsd/unit_tests/realserver_test/realserver_test.cpp

   1 #include <iostream>
   2 #include <boost/test/included/unit_test.hpp>
   3 #include <boost/thread/condition.hpp>
   4 #include "realserver.h"
   5 #include "logger.h"
   6 #include "parameter.h"
   7
   8 //class    l7vs::realserver;
   9
  10 using namespace boost::unit_test;
  11
  12
  13 namespace l7vs{
  14
  15
  16 class realserver_fake : public realserver
  17 {
  18 public:
  19     boost::mutex        starting_mutex;
  20     boost::condition    starting_condition;
  21
  22     //!    constractor
  23     realserver_fake(){}
  24     //! destractor
  25     ~realserver_fake(){}
  26
  27     void    set_active( const int in_active ){
  28         boost::mutex::scoped_lock lock( *active_mutex_ptr );
  29
  30         nactive = in_active ;
  31     }
  32     void    set_inact( const int in_inact ){
  33         boost::mutex::scoped_lock lock( *inact_mutex_ptr );
  34
  35         ninact = in_inact ;
  36     }
  37
  38     void    increment_active2( const std::string& msg1, const std::string& msg2, const std::string& msg3, const std::string& msg4 ){
  39         {
  40             boost::mutex::scoped_lock    lock( starting_mutex );
  41             starting_condition.wait( lock );
  42         }
  43
  44         BOOST_MESSAGE( msg1 );
  45 //        increment_active();
  46         {
  47             boost::mutex::scoped_lock lock( *active_mutex_ptr );
  48
  49             BOOST_MESSAGE( msg3 );
  50             nactive++;
  51             if ( nactive == INT_MAX ){
  52                 nactive = 0;
  53             }
  54             BOOST_MESSAGE( msg4 );
  55 //            sleep(1);
  56         }
  57         BOOST_MESSAGE( msg2 );
  58     }
  59
  60     void    decrement_active2( const std::string& msg1, const std::string& msg2, const std::string& msg3, const std::string& msg4 ){
  61         {
  62             boost::mutex::scoped_lock    lock( starting_mutex );
  63             starting_condition.wait( lock );
  64         }
  65
  66         BOOST_MESSAGE( msg1 );
  67 //        decrement_active();
  68         {
  69             boost::mutex::scoped_lock lock( *active_mutex_ptr );
  70
  71             BOOST_MESSAGE( msg3 );
  72             if ( nactive > 0 ){
  73                 nactive--;
  74             }
  75             BOOST_MESSAGE( msg4 );
  76 //            sleep(1);
  77         }
  78         BOOST_MESSAGE( msg2 );
  79     }
  80
  81     void    increment_inact2( const std::string& msg1, const std::string& msg2, const std::string& msg3, const std::string& msg4 ){
  82         {
  83             boost::mutex::scoped_lock    lock( starting_mutex );
  84             starting_condition.wait( lock );
  85         }
  86
  87         BOOST_MESSAGE( msg1 );
  88 //        increment_inact();
  89         {
  90             boost::mutex::scoped_lock lock( *inact_mutex_ptr );
  91
  92             BOOST_MESSAGE( msg3 );
  93             ninact++;
  94             if ( ninact == INT_MAX ){
  95                 ninact = 0;
  96             }
  97             BOOST_MESSAGE( msg4 );
  98 //            sleep(1);
  99         }
 100         BOOST_MESSAGE( msg2 );
 101     }
 102 };
 103
 104 }    //namespace l7vs
 105
 106 l7vs::realserver_fake    rush_server;
 107
 108 void starting_thread( int id )
 109 {
 110     {
 111         std::stringstream    msg1, msg2, msg3, msg4;
 112
 113         msg1 << "start increment_active <Thread:" << id << ">";
 114         msg2 << "complete increment_active <Thread:" << id << ">";
 115         msg3 << "start inside <Thread:" << id << ">";
 116         msg4 << "complete inside <Thread:" << id << ">";
 117         rush_server.increment_active2( msg1.str(), msg2.str(), msg3.str(), msg4.str() );
 118     }
 119     {
 120         std::stringstream    msg1, msg2, msg3, msg4;
 121
 122         msg1 << "start decrement_active <Thread:" << id << ">";
 123         msg2 << "complete decrement_active <Thread:" << id << ">";
 124         msg3 << "start inside <Thread:" << id << ">";
 125         msg4 << "complete inside <Thread:" << id << ">";
 126         rush_server.decrement_active2( msg1.str(), msg2.str(), msg3.str(), msg4.str() );
 127     }
 128     {
 129         std::stringstream    msg1, msg2, msg3, msg4;
 130
 131         msg1 << "start increment_inact <Thread:" << id << ">";
 132         msg2 << "complete increment_inact <Thread:" << id << ">";
 133         msg3 << "start inside <Thread:" << id << ">";
 134         msg4 << "complete inside <Thread:" << id << ">";
 135         rush_server.increment_inact2( msg1.str(), msg2.str(), msg3.str(), msg4.str() );
 136     }
 137 };
 138
 139
 140 //test case1.
 141 void    realserver_test(){
 142     int                    nactive = 0;
 143     int                    ninact = 0;
 144     unsigned long long    send_byte = 0ULL;
 145     int                    weight = -1;
 146
 147     // unit_test[1]  コンストラクタのテスト（全てが初期化済み）
 148     l7vs::realserver    server1;
 149
 150     BOOST_CHECK_EQUAL( nactive, server1.get_active() );
 151     BOOST_CHECK_EQUAL( ninact, server1.get_inact() );
 152     BOOST_CHECK_EQUAL( send_byte, server1.send_byte );
 153     BOOST_CHECK_EQUAL( weight, server1.weight );
 154
 155     // unit_test[2]  コピーコンストラクタのテスト（全てがコピー元と同じ）
 156     server1.tcp_endpoint = boost::asio::ip::tcp::endpoint ( boost::asio::ip::address::from_string( "11.11.11.11" ), 11 ) ;
 157     server1.udp_endpoint = boost::asio::ip::udp::endpoint ( boost::asio::ip::address::from_string( "22.22.22.22" ), 22 ) ;
 158     server1.send_byte = 10;
 159     server1.weight = 0;
 160     server1.increment_active();
 161     server1.increment_inact();
 162
 163     l7vs::realserver    server2( server1 );
 164
 165     BOOST_CHECK_EQUAL( server2.get_active(), server1.get_active() );
 166     BOOST_CHECK_EQUAL( server2.get_inact(), server1.get_inact() );
 167     BOOST_CHECK_EQUAL( server2.send_byte, server1.send_byte );
 168     BOOST_CHECK_EQUAL( server2.weight, server1.weight );
 169     BOOST_CHECK( server2.tcp_endpoint == server1.tcp_endpoint );
 170     BOOST_CHECK( server2.udp_endpoint == server1.udp_endpoint );
 171
 172
 173     // unit_test[3]  比較オペレータのテスト（TCPエンドポイントが異なるとエラー）
 174     BOOST_CHECK_EQUAL( ( server1 == server2 ), true );
 175
 176     server1.tcp_endpoint = boost::asio::ip::tcp::endpoint ( boost::asio::ip::address::from_string( "33.33.33.33" ), 33 ) ;
 177     BOOST_CHECK_EQUAL( ( server1 == server2 ), false );
 178     BOOST_CHECK_EQUAL( server2.get_active(), server1.get_active() );
 179     BOOST_CHECK_EQUAL( server2.get_inact(), server1.get_inact() );
 180     BOOST_CHECK_EQUAL( server2.send_byte, server1.send_byte );
 181     BOOST_CHECK_EQUAL( server2.weight, server1.weight );
 182     BOOST_CHECK( server2.tcp_endpoint != server1.tcp_endpoint );
 183     BOOST_CHECK( server2.udp_endpoint == server1.udp_endpoint );
 184
 185     // unit_test[4]  比較オペレータのテスト２（UDPエンドポイントが異なるとエラー）
 186     server1 = server2;
 187     server1.udp_endpoint = boost::asio::ip::udp::endpoint ( boost::asio::ip::address::from_string( "44.44.44.44" ), 44 ) ;
 188     BOOST_CHECK_EQUAL( ( server1 == server2 ), false );
 189     BOOST_CHECK_EQUAL( server2.get_active(), server1.get_active() );
 190     BOOST_CHECK_EQUAL( server2.get_inact(), server1.get_inact() );
 191     BOOST_CHECK_EQUAL( server2.send_byte, server1.send_byte );
 192     BOOST_CHECK_EQUAL( server2.weight, server1.weight );
 193     BOOST_CHECK( server2.tcp_endpoint == server1.tcp_endpoint );
 194     BOOST_CHECK( server2.udp_endpoint != server1.udp_endpoint );
 195
 196     // unit_test[5]  比較オペレータのテスト３（weightが異なるとエラー）
 197     server1 = server2;
 198     server1.weight = 3;
 199     BOOST_CHECK_EQUAL( ( server1 == server2 ), false );
 200     BOOST_CHECK_EQUAL( server2.get_active(), server1.get_active() );
 201     BOOST_CHECK_EQUAL( server2.get_inact(), server1.get_inact() );
 202     BOOST_CHECK_EQUAL( server2.send_byte, server1.send_byte );
 203     BOOST_CHECK( server2.weight != server1.weight );
 204     BOOST_CHECK( server2.tcp_endpoint == server1.tcp_endpoint );
 205     BOOST_CHECK( server2.udp_endpoint == server1.udp_endpoint );
 206
 207     // unit_test[6]  比較オペレータのテスト４（接続数が異なっても問題無し）
 208     server1 = server2;
 209     server1.increment_active();
 210     BOOST_CHECK_EQUAL( ( server1 == server2 ), true );
 211     BOOST_CHECK( server2.get_active() != server1.get_active() );
 212     BOOST_CHECK_EQUAL( server2.get_inact(), server1.get_inact() );
 213     BOOST_CHECK_EQUAL( server2.send_byte, server1.send_byte );
 214     BOOST_CHECK_EQUAL( server2.weight, server1.weight );
 215     BOOST_CHECK( server2.tcp_endpoint == server1.tcp_endpoint );
 216     BOOST_CHECK( server2.udp_endpoint == server1.udp_endpoint );
 217
 218     // unit_test[7]  比較オペレータのテスト５（切断数が異なっても問題無し）
 219     server1 = server2;
 220     server1.increment_inact();
 221     BOOST_CHECK_EQUAL( ( server1 == server2 ), true );
 222     BOOST_CHECK_EQUAL( server2.get_active(), server1.get_active() );
 223     BOOST_CHECK( server2.get_inact() != server1.get_inact() );
 224     BOOST_CHECK_EQUAL( server2.send_byte, server1.send_byte );
 225     BOOST_CHECK_EQUAL( server2.weight, server1.weight );
 226     BOOST_CHECK( server2.tcp_endpoint == server1.tcp_endpoint );
 227     BOOST_CHECK( server2.udp_endpoint == server1.udp_endpoint );
 228
 229     // unit_test[8]  比較オペレータのテスト６（送信バイト数が異なっても問題無し）
 230     server1 = server2;
 231     server1.send_byte = 100;
 232     BOOST_CHECK_EQUAL( ( server1 == server2 ), true );
 233     BOOST_CHECK_EQUAL( server2.get_active(), server1.get_active() );
 234     BOOST_CHECK_EQUAL( server2.get_inact(), server1.get_inact() );
 235     BOOST_CHECK( server2.send_byte != server1.send_byte );
 236     BOOST_CHECK_EQUAL( server2.weight, server1.weight );
 237     BOOST_CHECK( server2.tcp_endpoint == server1.tcp_endpoint );
 238     BOOST_CHECK( server2.udp_endpoint == server1.udp_endpoint );
 239
 240     // unit_test[9]  否定オペレータのテスト（TCPエンドポイントが異なると検出）
 241     server1 = server2;
 242
 243     BOOST_CHECK_EQUAL( ( server1 != server2 ), false);
 244
 245     server1.tcp_endpoint = boost::asio::ip::tcp::endpoint ( boost::asio::ip::address::from_string( "33.33.33.33" ), 33 ) ;
 246     BOOST_CHECK_EQUAL( ( server1 != server2 ), true );
 247     BOOST_CHECK_EQUAL( server2.get_active(), server1.get_active() );
 248     BOOST_CHECK_EQUAL( server2.get_inact(), server1.get_inact() );
 249     BOOST_CHECK_EQUAL( server2.send_byte, server1.send_byte );
 250     BOOST_CHECK_EQUAL( server2.weight, server1.weight );
 251     BOOST_CHECK( server2.tcp_endpoint != server1.tcp_endpoint );
 252     BOOST_CHECK( server2.udp_endpoint == server1.udp_endpoint );
 253
 254     // unit_test[10]  否定オペレータのテスト２（UDPエンドポイントが異なると検出）
 255     server1 = server2;
 256     server1.udp_endpoint = boost::asio::ip::udp::endpoint ( boost::asio::ip::address::from_string( "44.44.44.44" ), 44 ) ;
 257     BOOST_CHECK_EQUAL( ( server1 != server2 ), true );
 258     BOOST_CHECK_EQUAL( server2.get_active(), server1.get_active() );
 259     BOOST_CHECK_EQUAL( server2.get_inact(), server1.get_inact() );
 260     BOOST_CHECK_EQUAL( server2.send_byte, server1.send_byte );
 261     BOOST_CHECK_EQUAL( server2.weight, server1.weight );
 262     BOOST_CHECK( server2.tcp_endpoint == server1.tcp_endpoint );
 263     BOOST_CHECK( server2.udp_endpoint != server1.udp_endpoint );
 264
 265     // unit_test[11]  否定オペレータのテスト３（weightが異なると検出）
 266     server1 = server2;
 267     server1.weight = 3;
 268     BOOST_CHECK_EQUAL( ( server1 != server2 ), true );
 269     BOOST_CHECK_EQUAL( server2.get_active(), server1.get_active() );
 270     BOOST_CHECK_EQUAL( server2.get_inact(), server1.get_inact() );
 271     BOOST_CHECK_EQUAL( server2.send_byte, server1.send_byte );
 272     BOOST_CHECK( server2.weight != server1.weight );
 273     BOOST_CHECK( server2.tcp_endpoint == server1.tcp_endpoint );
 274     BOOST_CHECK( server2.udp_endpoint == server1.udp_endpoint );
 275
 276     // unit_test[12]  否定オペレータのテスト４（接続数が異なっても問題無し）
 277     server1 = server2;
 278     server1.increment_active();
 279     BOOST_CHECK_EQUAL( ( server1 != server2 ), false );
 280     BOOST_CHECK( server2.get_active() != server1.get_active() );
 281     BOOST_CHECK_EQUAL( server2.get_inact(), server1.get_inact() );
 282     BOOST_CHECK_EQUAL( server2.send_byte, server1.send_byte );
 283     BOOST_CHECK_EQUAL( server2.weight, server1.weight );
 284     BOOST_CHECK( server2.tcp_endpoint == server1.tcp_endpoint );
 285     BOOST_CHECK( server2.udp_endpoint == server1.udp_endpoint );
 286
 287     // unit_test[13]  否定オペレータのテスト５（切断数が異なっても問題無し）
 288     server1 = server2;
 289     server1.increment_inact();
 290     BOOST_CHECK_EQUAL( ( server1 != server2 ), false );
 291     BOOST_CHECK_EQUAL( server2.get_active(), server1.get_active() );
 292     BOOST_CHECK( server2.get_inact() != server1.get_inact() );
 293     BOOST_CHECK_EQUAL( server2.send_byte, server1.send_byte );
 294     BOOST_CHECK_EQUAL( server2.weight, server1.weight );
 295     BOOST_CHECK( server2.tcp_endpoint == server1.tcp_endpoint );
 296     BOOST_CHECK( server2.udp_endpoint == server1.udp_endpoint );
 297
 298     // unit_test[14]  否定オペレータのテスト６（送信バイト数が異なっても問題無し）
 299     server1 = server2;
 300     server1.send_byte = 100;
 301     BOOST_CHECK_EQUAL( ( server1 != server2 ), false );
 302     BOOST_CHECK_EQUAL( server2.get_active(), server1.get_active() );
 303     BOOST_CHECK_EQUAL( server2.get_inact(), server1.get_inact() );
 304     BOOST_CHECK( server2.send_byte != server1.send_byte );
 305     BOOST_CHECK_EQUAL( server2.weight, server1.weight );
 306     BOOST_CHECK( server2.tcp_endpoint == server1.tcp_endpoint );
 307     BOOST_CHECK( server2.udp_endpoint == server1.udp_endpoint );
 308
 309     // unit_test[15]  コピーオペレータのテスト（全てがコピー元と同じ）
 310     server1 = l7vs::realserver();
 311     server2 = server1 ;
 312
 313     BOOST_CHECK_EQUAL( server2.get_active(), server1.get_active() );
 314     BOOST_CHECK_EQUAL( server2.get_inact(), server1.get_inact() );
 315     BOOST_CHECK_EQUAL( server2.send_byte, server1.send_byte );
 316     BOOST_CHECK_EQUAL( server2.weight, server1.weight );
 317     BOOST_CHECK( server2.tcp_endpoint == server1.tcp_endpoint );
 318     BOOST_CHECK( server2.udp_endpoint == server1.udp_endpoint );
 319
 320     BOOST_CHECK( server1 == server2 );
 321
 322     // unit_test[16]  大小比較オペレータのテスト（TCPエンドポイントが大きいと検出）
 323     server1.tcp_endpoint = boost::asio::ip::tcp::endpoint ( boost::asio::ip::address::from_string( "10.144.169.86" ), 21 ) ;
 324
 325     BOOST_CHECK_EQUAL( ( server2 < server1 ), true );
 326     BOOST_CHECK_EQUAL( server2.get_active(), server1.get_active() );
 327     BOOST_CHECK_EQUAL( server2.get_inact(), server1.get_inact() );
 328     BOOST_CHECK_EQUAL( server2.send_byte, server1.send_byte );
 329     BOOST_CHECK_EQUAL( server2.weight, server1.weight );
 330     BOOST_CHECK( server2.tcp_endpoint < server1.tcp_endpoint );
 331     BOOST_CHECK( server2.udp_endpoint == server1.udp_endpoint );
 332
 333     // unit_test[17]  大小比較オペレータのテスト２（UDPエンドポイントが異なっても問題無し）
 334     server1 = server2;
 335     server1.udp_endpoint = boost::asio::ip::udp::endpoint ( boost::asio::ip::address::from_string( "10.144.169.86" ), 21 ) ;
 336
 337     BOOST_CHECK_EQUAL( ( server2 < server1 ), false );
 338     BOOST_CHECK_EQUAL( server2.get_active(), server1.get_active() );
 339     BOOST_CHECK_EQUAL( server2.get_inact(), server1.get_inact() );
 340     BOOST_CHECK_EQUAL( server2.send_byte, server1.send_byte );
 341     BOOST_CHECK_EQUAL( server2.weight, server1.weight );
 342     BOOST_CHECK( server2.tcp_endpoint == server1.tcp_endpoint );
 343     BOOST_CHECK( server2.udp_endpoint < server1.udp_endpoint );
 344
 345     // unit_test[18]  大小比較オペレータのテスト３（TCPが等しくweightが大きいと検出）
 346     server1 = server2;
 347     server1.weight = 10;
 348
 349     BOOST_CHECK_EQUAL( ( server2 < server1 ), true );
 350     BOOST_CHECK_EQUAL( server2.get_active(), server1.get_active() );
 351     BOOST_CHECK_EQUAL( server2.get_inact(), server1.get_inact() );
 352     BOOST_CHECK_EQUAL( server2.send_byte, server1.send_byte );
 353     BOOST_CHECK( server2.weight < server1.weight );
 354     BOOST_CHECK( server2.tcp_endpoint == server1.tcp_endpoint );
 355     BOOST_CHECK( server2.udp_endpoint == server1.udp_endpoint );
 356
 357     // unit_test[19]  大小比較オペレータのテスト４（接続数が異なっても問題無し）
 358     server1 = server2;
 359     server1.increment_active();
 360     BOOST_CHECK_EQUAL( ( server2 < server1 ), false );
 361     BOOST_CHECK( server2.get_active() != server1.get_active() );
 362     BOOST_CHECK_EQUAL( server2.get_inact(), server1.get_inact() );
 363     BOOST_CHECK_EQUAL( server2.send_byte, server1.send_byte );
 364     BOOST_CHECK_EQUAL( server2.weight, server1.weight );
 365     BOOST_CHECK( server2.tcp_endpoint == server1.tcp_endpoint );
 366     BOOST_CHECK( server2.udp_endpoint == server1.udp_endpoint );
 367
 368     // unit_test[20]  大小比較オペレータのテスト５（切断数が異なっても問題無し）
 369     server1 = server2;
 370     server1.increment_inact();
 371     BOOST_CHECK_EQUAL( ( server2 < server1 ), false );
 372     BOOST_CHECK_EQUAL( server2.get_active(), server1.get_active() );
 373     BOOST_CHECK( server2.get_inact() != server1.get_inact() );
 374     BOOST_CHECK_EQUAL( server2.send_byte, server1.send_byte );
 375     BOOST_CHECK_EQUAL( server2.weight, server1.weight );
 376     BOOST_CHECK( server2.tcp_endpoint == server1.tcp_endpoint );
 377     BOOST_CHECK( server2.udp_endpoint == server1.udp_endpoint );
 378
 379     // unit_test[21]  大小比較オペレータのテスト６（送信バイト数が異なっても問題無し）
 380     server1 = server2;
 381     server1.send_byte = 100;
 382     BOOST_CHECK_EQUAL( ( server2 < server1 ), false );
 383     BOOST_CHECK_EQUAL( server2.get_active(), server1.get_active() );
 384     BOOST_CHECK_EQUAL( server2.get_inact(), server1.get_inact() );
 385     BOOST_CHECK( server2.send_byte != server1.send_byte );
 386     BOOST_CHECK_EQUAL( server2.weight, server1.weight );
 387     BOOST_CHECK( server2.tcp_endpoint == server1.tcp_endpoint );
 388     BOOST_CHECK( server2.udp_endpoint == server1.udp_endpoint );
 389
 390     // unit_test[22]  接続数取得メソッドのテスト
 391     BOOST_CHECK_EQUAL( server1.get_active(), nactive );
 392
 393     // unit_test[23]  切断数取得メソッドのテスト
 394     BOOST_CHECK_EQUAL( server1.get_inact(), ninact );
 395
 396     // unit_test[24]  接続数インクリメントメソッドのテスト
 397     server1.increment_active();
 398     BOOST_CHECK_EQUAL( server1.get_active(), 1 );
 399
 400     // unit_test[25]  接続数デクリメントメソッドのテスト
 401     server1.decrement_active();
 402     BOOST_CHECK_EQUAL( server1.get_active(), 0 );
 403
 404     // unit_test[26]  接続数インクリメントメソッドのテスト２（上限INT_MAXに達すると0にクリア）
 405 //    BOOST_MESSAGE( "wait a minute to INT_MAX" );
 406 //    for ( int loop = 0; loop < INT_MAX; loop++ ){
 407 //        server1.increment_active();
 408 //    }
 409 //    BOOST_CHECK_EQUAL( server1.get_active(), 0 );
 410
 411     l7vs::realserver_fake    server3;
 412
 413     nactive = INT_MAX - 1 ;
 414     server3.set_active( nactive );
 415     BOOST_CHECK_EQUAL( server3.get_active(), nactive );
 416
 417     server3.increment_active();
 418     BOOST_CHECK_EQUAL( server3.get_active(), 0 );
 419
 420     // unit_test[27]  接続数デクリメントメソッドのテスト２（0に対しては何も行わない）
 421     server1.decrement_active();
 422     BOOST_CHECK_EQUAL( server1.get_active(), 0 );
 423
 424     // unit_test[28]  切断数インクリメントメソッドのテスト
 425     server1.increment_inact();
 426     BOOST_CHECK_EQUAL( server1.get_inact(), 1 );
 427
 428     // unit_test[29]  切断数インクリメントメソッドのテスト２（上限INT_MAXに達すると0にクリア）
 429 //    BOOST_MESSAGE( "wait a minute to INT_MAX" );
 430 //    for ( int loop = server1.get_inact(); loop < INT_MAX; loop++ ){
 431 //        server1.increment_inact();
 432 //    }
 433 //    BOOST_CHECK_EQUAL( server1.get_inact(), 0 );
 434
 435     ninact = INT_MAX - 1 ;
 436     server3.set_inact( ninact );
 437     BOOST_CHECK_EQUAL( server3.get_inact(), ninact );
 438
 439     server3.increment_inact();
 440     BOOST_CHECK_EQUAL( server3.get_inact(), 0 );
 441
 442
 443     boost::thread    thread_item1( boost::bind ( &starting_thread, 1 ) );
 444     boost::thread    thread_item2( boost::bind ( &starting_thread, 2 ) );
 445     boost::thread    thread_item3( boost::bind ( &starting_thread, 3 ) );
 446     boost::thread    thread_item4( boost::bind ( &starting_thread, 4 ) );
 447     boost::thread    thread_item5( boost::bind ( &starting_thread, 5 ) );
 448
 449     // unit_test[30]  接続数インクリメントメソッドのテスト３（複数スレッドから同時アクセス）
 450     BOOST_MESSAGE( "sleep in" );
 451     sleep( 1 );
 452     rush_server.starting_condition.notify_all();
 453     sleep( 2 );
 454     BOOST_CHECK_EQUAL( rush_server.get_active(), 5 );
 455
 456     // unit_test[31]  接続数デクリメントメソッドのテスト３（複数スレッドから同時アクセス）
 457     BOOST_MESSAGE( "sleep in" );
 458     sleep( 1 );
 459     rush_server.starting_condition.notify_all();
 460     sleep( 2 );
 461     BOOST_CHECK_EQUAL( rush_server.get_active(), 0 );
 462
 463     // unit_test[32]  切断数インクリメントメソッドのテスト３（複数スレッドから同時アクセス）
 464     BOOST_MESSAGE( "sleep in" );
 465     sleep( 1 );
 466     rush_server.starting_condition.notify_all();
 467     sleep( 2 );
 468
 469     thread_item1.join();
 470     thread_item2.join();
 471     thread_item3.join();
 472     thread_item4.join();
 473     thread_item5.join();
 474
 475     BOOST_CHECK_EQUAL( rush_server.get_inact(), 5 );
 476
 477
 478     // nactive, ninactをelement時のみsettter有効にする評価
 479     l7vs::realserver            rs;
 480     rs.increment_active();
 481 //    rs.set_active( 10 );        // protectedなので変更できない（コンパイルエラー）
 482     BOOST_CHECK( rs.get_active() != 10 );
 483     rs.increment_inact();
 484 //    rs.set_inact( 10 );            // protectedなので変更できない（コンパイルエラー）
 485     BOOST_CHECK( rs.get_inact() != 10 );
 486
 487     // こんなことするとrealserver上からも変更できてしまうけどそれは不正なので無視とする
 488 //    l7vs::realserver_element&    rs_elem2( rs );
 489 //    rs_elem2.set_active( 10 );
 490 //    BOOST_CHECK( rs.get_active() != 10 );
 491 //    rs_elem2.set_inact( 10 );
 492 //    BOOST_CHECK( rs.get_inact() != 10 );
 493
 494
 495     l7vs::realserver_element    rs_elem( rs );
 496     BOOST_CHECK_EQUAL( rs_elem.get_active(), 1 );
 497     BOOST_CHECK_EQUAL( rs_elem.get_inact(), 1 );
 498     rs_elem.set_active( 0 );        // publicなので設定可能
 499     rs_elem.set_inact( 0 );            // publicなので設定可能
 500     BOOST_CHECK_EQUAL( rs_elem.get_active(), 0 );
 501     BOOST_CHECK_EQUAL( rs_elem.get_inact(), 0 );
 502 }
 503
 504 test_suite*    init_unit_test_suite( int argc, char* argv[] ){
 505 //    l7vs::Logger    logger;
 506 //    l7vs::Parameter    parameter;
 507
 508 //    logger.loadConf();
 509
 510     // create unit test suite
 511     test_suite* ts = BOOST_TEST_SUITE( "realserver_test" );
 512
 513     // add test case to test suite
 514     ts->add( BOOST_TEST_CASE( &realserver_test ) );
 515
 516     framework::master_test_suite().add( ts );
 517
 518     return 0;
 519 }
 520