jsp/cfg/base/component.cpp

   1 /*
   2  *  TOPPERS/JSP Kernel
   3  *      Toyohashi Open Platform for Embedded Real-Time Systems/
   4  *      Just Standard Profile Kernel
   5  *
   6  *  Copyright (C) 2000-2003 by Embedded and Real-Time Systems Laboratory
   7  *                              Toyohashi Univ. of Technology, JAPAN
   8  *
   9  *  上記著作権者は，以下の (1)〜(4) の条件か，Free Software Foundation
  10  *  によって公表されている GNU General Public License の Version 2 に記
  11  *  述されている条件を満たす場合に限り，本ソフトウェア（本ソフトウェア
  12  *  を改変したものを含む．以下同じ）を使用・複製・改変・再配布（以下，
  13  *  利用と呼ぶ）することを無償で許諾する．
  14  *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
  15  *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
  16  *      スコード中に含まれていること．
  17  *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
  18  *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
  19  *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
  20  *      の無保証規定を掲載すること．
  21  *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
  22  *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
  23  *      と．
  24  *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
  25  *        作権表示，この利用条件および下記の無保証規定を掲載すること．
  26  *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
  27  *        報告すること．
  28  *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
  29  *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
  30  *
  31  *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
  32  *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，その適用可能性も
  33  *  含めて，いかなる保証も行わない．また，本ソフトウェアの利用により直
  34  *  接的または間接的に生じたいかなる損害に関しても，その責任を負わない．
  35  *
  36  *  @(#) $Id: component.cpp,v 1.2 2012/06/17 00:24:19 suikan Exp $
  37  */
  38
  39 // $Header: /cvsroot/toppersjsp4bf/jsp/cfg/base/component.cpp,v 1.2 2012/06/17 00:24:19 suikan Exp $
  40
  41 #include "base/component.h"
  42
  43 #include <iostream>
  44
  45 using namespace std;
  46
  47     //コンポーネント全体が使用できるならtrue
  48 bool Component::is_valid = true;
  49
  50     //コンポーネントの登録
  51 bool Component::ComponentInfo::addComponent(Component * component, int order) throw()
  52 {
  53     bool result = false;
  54
  55     if(this != 0 && component != 0) {
  56         componentList.insert(multimap<int, Component *>::value_type(order, component));
  57         result = true;
  58     }
  59
  60     return result;
  61 }
  62
  63     //コンポーネントの登録解除
  64 void Component::ComponentInfo::removeComponent(Component * component, int order) throw()
  65 {
  66     if(this != 0 && component != 0) {
  67         multimap<int, Component *>::iterator scope;
  68
  69         scope = componentList.lower_bound(order);
  70         while(scope != componentList.end()) {
  71                 //もう指定された優先度はすべて見た
  72             if(scope->first != order)
  73                 break;
  74
  75                 //指定されたコンポーネントに一致したら削除
  76             if(scope->second == component) {
  77                 multimap<int, Component *>::iterator target = scope;
  78                 ++ scope;
  79                 componentList.erase(target);
  80             }
  81             else
  82                 ++ scope;
  83         }
  84     }
  85 }
  86
  87     //コンポーネントの登録解除
  88 void Component::ComponentInfo::removeComponent(Component * component) throw()
  89 {
  90     if(this != 0 && component != 0) {
  91         multimap<int, Component *>::iterator scope;
  92
  93             //指定されたコンポーネントに一致するものを全て削除
  94         scope = componentList.begin();
  95         while(scope != componentList.end()) {
  96             if(scope->second == component) {
  97                 multimap<int, Component *>::iterator target = scope;
  98                 ++ scope;
  99                 componentList.erase(target);
 100             }
 101             else
 102                 ++ scope;
 103         }
 104
 105     }
 106 }
 107
 108     //コンポーネントの起動要求の発行
 109 bool Component::ComponentInfo::activateComponent(Component * component) throw()
 110 {
 111     bool result = false;
 112
 113     if(this != 0 && component != 0) {
 114             //起動要求の末尾に加える
 115         activatedComponentList.push_back(component);
 116         result = true;
 117     }
 118
 119     return result;
 120 }
 121
 122     //オプションのパース
 123 void Component::ComponentInfo::parseOption(OptionParameter & option)
 124 {
 125     if(this != 0) {
 126         multimap<int, Component *>::iterator scope;
 127
 128             //全てのコンポーネントのparseOptionを実行
 129         scope = componentList.begin();
 130         while(scope != componentList.end()) {
 131             DebugMessage("Component::parseOption start  - %\n") << typeid(*scope->second).name();
 132             scope->second->parseOption(option);
 133             DebugMessage("Component::parseOption finish - %\n") << typeid(*scope->second).name();
 134             ++ scope;
 135         }
 136     }
 137 }
 138
 139     //コンポーネントの起動
 140 void Component::ComponentInfo::activateComponent(void)
 141 {
 142     if(this != 0) {
 143         list<Component *>::iterator scope;
 144
 145         try {
 146                 //起動要求のあった全てのコンポーネントを起動
 147             scope = activatedComponentList.begin();
 148             while(scope != activatedComponentList.end()) {
 149                 DebugMessage("Component::body start  - %\n") << typeid(**scope).name();
 150                 (*scope)->body();
 151                 DebugMessage("Component::body finish - %\n") << typeid(**scope).name();
 152                 ++ scope;
 153             }
 154                 //要求リストをクリア
 155             activatedComponentList.clear();
 156         }
 157         catch(...) {
 158                 //onFatalExit用に、activatedComponentListを起動をかけたコンポーネントだけに絞る
 159             ++ scope;
 160             if(scope != activatedComponentList.end())
 161                 activatedComponentList.erase(scope, activatedComponentList.end());
 162
 163             throw;
 164         }
 165     }
 166 }
 167
 168     //異常処理ハンドラの起動
 169 void Component::ComponentInfo::onFatalExit(void)
 170 {
 171     if(this != 0) {
 172         Component * handler;
 173
 174             //起動要求のあった全てのコンポーネントを起動
 175         while(!activatedComponentList.empty()) {
 176             handler = *activatedComponentList.begin();
 177             activatedComponentList.pop_front();
 178
 179                 //ハンドラを起動
 180             DebugMessage("Component::onFatalExit start  - %\n") << typeid(*handler).name();
 181             handler->onFatalExit();
 182             DebugMessage("Component::onFatalExit fihish - %\n") << typeid(*handler).name();
 183         }
 184             //要求リストをクリア
 185         activatedComponentList.clear();
 186     }
 187 }
 188
 189
 190 /*
 191  *   Component : コンポーネント
 192  */
 193
 194     //コンストラクタ
 195 Component::Component(int order) throw() : RuntimeObject()
 196 {
 197         //ここで初めてシングルトンインスタンスにアクセスするので、bad_allocが発生する可能性がある
 198     try {
 199         Singleton<ComponentInfo>::getInstance()->addComponent(this, order);
 200     }
 201     catch(bad_alloc) {
 202         is_valid = false;
 203     }
 204 }
 205
 206     //デストラクタ
 207 Component::~Component(void) throw()
 208 {   Singleton<ComponentInfo>::getInstance()->removeComponent(this);   }
 209
 210     //コンポーネントの実行
 211 void Component::executeComponents(int argc, char * argv [])
 212 {
 213     OptionParameter & option = getOptionParameter();
 214
 215     option.parseOption(argc, argv);
 216     executeComponents(option);
 217 }
 218
 219     //コンポーネントの実行
 220 void Component::executeComponents(OptionParameter & option)
 221 {
 222     if(isValid()) {
 223
 224         _parseCommonOption(option);
 225
 226         try {
 227                 //オプションのパース
 228             Singleton<ComponentInfo>::getInstance()->parseOption(option);
 229
 230                 //全てのオプションが使用済みでなければエラー
 231             if(!option.validateOption()) {
 232                 CHECKPOINT("Exception_UnknownOption");
 233                 ExceptionMessage("Unknown option [%] found.","不明なオプションが指定された : %") << option.getInvalidOptions() << throwException;
 234             }
 235             else {
 236                     //コンポーネントの実行
 237                 Singleton<ComponentInfo>::getInstance()->activateComponent();
 238             }
 239         }
 240
 241             //例外の発生 -> 異常終了ハンドラの起動
 242         catch(...) {
 243             bool continuation;
 244             do {
 245                 try {
 246                     continuation = true;
 247                     Singleton<ComponentInfo>::getInstance()->onFatalExit();
 248                     continuation = false;
 249                 }
 250                 catch(Exception & e) {
 251                     CHECKPOINT("Exception_onFatalExit");
 252                     cerr << Message("[Internal error] onFatalExit threw an exception! : ","[内部エラー] onFatalExit中の例外! : ") << e.getDetails() << '\n';
 253                 }
 254             } while(continuation);
 255
 256             throw;
 257         }
 258     }
 259 }
 260
 261
 262     //一般的なオプションの処理
 263 void Component::_parseCommonOption(OptionParameter & option) throw()
 264 {
 265         //デバッグ処理
 266     if(option.find("debug")) {
 267         DebugMessage::setStream(&cerr);
 268         DebugMessage::setVerbose(true);
 269     }
 270
 271         //言語選択
 272     if(option.find("lj") || option.find("-japanese"))
 273         Message::selectLanguage(Message::JAPANESE);
 274     if(option.find("le") || option.find("-english"))
 275         Message::selectLanguage(Message::ENGLISH);
 276
 277         //冗長メッセージ
 278     if(option.find("v") || option.find("-verbose")) {
 279         VerboseMessage::setStream(&cout);
 280         VerboseMessage::setVerbose(true);
 281     }
 282
 283         //バナー表示
 284     if((!getBanner().empty() && option.find("v")) || option.find("-verbose") || option.find("h") || option.find("-help"))
 285         cout << getBanner() << endl;
 286
 287         //ヘルプ表示
 288     if(option.find("h") || option.find("-help"))
 289         cout << '\n' << Message(
 290             "Global option\n"
 291             " -lj, --japanese : Use Japanese as default language\n"
 292             " -le, --english  : Use English as default language\n"
 293             " -v,  --verbose  : Verbose Message\n",
 294             "全体のオプション\n"
 295             " -lj, --japanese : 日本語で表示します\n"
 296             " -le, --english  : 英語で表示します\n"
 297             " -v,  --verbose  : 冗長メッセージを出力します\n");
 298 }
 299
 300     //バナーアクセサ
 301 void Component::setBanner(string src) throw(bad_alloc)
 302 {
 303     ComponentInfo * info = Singleton<ComponentInfo>::getInstance();
 304     info->setBanner(src);
 305 }
 306
 307 string Component::getBanner(void) throw(bad_alloc)
 308 {
 309     ComponentInfo * info = Singleton<ComponentInfo>::getInstance();
 310     return info->getBanner();
 311 }
 312
 313 /*
 314  *   過去との互換性のためのパラメータ操作API
 315  */
 316
 317     /* 指定されたオプションの存在を確認し、必要であればそのパラメータを取得する */
 318 bool Component::findOption(const char * key1, const char * key2, std::string * element) throw()
 319 {
 320     OptionParameter::OptionItem item;
 321
 322     item = getOption(key1, key2, true);
 323     if(item.isValid() && element != 0 && item.hasParameter())
 324         *element = item[0];
 325
 326     return item.isValid();
 327 }
 328
 329     /* 存在確認 + チェックをつける */
 330 bool Component::checkOption(const char * key1, const char * key2) throw()
 331 {   return getOption(key1, key2, true).isValid();   }
 332
 333     /* 指定された名前のオプションパラメータを取得 */
 334 OptionParameter::OptionItem Component::getOption(const char * key1, const char * key2, bool dirty) throw()
 335 {
 336     OptionParameter::OptionItem item;
 337
 338     if(key1 != 0)
 339         item = getOptionParameter().get(key1, dirty);
 340
 341     if(key2 != 0) {
 342         if(item.isValid())
 343             item.mergeItem(getOptionParameter().get(string("-") + key2, dirty));
 344         else
 345             item = getOptionParameter().get(string("-") + key2, dirty);
 346     }
 347
 348     return item;
 349 }
 350
 351     /* 2つのオプション項目をマージする (放っておいてもマージされるので気にしない) */
 352 OptionParameter::OptionItem Component::mergeOption(const char * key1, const char * key2) throw()
 353 {   return getOption(key1, key2);   }
 354
 355
 356
 357 /****************************************************** テストスィート ******************************************************/
 358
 359 #ifdef TESTSUITE
 360 #include "coverage_undefs.h"
 361
 362 namespace {
 363     int counter = 0;
 364
 365     class TestComponent : public Component
 366     {
 367     public:
 368         bool         check_parseOption;
 369         bool         check_body;
 370         bool         check_onFatalExit;
 371         bool         activation;
 372         bool         throw_parseOption;
 373         bool         throw_body;
 374         bool         throw_onFatalExit;
 375         int          actcnt;
 376
 377         TestComponent(int order = GENERAL_PURPOSE) : Component(order)
 378         {
 379             check_parseOption = false;
 380             check_body        = false;
 381             check_onFatalExit = false;
 382             activation        = false;
 383             throw_parseOption = false;
 384             throw_body        = false;
 385             throw_onFatalExit = false;
 386         }
 387
 388         void parseOption(OptionParameter & option) throw(Exception)
 389         {
 390             actcnt = ++counter;
 391             check_parseOption = true;
 392             if(activation)
 393                 activateComponent();
 394             if(throw_parseOption)
 395                 ExceptionMessage("exception","exception").throwException();
 396         }
 397
 398         void body(void) throw(Exception)
 399         {
 400             actcnt = ++counter;
 401             check_body = true;
 402             if(throw_body)
 403                 ExceptionMessage("exception","exception").throwException();
 404         }
 405
 406         void onFatalExit(void) throw(Exception)
 407         {
 408             actcnt = ++counter;
 409             check_onFatalExit = true;
 410             if(throw_onFatalExit)
 411                 ExceptionMessage("exception","exception").throwException();
 412         }
 413     };
 414
 415     class DerivedTestComponent : public TestComponent
 416     {};
 417 }
 418
 419
 420 TESTSUITE_(main,ComponentInfo,Component)
 421 {
 422     Singleton<ComponentInfo>::Context context;
 423     Singleton<ComponentInfo>::saveContext(context);
 424     Singleton<ComponentInfo>::renewInstance();
 425
 426     BEGIN_CASE("addComponent","addComponent") {
 427
 428         BEGIN_CASE("1","正しく追加できる") {
 429             ComponentInfo info;
 430
 431             BEGIN_CASE("1","関数は成功する") {
 432                 if(!info.addComponent((Component *)0x1234, 10))
 433                     TEST_FAIL;
 434             } END_CASE;
 435
 436             BEGIN_CASE("2","追加されている") {
 437                 if(info.componentList.size() != 1)
 438                     TEST_FAIL;
 439             } END_CASE;
 440
 441             BEGIN_CASE("3", "内容が正しい") {
 442                 if(info.componentList.begin()->first != 10 || info.componentList.begin()->second != (Component *)0x1234)
 443                     TEST_FAIL;
 444             } END_CASE;
 445         } END_CASE;
 446
 447         BEGIN_CASE("2","NULLインスタンスは登録できない") {
 448             ComponentInfo info;
 449
 450             BEGIN_CASE("1","関数は失敗する") {
 451                 if(info.addComponent(0, 10))
 452                     TEST_FAIL;
 453             } END_CASE;
 454
 455             BEGIN_CASE("2","要素は追加されていない") {
 456                 if(info.componentList.size() != 0)
 457                     TEST_FAIL;
 458             } END_CASE;
 459         } END_CASE;
 460
 461         BEGIN_CASE("3","NULLインスタンスに操作するとfalseが返る") {
 462             if(((ComponentInfo *)0)->addComponent((Component *)0x1234, 10))
 463                 TEST_FAIL;
 464         } END_CASE;
 465
 466     } END_CASE;
 467
 468     BEGIN_CASE("removeComponent(Component *, int)","removeComponent(Component *, int)") {
 469         BEGIN_CASE("1", "正しく解除できる") {
 470             ComponentInfo info;
 471
 472             info.addComponent((Component *)0x0123, 10); //38行目のifのelseを実行させるためのダミー
 473             info.addComponent((Component *)0x1234, 10);
 474             info.addComponent((Component *)0x1234, 20);
 475
 476             info.removeComponent((Component *)0x1234, 10);
 477             info.removeComponent((Component *)0x0123, 10);
 478
 479             BEGIN_CASE("1","要素数が1") {
 480                 if(info.componentList.size() != 1)
 481                     TEST_FAIL;
 482             } END_CASE;
 483
 484             BEGIN_CASE("2","残った要素のorderは20") {
 485                 if(info.componentList.begin()->first != 20)
 486                     TEST_FAIL;
 487             } END_CASE;
 488         } END_CASE;
 489
 490         BEGIN_CASE("2", "NULLオブジェクトから実行しても大丈夫") {
 491             ((ComponentInfo *)0)->removeComponent(0, 0);
 492         } END_CASE;
 493     } END_CASE;
 494
 495     BEGIN_CASE("removeComponent(Component *)","removeComponent(Component *)") {
 496         BEGIN_CASE("1", "正しく解除できる") {
 497             ComponentInfo info;
 498             multimap<int, Component *>::iterator scope;
 499
 500             info.addComponent((Component *)0x1234, 10);
 501             info.addComponent((Component *)0x1235, 10);
 502             info.addComponent((Component *)0x1234, 20);
 503             info.addComponent((Component *)0x1235, 20);
 504
 505             info.removeComponent((Component *)0x1234);
 506
 507             BEGIN_CASE("1","要素数が2") {
 508                 if(info.componentList.size() != 2)
 509                     TEST_FAIL;
 510             } END_CASE;
 511
 512             scope = info.componentList.begin();
 513             BEGIN_CASE("2","残った要素の内容は正しい") {
 514                 if(scope->first != 10 || scope->second != (Component *)0x1235)
 515                     TEST_FAIL;
 516                 ++ scope;
 517                 if(scope->first != 20 || scope->second != (Component *)0x1235)
 518                     TEST_FAIL;
 519             } END_CASE;
 520         } END_CASE;
 521
 522         BEGIN_CASE("2", "NULLオブジェクトから実行しても大丈夫") {
 523             ((ComponentInfo *)0)->removeComponent(0);
 524         } END_CASE;
 525     } END_CASE;
 526
 527     BEGIN_CASE("activateComponent","activateComponent") {
 528         BEGIN_CASE("1","正常に追加できる") {
 529             ComponentInfo info;
 530
 531             BEGIN_CASE("1","関数は成功する") {
 532                 if(!info.activateComponent((Component *)0x1234))
 533                     TEST_FAIL;
 534             } END_CASE;
 535
 536             BEGIN_CASE("2","起動要求リストに正しく追加されている") {
 537                 if(info.activatedComponentList.size() != 1)
 538                     TEST_FAIL;
 539                 if(*info.activatedComponentList.begin() != (Component *)0x1234)
 540                     TEST_FAIL;
 541             } END_CASE;
 542
 543             BEGIN_CASE("3","NULLオブジェクトから発行しても暴走しない") {
 544                 ((ComponentInfo *)0)->activateComponent();
 545             } END_CASE;
 546         } END_CASE;
 547
 548         BEGIN_CASE("1","NULLインスタンスは追加されない") {
 549             ComponentInfo info;
 550
 551             BEGIN_CASE("1","関数は失敗する") {
 552                 if(info.activateComponent((Component *)0))
 553                     TEST_FAIL;
 554             } END_CASE;
 555
 556             BEGIN_CASE("2","起動要求リストは空のまま") {
 557                 if(!info.activatedComponentList.empty())
 558                     TEST_FAIL;
 559             } END_CASE;
 560         } END_CASE;
 561     } END_CASE;
 562
 563     BEGIN_CASE("Component::Component","Component::Component") {
 564         Singleton<ComponentInfo>::renewInstance();
 565         TestComponent * test = 0;
 566
 567         BEGIN_CASE("0","前提条件を満たす") {
 568             if(Singleton<ComponentInfo>::getInstance()->componentList.size() != 0)
 569                 TEST_FAIL;
 570         } END_CASE;
 571
 572         BEGIN_CASE("1","Componentをインスタンス化すると、勝手に登録される") {
 573             test = new TestComponent;
 574             if(Singleton<ComponentInfo>::getInstance()->componentList.size() != 1)
 575                 TEST_FAIL;
 576         } END_CASE;
 577
 578         BEGIN_CASE("2","登録されている内容は正しい") {
 579             if(Singleton<ComponentInfo>::getInstance()->componentList.begin()->second != test)
 580                 TEST_FAIL;
 581         } END_CASE;
 582
 583         BEGIN_CASE("3","破棄するとエントリが消える") {
 584             delete test;
 585             if(Singleton<ComponentInfo>::getInstance()->componentList.size() != 0)
 586                 TEST_FAIL;
 587         } END_CASE;
 588     } END_CASE;
 589
 590     BEGIN_CASE("parseOption","parseOption") {
 591
 592         BEGIN_CASE("1","parseOptionを実行すると登録されたコンポーネントのparseOptionが実行される") {
 593             Singleton<ComponentInfo>::renewInstance();
 594
 595             TestComponent test;
 596             TestComponent test2;
 597
 598             Singleton<ComponentInfo>::getInstance()->parseOption(getOptionParameter());
 599
 600             if(!test.check_parseOption || !test2.check_parseOption)
 601                 TEST_FAIL;
 602         } END_CASE;
 603
 604         BEGIN_CASE("2","起動順序が正しい (同一レベルなら登録順)") {
 605             Singleton<ComponentInfo>::renewInstance();
 606
 607             TestComponent test;
 608             TestComponent test2;
 609
 610             counter = 0;
 611             Singleton<ComponentInfo>::getInstance()->parseOption(getOptionParameter());
 612
 613             if(test.actcnt != 1 || test2.actcnt != 2 )
 614                 TEST_FAIL;
 615         } END_CASE;
 616
 617         BEGIN_CASE("3","起動順序が正しい (優先度順)") {
 618             Singleton<ComponentInfo>::renewInstance();
 619
 620             TestComponent test(10);
 621             TestComponent test2(1);
 622
 623             counter = 0;
 624             Singleton<ComponentInfo>::getInstance()->parseOption(getOptionParameter());
 625
 626             if(test.actcnt != 2 || test2.actcnt != 1 )
 627                 TEST_FAIL;
 628         } END_CASE;
 629
 630         BEGIN_CASE("4","activateをかけるとactivateListに登録される") {
 631             Singleton<ComponentInfo>::renewInstance();
 632
 633             TestComponent test;
 634             TestComponent test2;
 635             list<Component *>::iterator scope;
 636
 637             test.activation = true;
 638             test2.activation = true;
 639             Singleton<ComponentInfo>::getInstance()->parseOption(getOptionParameter());
 640
 641             if(Singleton<ComponentInfo>::getInstance()->activatedComponentList.size() != 2)
 642                 TEST_FAIL;
 643             scope = Singleton<ComponentInfo>::getInstance()->activatedComponentList.begin();
 644             if(*scope != &test)
 645                 TEST_FAIL;
 646             ++ scope;
 647             if(*scope != &test2)
 648                 TEST_FAIL;
 649         } END_CASE;
 650
 651         BEGIN_CASE("5","例外は抜けてくる") {
 652             Singleton<ComponentInfo>::renewInstance();
 653
 654             TestComponent test;
 655             TestComponent test2;
 656             list<Component *>::iterator scope;
 657             bool result = false;
 658
 659             Exception::setThrowControl(true);
 660             test.throw_parseOption = true;
 661             try {
 662                 Singleton<ComponentInfo>::getInstance()->parseOption(getOptionParameter());
 663             }
 664             catch(...) {
 665                 result = true;
 666             }
 667
 668             if(!result)
 669                 TEST_FAIL;
 670         } END_CASE;
 671
 672         BEGIN_CASE("6","例外前に登録されたactivateは残る") {
 673             Singleton<ComponentInfo>::renewInstance();
 674
 675             TestComponent test;
 676             TestComponent test2;
 677             list<Component *>::iterator scope;
 678             bool result = false;
 679
 680             Exception::setThrowControl(true);
 681             test.activation = true;
 682             test2.throw_parseOption = true;
 683             try {
 684                 Singleton<ComponentInfo>::getInstance()->parseOption(getOptionParameter());
 685             }
 686             catch(...) {
 687                 result = true;
 688             }
 689
 690             if(!result)
 691                 TEST_FAIL;
 692
 693             if(Singleton<ComponentInfo>::getInstance()->activatedComponentList.size() != 1)
 694                 TEST_FAIL;
 695
 696             if(*Singleton<ComponentInfo>::getInstance()->activatedComponentList.begin() != &test)
 697                 TEST_FAIL;
 698         } END_CASE;
 699
 700         BEGIN_CASE("7","NULLインスタンスからのコールに耐える") {
 701             ((ComponentInfo *)0)->parseOption(getOptionParameter());
 702         } END_CASE;
 703     }END_CASE;
 704
 705     BEGIN_CASE("activateCompoent/Component::body","activateCompoent/Component::body") {
 706         BEGIN_CASE("1","activateComponentをすると、起動要求を出したコンポーネントが起動される") {
 707             Singleton<ComponentInfo>::renewInstance();
 708
 709             TestComponent test;
 710             TestComponent test2;
 711
 712             test.activation = true;
 713             test2.activation = true;
 714             Singleton<ComponentInfo>::getInstance()->parseOption(getOptionParameter());
 715             Singleton<ComponentInfo>::getInstance()->activateComponent();
 716
 717             if(!test.check_body || !test2.check_body)
 718                 TEST_FAIL;
 719         } END_CASE;
 720
 721         BEGIN_CASE("2","起動要求を出さないコンポーネントは起動されない") {
 722             Singleton<ComponentInfo>::renewInstance();
 723
 724             TestComponent test;
 725             TestComponent test2;
 726
 727             test.activation = false;
 728             test2.activation = true;
 729             Singleton<ComponentInfo>::getInstance()->parseOption(getOptionParameter());
 730             Singleton<ComponentInfo>::getInstance()->activateComponent();
 731
 732             if(test.check_body || !test2.check_body)
 733                 TEST_FAIL;
 734         } END_CASE;
 735
 736         BEGIN_CASE("3","起動順序が正しい (同一レベルなら登録順)") {
 737             Singleton<ComponentInfo>::renewInstance();
 738
 739             TestComponent test;
 740             TestComponent test2;
 741             counter = 0;
 742
 743             test.activation = test2.activation = true;
 744             Singleton<ComponentInfo>::getInstance()->parseOption(getOptionParameter());
 745             Singleton<ComponentInfo>::getInstance()->activateComponent();
 746
 747             if(test.actcnt != 3 || test2.actcnt != 4 )
 748                 TEST_FAIL;
 749         } END_CASE;
 750
 751         BEGIN_CASE("4","起動順序が正しい (優先度順)") {
 752             Singleton<ComponentInfo>::renewInstance();
 753
 754             TestComponent test(10);
 755             TestComponent test2(4);
 756             counter = 0;
 757
 758             test.activation = test2.activation = true;
 759             Singleton<ComponentInfo>::getInstance()->parseOption(getOptionParameter());
 760             Singleton<ComponentInfo>::getInstance()->activateComponent();
 761
 762             if(test.actcnt != 4 || test2.actcnt != 3 )
 763                 TEST_FAIL;
 764         } END_CASE;
 765
 766         BEGIN_CASE("5","例外は抜けてくる") {
 767             Singleton<ComponentInfo>::renewInstance();
 768
 769             TestComponent test;
 770             TestComponent test2;
 771             list<Component *>::iterator scope;
 772             bool result = false;
 773
 774             Exception::setThrowControl(true);
 775             test.activation = test2.activation = true;
 776             test.throw_body = true;
 777             Singleton<ComponentInfo>::getInstance()->parseOption(getOptionParameter());
 778             try {
 779                 Singleton<ComponentInfo>::getInstance()->activateComponent();
 780             }
 781             catch(...) {
 782                 result = true;
 783             }
 784
 785             if(!result)
 786                 TEST_FAIL;
 787         } END_CASE;
 788
 789         BEGIN_CASE("6","例外を起こしたら、それまでに起動したコンポーネントがactivatedComponentListに残る") {
 790             Singleton<ComponentInfo>::renewInstance();
 791
 792             TestComponent test;
 793             TestComponent test2;
 794             bool result = false;
 795
 796             Exception::setThrowControl(true);
 797             test.activation = test2.activation = true;
 798             test.throw_body = true;
 799             Singleton<ComponentInfo>::getInstance()->parseOption(getOptionParameter());
 800             try {
 801                 Singleton<ComponentInfo>::getInstance()->activateComponent();
 802             }
 803             catch(...) {
 804                 result = true;
 805             }
 806
 807             if(!result)
 808                 TEST_FAIL;
 809
 810             if(Singleton<ComponentInfo>::getInstance()->activatedComponentList.size() != 1)
 811                 TEST_FAIL;
 812
 813             if(*Singleton<ComponentInfo>::getInstance()->activatedComponentList.begin() != &test)
 814                 TEST_FAIL;
 815         } END_CASE;
 816
 817         BEGIN_CASE("8","例外を起こしたら、それまでに起動したコンポーネントがactivatedComponentListに残る(2個目)") {
 818             Singleton<ComponentInfo>::renewInstance();
 819
 820             TestComponent test;
 821             TestComponent test2;
 822             list<Component *>::iterator scope;
 823             bool result = false;
 824
 825             Exception::setThrowControl(true);
 826             test.activation = test2.activation = true;
 827             test2.throw_body = true;
 828             Singleton<ComponentInfo>::getInstance()->parseOption(getOptionParameter());
 829             try {
 830                 Singleton<ComponentInfo>::getInstance()->activateComponent();
 831             }
 832             catch(...) {
 833                 result = true;
 834             }
 835
 836             if(!result)
 837                 TEST_FAIL;
 838
 839             if(Singleton<ComponentInfo>::getInstance()->activatedComponentList.size() != 2)
 840                 TEST_FAIL;
 841             scope = Singleton<ComponentInfo>::getInstance()->activatedComponentList.begin();
 842             if(*scope != &test)
 843                 TEST_FAIL;
 844             ++ scope;
 845             if(*scope != &test2)
 846                 TEST_FAIL;
 847         } END_CASE;
 848     } END_CASE;
 849
 850     BEGIN_CASE("onFatalExit","onFatalExit") {
 851         BEGIN_CASE("1","OnFatalExitをすると起動要求リストにあるコンポーネントが呼ばれる") {
 852             Singleton<ComponentInfo>::renewInstance();
 853
 854             TestComponent test;
 855             TestComponent test2;
 856
 857             test.activation = test2.activation = true;
 858             test2.throw_body = true;
 859             Singleton<ComponentInfo>::getInstance()->parseOption(getOptionParameter());
 860             try{ Singleton<ComponentInfo>::getInstance()->activateComponent(); } catch(...) {}
 861             Singleton<ComponentInfo>::getInstance()->onFatalExit();
 862
 863             if(!test.check_onFatalExit || !test2.check_onFatalExit)
 864                 TEST_FAIL;
 865         } END_CASE;
 866
 867         BEGIN_CASE("2","起動要求を出さないコンポーネントは起動されない") {
 868             Singleton<ComponentInfo>::renewInstance();
 869
 870             TestComponent test;
 871             TestComponent test2;
 872
 873             test.activation = false;
 874             test2.activation = true;
 875             test2.throw_body = true;
 876             Singleton<ComponentInfo>::getInstance()->parseOption(getOptionParameter());
 877             try{ Singleton<ComponentInfo>::getInstance()->activateComponent(); } catch(...) {}
 878             Singleton<ComponentInfo>::getInstance()->onFatalExit();
 879
 880             if(test.check_onFatalExit || !test2.check_onFatalExit)
 881                 TEST_FAIL;
 882         } END_CASE;
 883
 884         BEGIN_CASE("4","起動順序が正しい (同一レベルなら登録順)") {
 885             Singleton<ComponentInfo>::renewInstance();
 886
 887             TestComponent test;
 888             TestComponent test2;
 889             counter = 0;
 890
 891             test2.throw_body = true;
 892             test.activation = test2.activation = true;
 893             Singleton<ComponentInfo>::getInstance()->parseOption(getOptionParameter());
 894             try{ Singleton<ComponentInfo>::getInstance()->activateComponent(); } catch(...) {}
 895             Singleton<ComponentInfo>::getInstance()->onFatalExit();
 896
 897             if(test.actcnt != 5 || test2.actcnt != 6 )
 898                 TEST_FAIL;
 899         } END_CASE;
 900
 901         BEGIN_CASE("5","起動順序が正しい (優先度順)") {
 902             Singleton<ComponentInfo>::renewInstance();
 903
 904             TestComponent test(10);
 905             TestComponent test2(4);
 906             counter = 0;
 907
 908             test.activation = test2.activation = true;
 909             test.throw_body = true;
 910             Singleton<ComponentInfo>::getInstance()->parseOption(getOptionParameter());
 911             try{ Singleton<ComponentInfo>::getInstance()->activateComponent(); } catch(...) {}
 912             Singleton<ComponentInfo>::getInstance()->onFatalExit();
 913
 914             if(test.actcnt != 6 || test2.actcnt != 5 )
 915                 TEST_FAIL;
 916         } END_CASE;
 917
 918         BEGIN_CASE("6","例外は抜けてくる") {
 919             Singleton<ComponentInfo>::renewInstance();
 920
 921             TestComponent test;
 922             TestComponent test2;
 923             list<Component *>::iterator scope;
 924             bool result = false;
 925
 926             Exception::setThrowControl(true);
 927             test.activation = test2.activation = true;
 928             test2.throw_body = true;
 929             test.throw_onFatalExit = true;
 930             Singleton<ComponentInfo>::getInstance()->parseOption(getOptionParameter());
 931             try{ Singleton<ComponentInfo>::getInstance()->activateComponent(); } catch(...) {}
 932             try {
 933                 Singleton<ComponentInfo>::getInstance()->onFatalExit();
 934             }
 935             catch(...) {
 936                 result = true;
 937             }
 938
 939             if(!result)
 940                 TEST_FAIL;
 941         } END_CASE;
 942
 943         BEGIN_CASE("7","例外が起きたとき、まだ実行されていないコンポーネントのハンドラ起動要求は残る") {
 944             Singleton<ComponentInfo>::renewInstance();
 945
 946             TestComponent test;
 947             TestComponent test2;
 948             list<Component *>::iterator scope;
 949             bool result = false;
 950
 951             Exception::setThrowControl(true);
 952             test.activation = test2.activation = true;
 953             test2.throw_body = true;
 954             test.throw_onFatalExit = true;
 955             Singleton<ComponentInfo>::getInstance()->parseOption(getOptionParameter());
 956             try{ Singleton<ComponentInfo>::getInstance()->activateComponent(); } catch(...) {}
 957             try{
 958                 Singleton<ComponentInfo>::getInstance()->onFatalExit();
 959             }
 960             catch(...) {
 961                 result = true;
 962             }
 963
 964             if(!result)
 965                 TEST_FAIL;
 966
 967             if(Singleton<ComponentInfo>::getInstance()->activatedComponentList.size() != 1)
 968                 TEST_FAIL;
 969
 970             if(*Singleton<ComponentInfo>::getInstance()->activatedComponentList.begin() != &test2)
 971                 TEST_FAIL;
 972
 973         } END_CASE;
 974
 975         BEGIN_CASE("8","NULLオブジェクトから発行しても大丈夫") {
 976             ((ComponentInfo *)0)->onFatalExit();
 977         } END_CASE;
 978
 979     } END_CASE;
 980
 981     BEGIN_CASE("isActive","isActive") {
 982         BEGIN_CASE("1","起動したコンポーネントを判定できる") {
 983             Singleton<ComponentInfo>::renewInstance();
 984
 985             TestComponent test;
 986             Singleton<ComponentInfo>::getInstance()->activateComponent(&test);
 987
 988             if(!Singleton<ComponentInfo>::getInstance()->isActive<TestComponent>())
 989                 TEST_FAIL;
 990         } END_CASE;
 991
 992         BEGIN_CASE("2","起動していないコンポーネントには反応しない") {
 993             Singleton<ComponentInfo>::renewInstance();
 994
 995             TestComponent test;
 996
 997             if(Singleton<ComponentInfo>::getInstance()->isActive<TestComponent>())
 998                 TEST_FAIL;
 999         } END_CASE;
1000
1001         BEGIN_CASE("3","派生したコンポーネントのインスタンスには反応する") {
1002             Singleton<ComponentInfo>::renewInstance();
1003
1004             DerivedTestComponent test;
1005             Singleton<ComponentInfo>::getInstance()->activateComponent(&test);
1006
1007             if(!Singleton<ComponentInfo>::getInstance()->isActive<TestComponent>())
1008                 TEST_FAIL;
1009         } END_CASE;
1010
1011         BEGIN_CASE("4","複数起動していても要求に合ったものを探せる") {   //isActiveのif(dynamic_cast<T *>(iterator->instance) != 0)のelse節を実行させるのが目的
1012             Singleton<ComponentInfo>::renewInstance();
1013
1014             TestComponent test;
1015             Singleton<ComponentInfo>::getInstance()->activateComponent(&test);
1016             DerivedTestComponent test2;
1017             Singleton<ComponentInfo>::getInstance()->activateComponent(&test2);
1018
1019             if(!Singleton<ComponentInfo>::getInstance()->isActive<DerivedTestComponent>())
1020                 TEST_FAIL;
1021         } END_CASE;
1022     } END_CASE;
1023
1024
1025     Singleton<ComponentInfo>::restoreContext(context);
1026 }
1027
1028 //--------
1029
1030
1031 TESTSUITE(main,Component)
1032 {
1033     SingletonBase::ContextChain chain;
1034
1035     chain.saveContext<ComponentInfo>();
1036     chain.saveContext<OptionParameter>();
1037     chain.saveContext<VerboseMessage::VerboseControl>();
1038     chain.saveContext<Message::MessageControl>();
1039     chain.saveContext<DebugMessage::DebugControl>();
1040
1041     BEGIN_CASE("executeComponent","executeComponent") {
1042         BEGIN_CASE("1","特に何もなけばparseOption/bodyが実行される") {
1043             chain.renewInstance();
1044
1045             bool result = true;
1046             TestComponent test;
1047             test.activation = true;
1048
1049             Exception::setThrowControl(true);
1050             try { executeComponents(getOptionParameter()); }
1051             catch(...) { result = false; }
1052
1053             BEGIN_CASE("1","例外は起こらない") {
1054                 if(!result)
1055                     TEST_FAIL;
1056             } END_CASE;
1057
1058             BEGIN_CASE("2","parseOption/bodyは実行される") {
1059                  if(!test.check_parseOption || !test.check_body || test.check_onFatalExit)
1060                      TEST_FAIL;
1061             } END_CASE;
1062         } END_CASE;
1063
1064         BEGIN_CASE("2","処理してないオプションがある") {
1065             TestSuite::clearCheckpoints();
1066             chain.renewInstance();
1067
1068             char * argv[] = { "test.exe", "-test" };
1069             bool result = false;
1070             TestComponent test;
1071             test.activation = true;
1072
1073             getOptionParameter().parseOption(2, argv);
1074             Exception::setThrowControl(true);
1075             try { executeComponents(getOptionParameter()); }
1076             catch(...) { result = true; }
1077
1078             BEGIN_CASE("1","例外が起こる") {
1079                 if(!result)
1080                     TEST_FAIL;
1081                 if(!TestSuite::isReached("Exception_UnknownOption"))
1082                     TEST_FAIL;
1083             } END_CASE;
1084
1085             BEGIN_CASE("2","parseOption/onFatalExitは実行されるがbodyは実行されない") {
1086                  if(!test.check_parseOption || test.check_body || !test.check_onFatalExit)
1087                      TEST_FAIL;
1088             } END_CASE;
1089         } END_CASE;
1090
1091         BEGIN_CASE("3","オプションパース中に例外 (activateなし)") {
1092             chain.renewInstance();
1093
1094             bool result = false;
1095             TestComponent test;
1096             test.throw_parseOption = true;
1097
1098             Exception::setThrowControl(true);
1099             try { executeComponents(getOptionParameter()); }
1100             catch(...) { result = true; }
1101
1102             BEGIN_CASE("1","例外が起こる") {
1103                 if(!result)
1104                     TEST_FAIL;
1105             } END_CASE;
1106
1107             BEGIN_CASE("2","parseOptionは実行されるがbody/onFatalExitは実行されない") {
1108                  if(!test.check_parseOption || test.check_body || test.check_onFatalExit)
1109                      TEST_FAIL;
1110             } END_CASE;
1111         } END_CASE;
1112
1113         BEGIN_CASE("4","オプションパース中に例外 (activateあり)") {
1114             chain.renewInstance();
1115
1116             bool result = false;
1117             TestComponent test;
1118             test.throw_parseOption = true;
1119             test.activation = true;
1120
1121             Exception::setThrowControl(true);
1122             try { executeComponents(getOptionParameter()); }
1123             catch(...) { result = true; }
1124
1125             BEGIN_CASE("1","例外が起こる") {
1126                 if(!result)
1127                     TEST_FAIL;
1128             } END_CASE;
1129
1130             BEGIN_CASE("2","parseOption/onFatalExitは実行されるがbodyは実行されない") {
1131                  if(!test.check_parseOption || test.check_body || !test.check_onFatalExit)
1132                      TEST_FAIL;
1133             } END_CASE;
1134         } END_CASE;
1135
1136         BEGIN_CASE("5","bodyで例外") {
1137             chain.renewInstance();
1138
1139             bool result = false;
1140             TestComponent test;
1141             test.throw_body = true;
1142             test.activation = true;
1143
1144             Exception::setThrowControl(true);
1145             try { executeComponents(getOptionParameter()); }
1146             catch(...) { result = true; }
1147
1148             BEGIN_CASE("1","例外が起こる") {
1149                 if(!result)
1150                     TEST_FAIL;
1151             } END_CASE;
1152
1153             BEGIN_CASE("2","parseOption/body/onFatalExitとも実行される") {
1154                  if(!test.check_parseOption || !test.check_body || !test.check_onFatalExit)
1155                      TEST_FAIL;
1156             } END_CASE;
1157         } END_CASE;
1158
1159
1160         BEGIN_CASE("6","onFatalExitで例外") {
1161             TestSuite::clearCheckpoints();
1162             chain.renewInstance();
1163
1164             bool result = false;
1165             TestComponent test;
1166             test.throw_onFatalExit = true;
1167             test.activation = true;
1168             TestComponent test2;
1169             test2.throw_body = true;
1170             test2.activation = true;
1171
1172             Exception::setThrowControl(true);
1173             try { executeComponents(getOptionParameter()); }
1174             catch(...) { result = true; }
1175
1176             BEGIN_CASE("1","例外が起こる") {
1177                 if(!result)
1178                     TEST_FAIL;
1179                 if(!TestSuite::isReached("Exception_onFatalExit"))
1180                     TEST_FAIL;
1181             } END_CASE;
1182
1183             BEGIN_CASE("2","最初のコンポーネントはparseOption/body/onFatalExitとも実行される") {
1184                  if(!test.check_parseOption || !test.check_body || !test.check_onFatalExit)
1185                      TEST_FAIL;
1186             } END_CASE;
1187             BEGIN_CASE("3","次のコンポーネントもparseOption/body/onFatalExitとも実行される") {
1188                  if(!test2.check_parseOption || !test2.check_body || !test2.check_onFatalExit)
1189                      TEST_FAIL;
1190             } END_CASE;
1191         } END_CASE;
1192
1193         BEGIN_CASE("7","Component::is_validがfalseのときは実行されない") {
1194             chain.renewInstance();
1195
1196             bool result = true;
1197             TestComponent test;
1198             test.activation = true;
1199
1200             Component::is_valid = false;
1201             Exception::setThrowControl(true);
1202             try { executeComponents(getOptionParameter()); }
1203             catch(...) { result = false; }
1204
1205             BEGIN_CASE("1","例外は起こらない") {
1206                 if(!result)
1207                     TEST_FAIL;
1208             } END_CASE;
1209
1210             BEGIN_CASE("2","parseOption/bodyは実行されない") {
1211                  if(test.check_parseOption || test.check_body || test.check_onFatalExit)
1212                      TEST_FAIL;
1213             } END_CASE;
1214
1215             Component::is_valid = true;
1216         } END_CASE;
1217     } END_CASE;
1218
1219     BEGIN_CASE("_parseCommonOption","_parseCommonOption") {
1220
1221         BEGIN_CASE("1", "-debugでDebugMessageが有効になる") {
1222             chain.renewInstance();
1223
1224             char * argv[] = { "test.exe", "-debug" };
1225             OptionParameter & param = getOptionParameter();
1226
1227             param.parseOption(2, argv);
1228             Component::_parseCommonOption(param);
1229
1230             if(!DebugMessage::getVerbose())
1231                 TEST_FAIL;
1232
1233         } END_CASE;
1234
1235         BEGIN_CASE("2", "-v でVerboseMessageが有効になる") {
1236             chain.renewInstance();
1237
1238             char * argv[] = { "test.exe", "-v" };
1239             OptionParameter & param = getOptionParameter();
1240
1241             param.parseOption(2, argv);
1242             Component::_parseCommonOption(param);
1243
1244             if(!VerboseMessage::getVerbose())
1245                 TEST_FAIL;
1246         } END_CASE;
1247
1248         BEGIN_CASE("3", "--verboseでVerboseMessageが有効になる") {
1249             chain.renewInstance();
1250
1251             char * argv[] = { "test.exe", "--verbose" };
1252             OptionParameter & param = getOptionParameter();
1253
1254             param.parseOption(2, argv);
1255             Component::_parseCommonOption(param);
1256
1257             if(!VerboseMessage::getVerbose())
1258                 TEST_FAIL;
1259         } END_CASE;
1260
1261         BEGIN_CASE("4", "-lj でMessageが日本語になる") {
1262             chain.renewInstance();
1263
1264             char * argv[] = { "test.exe", "-lj" };
1265             OptionParameter & param = getOptionParameter();
1266
1267             param.parseOption(2, argv);
1268             Component::_parseCommonOption(param);
1269
1270             if(Message::getCurrentLanguage() != Message::JAPANESE)
1271                 TEST_FAIL;
1272         } END_CASE;
1273
1274         BEGIN_CASE("5", "--japanese でMessageが日本語になる") {
1275             chain.renewInstance();
1276
1277             char * argv[] = { "test.exe", "--japanese" };
1278             OptionParameter & param = getOptionParameter();
1279
1280             param.parseOption(2, argv);
1281             Component::_parseCommonOption(param);
1282
1283             if(Message::getCurrentLanguage() != Message::JAPANESE)
1284                 TEST_FAIL;
1285         } END_CASE;
1286
1287         BEGIN_CASE("6", "-le でMessageが英語になる") {
1288             chain.renewInstance();
1289
1290             char * argv[] = { "test.exe", "-le" };
1291             OptionParameter & param = getOptionParameter();
1292
1293             param.parseOption(2, argv);
1294             Component::_parseCommonOption(param);
1295
1296             if(Message::getCurrentLanguage() != Message::ENGLISH)
1297                 TEST_FAIL;
1298         } END_CASE;
1299
1300         BEGIN_CASE("7", "--english でMessageが英語になる") {
1301             chain.renewInstance();
1302
1303             char * argv[] = { "test.exe", "--english" };
1304             OptionParameter & param = getOptionParameter();
1305
1306             param.parseOption(2, argv);
1307             Component::_parseCommonOption(param);
1308
1309             if(Message::getCurrentLanguage() != Message::ENGLISH)
1310                 TEST_FAIL;
1311         } END_CASE;
1312
1313         BEGIN_CASE("8","ヘルプがでる (-h)") {
1314             chain.renewInstance();
1315
1316             char * argv[] = { "test.exe", "-h" };
1317             OptionParameter & param = getOptionParameter();
1318
1319             param.parseOption(2, argv);
1320             cout.str("");
1321             Component::_parseCommonOption(param);
1322
1323                 //とりあえず何か出力されていることだけ確認しておく
1324             if(cout.str().empty())
1325                 TEST_FAIL;
1326         } END_CASE;
1327
1328         BEGIN_CASE("9","ヘルプがでる (--help)") {
1329             chain.renewInstance();
1330
1331             char * argv[] = { "test.exe", "--help" };
1332             OptionParameter & param = getOptionParameter();
1333
1334             param.parseOption(2, argv);
1335             cout.str("");
1336             Component::_parseCommonOption(param);
1337
1338                 //とりあえず何か出力されていることだけ確認しておく
1339             if(cout.str().empty())
1340                 TEST_FAIL;
1341         } END_CASE;
1342
1343     } END_CASE;
1344
1345     BEGIN_CASE("getOption","オプションパラメータの取得") {
1346         chain.renewInstance();
1347
1348         char * argv[] = { "test.exe","-test","param","-test2","param2", "--test","param3","--test2","param4" };
1349         getOptionParameter().parseOption(9, argv);
1350
1351         BEGIN_CASE("1","getOption(test)でparamが取れる") {
1352             OptionParameter::OptionItem item;
1353
1354             item = getOption("test");
1355             TEST_CASE("1","有効な値が返る", item.isValid());
1356             TEST_CASE("2","チェック済みである", item.isChecked());
1357             TEST_CASE("3","1つのパラメータをもつ", item.countParameter() == 1);
1358             TEST_CASE("4","パラメータの内容があっている", item[0].compare("param") == 0);
1359         } END_CASE;
1360
1361         BEGIN_CASE("2","getOption(test,test)で2つの連結が取れる") {
1362             OptionParameter::OptionItem item;
1363
1364             TEST_CASE("0","[前提] --testにチェックはついていない", !getOptionParameter().get("-test",false).isChecked());
1365
1366             item = getOption("test","test");
1367
1368             TEST_CASE("1","有効な値が返る", item.isValid());
1369             TEST_CASE("2","チェック済みである", item.isChecked());
1370             TEST_CASE("3","チェック済みである (test)", getOptionParameter().get("test",false).isChecked());
1371             TEST_CASE("4","チェック済みである (-test)", getOptionParameter().get("-test",false).isChecked());
1372             TEST_CASE("5","2つのパラメータを持つ", item.countParameter() == 2);
1373             TEST_CASE("6","1つめのパラメータの値は正しい", item[0].compare("param") == 0);
1374             TEST_CASE("7","2つめのパラメータの値は正しい", item[1].compare("param3") == 0);
1375         } END_CASE;
1376
1377         BEGIN_CASE("3","getOption(test,unknown)でtestのパラメータが取れる") {
1378             OptionParameter::OptionItem item;
1379
1380             item = getOption("test","unknown");
1381
1382             TEST_CASE("1","有効な値が返る", item.isValid());
1383             TEST_CASE("2","1つのパラメータを持つ", item.countParameter() == 1);
1384             TEST_CASE("3","パラメータの値は正しい", item[0].compare("param") == 0);
1385         } END_CASE;
1386
1387         BEGIN_CASE("4","getOption(unknown,test)で -testのパラメータが取れる") {
1388             OptionParameter::OptionItem item;
1389
1390             item = getOption("unknown","test");
1391
1392             TEST_CASE("1","有効な値が返る", item.isValid());
1393             TEST_CASE("2","1つのパラメータを持つ", item.countParameter() == 1);
1394             TEST_CASE("3","パラメータの値は正しい", item[0].compare("param3") == 0);
1395         } END_CASE;
1396
1397         BEGIN_CASE("5","getOption(unknown,unknown)で無効なアイテムが返る") {
1398             OptionParameter::OptionItem item;
1399
1400             item = getOption("unknown","unknown");
1401
1402             TEST_CASE("1","無効な値が返る", !item.isValid());
1403         } END_CASE;
1404
1405         BEGIN_CASE("6","getOption(test2,test2,false)でチェックがつかない") {
1406             OptionParameter::OptionItem item;
1407
1408             TEST_CASE("0","[前提] -test2にチェックはついていない", !getOptionParameter().get("test2",false).isChecked());
1409             TEST_CASE("0","[前提] --test2にチェックはついていない", !getOptionParameter().get("-test2",false).isChecked());
1410
1411             item = getOption("test2","test2",false);
1412
1413             TEST_CASE("1","有効な値が返る", item.isValid());
1414             TEST_CASE("2","チェック済みでない", !item.isChecked());
1415             TEST_CASE("3","チェック済みでない (test2)", !getOptionParameter().get("test2",false).isChecked());
1416             TEST_CASE("4","チェック済みでない (-test2)", !getOptionParameter().get("-test2",false).isChecked());
1417             TEST_CASE("5","2つのパラメータを持つ", item.countParameter() == 2);
1418             TEST_CASE("6","1つめのパラメータの値は正しい", item[0].compare("param2") == 0);
1419             TEST_CASE("7","2つめのパラメータの値は正しい", item[1].compare("param4") == 0);
1420         } END_CASE;
1421
1422     } END_CASE;
1423
1424     BEGIN_CASE("findOption","オプションパラメータの取得") {
1425         chain.renewInstance();
1426
1427         char * argv[] = { "test.exe","-test","param","--test","param3", "-noparam"};
1428         getOptionParameter().parseOption(6, argv);
1429
1430         BEGIN_CASE("1","findOption(test,test)でparamが取れる") {
1431             string result;
1432
1433             TEST_CASE("0","[前提] チェック済みではない (test)", !getOptionParameter().get("test",false).isChecked());
1434             TEST_CASE("0","[前提] チェック済みではない (-test)", !getOptionParameter().get("-test",false).isChecked());
1435             TEST_CASE("1","関数は成功する", findOption("test","test",&result));
1436             TEST_CASE("2","文字列にparamが返る", result.compare("param") == 0);
1437             TEST_CASE("3","チェック済み (test)", getOptionParameter().get("test",false).isChecked());
1438             TEST_CASE("3","チェック済み (-test)", getOptionParameter().get("-test",false).isChecked());
1439         } END_CASE;
1440
1441         BEGIN_CASE("2","findOption(test,unknown)でparamが取れる") {
1442             string result;
1443
1444             TEST_CASE("1","関数は成功する", findOption("test","unknown",&result));
1445             TEST_CASE("2","文字列にparamが返る", result.compare("param") == 0);
1446         } END_CASE;
1447
1448         BEGIN_CASE("3","findOption(unknown,test)でparam3が取れる") {
1449             string result;
1450
1451             TEST_CASE("1","関数は成功する", findOption("unknown","test",&result));
1452             TEST_CASE("2","文字列にparamが返る", result.compare("param3") == 0);
1453         } END_CASE;
1454
1455         BEGIN_CASE("4","findOption(unknown,unknown)で無効なアイテムが返る") {
1456             string result;
1457
1458             result.assign("dummy");
1459
1460             TEST_CASE("1","関数は失敗する", !findOption("unknown","unknown",&result));
1461             TEST_CASE("2","文字列は書き換わらない", result.compare("dummy") == 0);
1462         } END_CASE;
1463
1464         BEGIN_CASE("5","findOption(noparam,NULL,&result)") {
1465             string result;
1466             result.assign("dummy");
1467
1468             TEST_CASE("1","関数は成功する", findOption("noparam", 0, &result));
1469             TEST_CASE("2","文字列は置き換わらない", result.compare("dummy") == 0);
1470         } END_CASE;
1471     } END_CASE;
1472
1473     BEGIN_CASE("checkOption","オプションパラメータの存在確認 + チェック") {
1474         chain.renewInstance();
1475
1476         char * argv[] = { "test.exe","-test","param","--test","param3", "-test2", "--test3"};
1477         getOptionParameter().parseOption(7, argv);
1478
1479         BEGIN_CASE("1","checkOption(test,test)でparamが取れる") {
1480             string result;
1481
1482             TEST_CASE("0","[前提] チェック済みではない (test)", !getOptionParameter().get("test",false).isChecked());
1483             TEST_CASE("0","[前提] チェック済みではない (-test)", !getOptionParameter().get("-test",false).isChecked());
1484             TEST_CASE("1","関数は成功する", checkOption("test","test"));
1485             TEST_CASE("2","チェック済み (test)", getOptionParameter().get("test",false).isChecked());
1486             TEST_CASE("3","チェック済み (-test)", getOptionParameter().get("-test",false).isChecked());
1487         } END_CASE;
1488
1489         BEGIN_CASE("2","checkOption(test2,unknown)でparamが取れる") {
1490             string result;
1491
1492             TEST_CASE("0","[前提] チェック済みではない (test2)", !getOptionParameter().get("test2",false).isChecked());
1493             TEST_CASE("1","関数は成功する", checkOption("test2","unknown"));
1494             TEST_CASE("2","チェック済み (test2)", getOptionParameter().get("test2",false).isChecked());
1495         } END_CASE;
1496
1497         BEGIN_CASE("3","checkOption(unknown,test3)でparam3が取れる") {
1498             string result;
1499
1500             TEST_CASE("0","[前提] チェック済みではない (test3)", !getOptionParameter().get("-test3",false).isChecked());
1501             TEST_CASE("1","関数は成功する", checkOption("unknown","test3"));
1502             TEST_CASE("2","チェック済み (test3)", getOptionParameter().get("-test3",false).isChecked());
1503         } END_CASE;
1504
1505         BEGIN_CASE("4","checkOption(unknown,unknown)で無効なアイテムが返る") {
1506             string result;
1507
1508             result.assign("dummy");
1509
1510             TEST_CASE("1","関数は失敗する", !checkOption("unknown","unknown"));
1511         } END_CASE;
1512     } END_CASE;
1513
1514         /* mergeOptionのチェック項目は、getOptionとほぼ同じ */
1515     BEGIN_CASE("mergeOption","オプションパラメータの結合") {
1516         chain.renewInstance();
1517
1518         char * argv[] = { "test.exe","-test","param","-test2","param2", "--test","param3","--test2","param4" };
1519         getOptionParameter().parseOption(9, argv);
1520
1521         BEGIN_CASE("1","mergeOption(test)でparamが取れる") {
1522             OptionParameter::OptionItem item;
1523
1524             item = mergeOption("test");
1525             TEST_CASE("1","有効な値が返る", item.isValid());
1526             TEST_CASE("2","チェック済みである", item.isChecked());
1527             TEST_CASE("3","1つのパラメータをもつ", item.countParameter() == 1);
1528             TEST_CASE("4","パラメータの内容があっている", item[0].compare("param") == 0);
1529         } END_CASE;
1530
1531         BEGIN_CASE("2","mergeOption(test,test)で2つの連結が取れる") {
1532             OptionParameter::OptionItem item;
1533
1534             TEST_CASE("0","[前提] --testにチェックはついていない", !getOptionParameter().get("-test",false).isChecked());
1535
1536             item = mergeOption("test","test");
1537
1538             TEST_CASE("1","有効な値が返る", item.isValid());
1539             TEST_CASE("2","チェック済みである", item.isChecked());
1540             TEST_CASE("3","チェック済みである (test)", getOptionParameter().get("test",false).isChecked());
1541             TEST_CASE("4","チェック済みである (-test)", getOptionParameter().get("-test",false).isChecked());
1542             TEST_CASE("5","2つのパラメータを持つ", item.countParameter() == 2);
1543             TEST_CASE("6","1つめのパラメータの値は正しい", item[0].compare("param") == 0);
1544             TEST_CASE("7","2つめのパラメータの値は正しい", item[1].compare("param3") == 0);
1545         } END_CASE;
1546
1547         BEGIN_CASE("3","mergeOption(test,unknown)でtestのパラメータが取れる") {
1548             OptionParameter::OptionItem item;
1549
1550             item = mergeOption("test","unknown");
1551
1552             TEST_CASE("1","有効な値が返る", item.isValid());
1553             TEST_CASE("2","1つのパラメータを持つ", item.countParameter() == 1);
1554             TEST_CASE("3","パラメータの値は正しい", item[0].compare("param") == 0);
1555         } END_CASE;
1556
1557         BEGIN_CASE("4","mergeOption(unknown,test)で -testのパラメータが取れる") {
1558             OptionParameter::OptionItem item;
1559
1560             item = mergeOption("unknown","test");
1561
1562             TEST_CASE("1","有効な値が返る", item.isValid());
1563             TEST_CASE("2","1つのパラメータを持つ", item.countParameter() == 1);
1564             TEST_CASE("3","パラメータの値は正しい", item[0].compare("param3") == 0);
1565         } END_CASE;
1566
1567         BEGIN_CASE("5","mergeOption(unknown,unknown)で無効なアイテムが返る") {
1568             OptionParameter::OptionItem item;
1569
1570             item = mergeOption("unknown","unknown");
1571
1572             TEST_CASE("1","無効な値が返る", !item.isValid());
1573         } END_CASE;
1574
1575     } END_CASE;
1576
1577     chain.restoreContext();
1578 }
1579 #endif
1580
1581