l7vsd/unit_tests/l7vs_logger/logger_access_manager_test.cpp

   1
   2
   3 #include <iostream>
   4 //#include "../../../l7vsd/src/logger_impl.cpp"
   5 #include <boost/test/unit_test.hpp>
   6
   7 #include "./parameter_stub/parameter_impl.h"
   8 //#include "./parameter_stub/parameter_impl.cpp"
   9 #include "./parameter_stub/parameter.h"
  10 //#include "./parameter_stub/parameter.cpp"
  11
  12 #include "../../src/logger_impl.cpp"
  13 #include "../../src/logger.cpp"
  14
  15 #include <log4cxx/logmanager.h>
  16 #include <log4cxx/helpers/loglog.h>
  17 #include <log4cxx/rolling/rollingfileappender.h>
  18 #include <log4cxx/rolling/fixedwindowrollingpolicy.h>
  19 #include <log4cxx/rolling/sizebasedtriggeringpolicy.h>
  20 #include <log4cxx/rolling/timebasedrollingpolicy.h>
  21 #include <log4cxx/consoleappender.h>
  22 #include <log4cxx/appender.h>
  23 #include <log4cxx/logmanager.h>
  24 #include <log4cxx/patternlayout.h>
  25 #include <log4cxx/fileappender.h>
  26 #include <log4cxx/net/syslogappender.h>
  27 #include <log4cxx/hierarchy.h>
  28
  29 #include <dlfcn.h>
  30 #include <limits.h>
  31 #include "./strict_time_based_rolling_policy_stub.cpp"
  32 #include "./time_and_size_based_rolling_policy_stub.cpp"
  33 #include "./logger_implement_access_stub/logger_implement_access.h"
  34 #include "logger_enum.h"
  35 //#include "logger_access_manager.h"
  36 #include "../../src/logger_logrotate_utility.cpp"
  37
  38
  39 #include "../../src/logger_access_manager.cpp"
  40
  41
  42 #include <boost/test/included/unit_test.hpp>
  43
  44
  45 using namespace boost::unit_test_framework;
  46
  47 using namespace l7vs;
  48
  49 using namespace std;
  50
  51
  52 using namespace boost::unit_test_framework;
  53
  54 using namespace l7vs;
  55
  56 extern void* _start;    //開始位置
  57 extern void* _etext;    //終了位置
  58
  59 #define BUF_LEN (4096)
  60
  61 typedef std::map< LOG_CATEGORY_TAG, LOG_LEVEL_TAG>
  62                 category_level_map_type;
  63
  64
  65 int resetConfigurationCalled = 0;
  66
  67 int getRootLoggerCalled = 0;
  68 bool getRootLoggerReturnNull = false;
  69
  70 int patternLayoutCtorCalled = 0;
  71 void* patternLayoutCreated = 0;
  72 bool patternLayoutNewFail = false;
  73
  74 int fileAppenderCtorCalled = 0;
  75 void* fileAppenderCreated = 0;
  76 bool fileAppenderNewFail = false;
  77 std::string fileAppenderCtorArgFilename = "";
  78 log4cxx::LayoutPtr fileAppenderCtorArgLayout = 0;
  79 int fileAppenderSetFileCalled = 0;
  80 std::string fileAppenderSetFileArgFilename = "";
  81 bool fileAppenderSetFileArgAppend = false;
  82 bool fileAppenderSetFileArgBufferedIO = false;
  83 size_t fileAppenderSetFileArgBufferSize = 0;
  84 void* fileAppenderSetFileArgPool = 0;
  85 bool fileAppenderSetFileException = false;
  86
  87 int poolCtorCalled = 0;
  88 void* poolCreated = 0;
  89
  90 int syslogAppenderCtorCalled = 0;
  91 void* syslogAppenderCreated = 0;
  92 bool syslogAppenderNewFail = false;
  93 log4cxx::LayoutPtr syslogAppenderCtorArgLayout = 0;
  94 int syslogAppenderCtorArgFacility = 0;
  95
  96 int loggerAddAppenderCalled = 0;
  97 log4cxx::AppenderPtr loggerAddAppenderArg[2] = {0, 0};
  98
  99 int loggerForcedLogCalled = 0;
 100 log4cxx::LevelPtr loggerForcedLogArgLevel = 0;
 101 std::string loggerForcedLogArgMessage = "";
 102 char loggerForcedLogArgFile[256];
 103 int loggerForcedLogArgLine = 0;
 104 bool loggerForcedLogEnabled = true;
 105 bool loggerForcedLogException = false;
 106
 107 int loggerGetLoggerCalled = 0;
 108 std::string loggerGetLoggerArgName = "";
 109 bool loggerGetLoggerReturnNull = false;
 110
 111 int fixedWindowCtorCalled = 0;
 112 void* fixedWindowCreated = 0;
 113 bool fixedWindowNewFail = false;
 114
 115 int sizeBaseCtorCalled = 0;
 116 void* sizeBaseCreated = 0;
 117 bool sizeBaseNewFail = false;
 118
 119 int strictPolicyCtorCalled = 0;
 120 void* strictPolicyCreated = 0;
 121 bool strictPolicyNewFail = false;
 122
 123 int timeSizePolicyCtorCalled = 0;
 124 void* timeSizePolicyCreated = 0;
 125 bool timeSizePolicyNewFail = false;
 126
 127 int rollingAppenderCtorCalled = 0;
 128 void* rollingAppenderCreated = 0;
 129 bool rollingAppenderNewFail = false;
 130
 131 int loggerGetLevelCalled = 0;
 132 int loggerSetLevelCalled = 0;
 133
 134 int snmpChangeLevelCalled = 0;
 135 int snmpChangeLevelArgCat = 0;
 136 int snmpChangeLevelArgLevel = 0;
 137
 138 int snmpGetLevelCalled = 0;
 139 LOG_CATEGORY_TAG snmpGetLevelArgCat;
 140 LOG_LEVEL_TAG snmpGetLevelReturns;
 141
 142 int appenderSkeletonSetLayoutCalled = 0;
 143 void* appenderSkeletonSetLayoutArgLayout = 0;
 144
 145 int rollingAppenderSkeletonActivateOptionsCalled = 0;
 146
 147 int hierarchySetConfiguredCalled = 0;
 148
 149
 150 #define BUF_LEN (4096)
 151
 152     typedef std::map< std::string , logger_implement_access* >
 153                     logimp_access_map_type;
 154
 155     typedef std::map< std::string , std::string >
 156                     accesslog_rotate_default_map_type;
 157
 158     typedef std::map< std::string , std::string >::iterator
 159                     accesslog_rotate_default_map_type_iterator;
 160
 161     typedef std::map< std::string , std::string > accesslog_rotate_map_type;
 162
 163     typedef std::map< std::string , std::string >::iterator accesslog_rotate_map_type_iterator;
 164
 165 class logger_access_manager_test : public l7vs::logger_access_manager
 166 {
 167 public:
 168     logimp_access_map_type &get_logimp_access_map(){ return(logimp_access_map); }
 169
 170     appender_property &get_access_log_default_property(){ return(access_log_default_property); }
 171
 172     void get_access_log_default_property_init() {
 173         access_log_default_property.log_filename_key                = "";
 174         access_log_default_property.log_filename_value              = "";
 175         access_log_default_property.rotation_key                    = "";
 176         access_log_default_property.rotation_value                  = LOG_ROT_SIZE;
 177         access_log_default_property.max_backup_index_key            = "";
 178         access_log_default_property.max_backup_index_value          = 1;
 179         access_log_default_property.max_file_size_key               = "";
 180         access_log_default_property.max_file_size_value             = 1;
 181         access_log_default_property.rotation_timing_key             = "";
 182         access_log_default_property.rotation_timing_value           = LOG_TIM_YEAR;
 183         access_log_default_property.rotation_timing_value_key       = "";
 184         access_log_default_property.rotation_timing_value_value     = "";
 185     }
 186
 187     accesslog_rotate_default_map_type &get_access_log_default_data(){ return(access_log_default_data); }
 188
 189     bool get_rotate_default_load_flag(){ return( rotate_default_load_flag); }
 190
 191     void set_rotate_default_load_flag(bool in){ rotate_default_load_flag = in; }
 192
 193     std::string &call_get_rotate_default_verbose_displayed_contents(){ return(rotate_default_verbose_displayed_contents); }
 194
 195     void set_rotate_default_verbose_displayed_contents(std::string in){ rotate_default_verbose_displayed_contents = in; }
 196 /*
 197     logger_implement_access *find_logger_implement_access(
 198                                 const std::string &access_log_filename,
 199                                 std::map< std::string , std::string > rotatedata,
 200                                 l7vs::error_code& err)
 201     {
 202         return( logger_access_manager::getInstance().find_logger_implement_access(
 203                                 access_log_filename,
 204                                 rotatedata,
 205                                 err) );
 206     }
 207
 208     void erase_logger_implement_access(
 209                             const std::string &access_log_filename,
 210                             l7vs::error_code& err)
 211     {
 212         logger_access_manager::getInstance().erase_logger_implement_access(
 213                             access_log_filename,
 214                             err);
 215     }
 216
 217     void access_log_rotate_loadConf()
 218     {
 219         logger_access_manager::access_log_rotate_loadConf();
 220     }
 221
 222         static  logger_access_manager_test&     get_instance(){
 223                 static logger_access_manager_test       instance;
 224                 return instance;
 225         }
 226 */
 227     logger_access_manager_test() {}
 228     //~logger_access_manager_test() {}
 229
 230 };
 231
 232
 233
 234 void logger_access_manager_access_log_rotate_loadConf_test()
 235 {
 236
 237     BOOST_MESSAGE( "----- logger_access_manager_access_log_rotate_loadConf_test start -----" );
 238
 239     logger_access_manager_test implTest;
 240
 241     Parameter pm;
 242
 243
 244     std::cout << "access_log_rotate_loadConf normal case01 size" << std::endl;
 245     {
 246         accesslog_rotate_default_map_type rotatedata;
 247         l7vs::error_code vs_err;
 248
 249         std::string no_thorw_error_msg = "exception throw!!";
 250
 251         std::string       l7cf_file_path = "./test_cf_files/l7vs.cf";
 252
 253         std::string       l7vsd_accesslog_rotate_type_val = "size";
 254         //std::string       l7vsd_accesslog_rotate_type_val = "date";
 255         //std::string       l7vsd_accesslog_rotate_type_val = "datesize";
 256         std::string       l7vsd_accesslog_rotate_max_backup_index_val = "1";
 257         std::string       l7vsd_accesslog_rotate_max_filesize_val = "10M";
 258         //std::string       l7vsd_accesslog_rotate_rotation_timing_val = "year";
 259         //std::string       l7vsd_accesslog_rotation_timing_value_val = "05/05 01:31";
 260
 261
 262         pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_KEY, l7vsd_accesslog_rotate_type_val );
 263         pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_MAX_BACKUP_INDEX_KEY, l7vsd_accesslog_rotate_max_backup_index_val);
 264         pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_MAX_FILE_SIZE_KEY, l7vsd_accesslog_rotate_max_filesize_val);
 265
 266         try {
 267
 268             implTest.access_log_rotate_loadConf();
 269             // unit_test[1] エラーが発生していないこと
 270             std::cout << "access_log_rotate_loadConf succeed\n";
 271         }
 272         catch ( const std::logic_error& ex ) {
 273             BOOST_ERROR(no_thorw_error_msg);
 274         }
 275
 276         std::string result_msg = "--ac-rotate-type size --ac-rotate-max-backup-index 1 --ac-rotate-max-filesize 10M";
 277
 278         // unit_test[2] エラーが発生していないこと
 279         BOOST_CHECK( implTest.call_get_rotate_default_verbose_displayed_contents() == result_msg );
 280
 281         pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_KEY );
 282         pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_MAX_BACKUP_INDEX_KEY );
 283         pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_MAX_FILE_SIZE_KEY );
 284
 285 //        std::string result_msg = "--ac-rotate-type date --ac-rotate-max-backup-index 1 --ac-rotate-rotation-timing year --ac-rotate-rotation-timing-value 05/05 01:31";
 286 //        std::string result_msg = "--ac-rotate-type datesize --ac-rotate-max-backup-index 1 --ac-rotate-max-filesize 10M --ac-rotate-rotation-timing year --ac-rotate-rotation-timing-value 05/05 01:31";
 287
 288     }
 289
 290     std::cout << "access_log_rotate_loadConf normal case02 date" << std::endl;
 291     {
 292         accesslog_rotate_default_map_type rotatedata;
 293         l7vs::error_code vs_err;
 294
 295         std::string no_thorw_error_msg = "exception throw!!";
 296
 297         std::string       l7cf_file_path = "./test_cf_files/l7vs.cf";
 298
 299         //std::string       l7vsd_accesslog_rotate_type_val = "size";
 300         std::string       l7vsd_accesslog_rotate_type_val = "date";
 301         //std::string       l7vsd_accesslog_rotate_type_val = "datesize";
 302         std::string       l7vsd_accesslog_rotate_max_backup_index_val = "1";
 303         //std::string       l7vsd_accesslog_rotate_max_filesize_val = "10M";
 304         std::string       l7vsd_accesslog_rotate_rotation_timing_val = "year";
 305         std::string       l7vsd_accesslog_rotation_timing_value_val = "05/05 01:31";
 306
 307
 308         pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_KEY, l7vsd_accesslog_rotate_type_val );
 309         pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_MAX_BACKUP_INDEX_KEY, l7vsd_accesslog_rotate_max_backup_index_val);
 310         pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_TIMING_KEY, l7vsd_accesslog_rotate_rotation_timing_val);
 311         pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_TIMING_VALUE_KEY, l7vsd_accesslog_rotation_timing_value_val);
 312
 313
 314         try {
 315
 316             implTest.access_log_rotate_loadConf();
 317             // unit_test[3] エラーが発生していないこと
 318             std::cout << "access_log_rotate_loadConf succeed\n";
 319         }
 320         catch ( const std::logic_error& ex ) {
 321             BOOST_ERROR(no_thorw_error_msg);
 322         }
 323
 324 //        std::string result_msg = "--ac-rotate-type size --ac-rotate-max-backup-index 1 --ac-rotate-max-filesize 10M";
 325         std::string result_msg = "--ac-rotate-type date --ac-rotate-max-backup-index 1 --ac-rotate-rotation-timing year --ac-rotate-rotation-timing-value 05/05 01:31";
 326
 327         // unit_test[4] エラーが発生していないこと
 328         BOOST_CHECK( implTest.call_get_rotate_default_verbose_displayed_contents() == result_msg );
 329
 330         pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_KEY );
 331         pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_MAX_BACKUP_INDEX_KEY );
 332         pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_TIMING_KEY );
 333         pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_TIMING_VALUE_KEY );
 334
 335 //        std::string result_msg = "--ac-rotate-type datesize --ac-rotate-max-backup-index 1 --ac-rotate-max-filesize 10M --ac-rotate-rotation-timing year --ac-rotate-rotation-timing-value 05/05 01:31";
 336
 337     }
 338
 339     std::cout << "access_log_rotate_loadConf normal case03 datesize" << std::endl;
 340     {
 341         accesslog_rotate_default_map_type rotatedata;
 342         l7vs::error_code vs_err;
 343
 344         std::string no_thorw_error_msg = "exception throw!!";
 345
 346         std::string       l7cf_file_path = "./test_cf_files/l7vs.cf";
 347
 348         //std::string       l7vsd_accesslog_rotate_type_val = "size";
 349         //std::string       l7vsd_accesslog_rotate_type_val = "date";
 350         std::string       l7vsd_accesslog_rotate_type_val = "datesize";
 351         std::string       l7vsd_accesslog_rotate_max_backup_index_val = "1";
 352         std::string       l7vsd_accesslog_rotate_max_filesize_val = "10M";
 353         std::string       l7vsd_accesslog_rotate_rotation_timing_val = "year";
 354         std::string       l7vsd_accesslog_rotation_timing_value_val = "05/05 01:31";
 355
 356
 357         pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_KEY, l7vsd_accesslog_rotate_type_val );
 358         pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_MAX_BACKUP_INDEX_KEY, l7vsd_accesslog_rotate_max_backup_index_val);
 359         pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_MAX_FILE_SIZE_KEY, l7vsd_accesslog_rotate_max_filesize_val);
 360         pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_TIMING_KEY, l7vsd_accesslog_rotate_rotation_timing_val);
 361         pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_TIMING_VALUE_KEY, l7vsd_accesslog_rotation_timing_value_val);
 362
 363
 364         try {
 365
 366             implTest.access_log_rotate_loadConf();
 367             // unit_test[5] エラーが発生していないこと
 368             std::cout << "access_log_rotate_loadConf succeed\n";
 369         }
 370         catch ( const std::logic_error& ex ) {
 371             BOOST_ERROR(no_thorw_error_msg);
 372         }
 373
 374 //        std::string result_msg = "--ac-rotate-type size --ac-rotate-max-backup-index 1 --ac-rotate-max-filesize 10M";
 375         std::string result_msg = "--ac-rotate-type datesize --ac-rotate-max-backup-index 1 --ac-rotate-max-filesize 10M --ac-rotate-rotation-timing year --ac-rotate-rotation-timing-value 05/05 01:31";
 376
 377         // unit_test[6] エラーが発生していないこと
 378         BOOST_CHECK( implTest.call_get_rotate_default_verbose_displayed_contents() == result_msg );
 379
 380         pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_KEY );
 381         pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_MAX_BACKUP_INDEX_KEY );
 382         pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_MAX_FILE_SIZE_KEY );
 383         pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_TIMING_KEY );
 384         pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_TIMING_VALUE_KEY );
 385
 386 //        std::string result_msg = "--ac-rotate-type date --ac-rotate-max-backup-index 1 --ac-rotate-rotation-timing year --ac-rotate-rotation-timing-value 05/05 01:31";
 387
 388     }
 389
 390     std::cout << "access_log_rotate_loadConf err case01 rotate_type not set" << std::endl;
 391     {
 392         accesslog_rotate_default_map_type rotatedata;
 393         l7vs::error_code vs_err;
 394
 395         std::string no_thorw_error_msg = "exception throw!!";
 396
 397         std::string       l7cf_file_path = "./test_cf_files/l7vs.cf";
 398
 399         //std::string       l7vsd_accesslog_rotate_type_val = "size";
 400         //std::string       l7vsd_accesslog_rotate_type_val = "date";
 401         //std::string       l7vsd_accesslog_rotate_type_val = "datesize";
 402         std::string       l7vsd_accesslog_rotate_max_backup_index_val = "1";
 403         std::string       l7vsd_accesslog_rotate_max_filesize_val = "10M";
 404         //std::string       l7vsd_accesslog_rotate_rotation_timing_val = "year";
 405         //std::string       l7vsd_accesslog_rotation_timing_value_val = "05/05 01:31";
 406
 407
 408         //pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_KEY, l7vsd_accesslog_rotate_type_val );
 409         pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_MAX_BACKUP_INDEX_KEY, l7vsd_accesslog_rotate_max_backup_index_val);
 410         pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_MAX_FILE_SIZE_KEY, l7vsd_accesslog_rotate_max_filesize_val);
 411         //pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_TIMING_KEY, l7vsd_accesslog_rotate_rotation_timing_val);
 412         //pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_TIMING_VALUE_KEY, l7vsd_accesslog_rotation_timing_value_val);
 413
 414
 415         try {
 416
 417             implTest.access_log_rotate_loadConf();
 418             BOOST_ERROR(no_thorw_error_msg);
 419         }
 420         catch ( const std::logic_error& ex ) {
 421             // unit_test[7] エラーが発生していること
 422             BOOST_CHECK_EQUAL(ex.what(), "Not Exist Log Rotation Setting.");
 423         }
 424
 425         //pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_KEY );
 426         pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_MAX_BACKUP_INDEX_KEY );
 427         pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_MAX_FILE_SIZE_KEY );
 428         //pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_TIMING_KEY );
 429         //pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_TIMING_VALUE_KEY );
 430
 431     }
 432
 433     std::cout << "access_log_rotate_loadConf err case02 max_backup_index not set" << std::endl;
 434     {
 435         accesslog_rotate_default_map_type rotatedata;
 436         l7vs::error_code vs_err;
 437
 438         std::string no_thorw_error_msg = "exception throw!!";
 439
 440         std::string       l7cf_file_path = "./test_cf_files/l7vs.cf";
 441
 442         std::string       l7vsd_accesslog_rotate_type_val = "size";
 443         //std::string       l7vsd_accesslog_rotate_type_val = "date";
 444         //std::string       l7vsd_accesslog_rotate_type_val = "datesize";
 445         //std::string       l7vsd_accesslog_rotate_max_backup_index_val = "1";
 446         std::string       l7vsd_accesslog_rotate_max_filesize_val = "10M";
 447         //std::string       l7vsd_accesslog_rotate_rotation_timing_val = "year";
 448         //std::string       l7vsd_accesslog_rotation_timing_value_val = "05/05 01:31";
 449
 450
 451
 452         pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_KEY, l7vsd_accesslog_rotate_type_val );
 453         //pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_MAX_BACKUP_INDEX_KEY, l7vsd_accesslog_rotate_max_backup_index_val);
 454         pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_MAX_FILE_SIZE_KEY, l7vsd_accesslog_rotate_max_filesize_val);
 455         //pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_TIMING_KEY, l7vsd_accesslog_rotate_rotation_timing_val);
 456         //pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_TIMING_VALUE_KEY, l7vsd_accesslog_rotation_timing_value_val);
 457
 458         try {
 459
 460             implTest.access_log_rotate_loadConf();
 461             BOOST_ERROR(no_thorw_error_msg);
 462         }
 463         catch ( const std::logic_error& ex ) {
 464             // unit_test[8] エラーが発生していること
 465             BOOST_CHECK_EQUAL(ex.what(), "Not Exist Log MaxBackupIndex Setting.");
 466         }
 467
 468         pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_KEY );
 469         //pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_MAX_BACKUP_INDEX_KEY );
 470         pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_MAX_FILE_SIZE_KEY );
 471         //pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_TIMING_KEY );
 472         //pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_TIMING_VALUE_KEY );
 473
 474     }
 475
 476     std::cout << "access_log_rotate_loadConf err case03 max_filesize not set" << std::endl;
 477     {
 478         accesslog_rotate_default_map_type rotatedata;
 479         l7vs::error_code vs_err;
 480
 481         std::string no_thorw_error_msg = "exception throw!!";
 482
 483         std::string       l7cf_file_path = "./test_cf_files/l7vs.cf";
 484
 485         std::string       l7vsd_accesslog_rotate_type_val = "size";
 486         //std::string       l7vsd_accesslog_rotate_type_val = "date";
 487         //std::string       l7vsd_accesslog_rotate_type_val = "datesize";
 488         std::string       l7vsd_accesslog_rotate_max_backup_index_val = "1";
 489         //std::string       l7vsd_accesslog_rotate_max_filesize_val = "10M";
 490         //std::string       l7vsd_accesslog_rotate_rotation_timing_val = "year";
 491         //std::string       l7vsd_accesslog_rotation_timing_value_val = "05/05 01:31";
 492
 493
 494         pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_KEY, l7vsd_accesslog_rotate_type_val );
 495         pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_MAX_BACKUP_INDEX_KEY, l7vsd_accesslog_rotate_max_backup_index_val);
 496         //pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_MAX_FILE_SIZE_KEY, l7vsd_accesslog_rotate_max_filesize_val);
 497         //pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_TIMING_KEY, l7vsd_accesslog_rotate_rotation_timing_val);
 498         //pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_TIMING_VALUE_KEY, l7vsd_accesslog_rotation_timing_value_val);
 499
 500         try {
 501
 502             implTest.access_log_rotate_loadConf();
 503             BOOST_ERROR(no_thorw_error_msg);
 504         }
 505         catch ( const std::logic_error& ex ) {
 506             // unit_test[9] エラーが発生していること
 507             BOOST_CHECK_EQUAL(ex.what(), "Not Exist Log MaxFileSize Setting.");
 508         }
 509
 510         pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_KEY );
 511         pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_MAX_BACKUP_INDEX_KEY );
 512         //pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_MAX_FILE_SIZE_KEY );
 513         //pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_TIMING_KEY );
 514         //pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_TIMING_VALUE_KEY );
 515
 516     }
 517
 518
 519     std::cout << "access_log_rotate_loadConf err case04 rotation_timing not set" << std::endl;
 520     {
 521         accesslog_rotate_default_map_type rotatedata;
 522         l7vs::error_code vs_err;
 523
 524         std::string no_thorw_error_msg = "exception throw!!";
 525
 526         std::string       l7cf_file_path = "./test_cf_files/l7vs.cf";
 527
 528         //std::string       l7vsd_accesslog_rotate_type_val = "size";
 529         //std::string       l7vsd_accesslog_rotate_type_val = "date";
 530         std::string       l7vsd_accesslog_rotate_type_val = "datesize";
 531         std::string       l7vsd_accesslog_rotate_max_backup_index_val = "1";
 532         std::string       l7vsd_accesslog_rotate_max_filesize_val = "10M";
 533         //std::string       l7vsd_accesslog_rotate_rotation_timing_val = "year";
 534         std::string       l7vsd_accesslog_rotation_timing_value_val = "05/05 01:31";
 535
 536
 537         pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_KEY, l7vsd_accesslog_rotate_type_val );
 538         pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_MAX_BACKUP_INDEX_KEY, l7vsd_accesslog_rotate_max_backup_index_val);
 539         pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_MAX_FILE_SIZE_KEY, l7vsd_accesslog_rotate_max_filesize_val);
 540         //pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_TIMING_KEY, l7vsd_accesslog_rotate_rotation_timing_val);
 541         pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_TIMING_VALUE_KEY, l7vsd_accesslog_rotation_timing_value_val);
 542
 543
 544         try {
 545
 546             implTest.access_log_rotate_loadConf();
 547             BOOST_ERROR(no_thorw_error_msg);
 548         }
 549         catch ( const std::logic_error& ex ) {
 550             // unit_test[10] エラーが発生していること
 551             BOOST_CHECK_EQUAL(ex.what(), "Not Exist Log RotaionTiming Setting.");
 552         }
 553
 554         pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_KEY );
 555         pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_MAX_BACKUP_INDEX_KEY );
 556         pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_MAX_FILE_SIZE_KEY );
 557         //pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_TIMING_KEY );
 558         pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_TIMING_VALUE_KEY );
 559
 560     }
 561
 562     std::cout << "access_log_rotate_loadConf err case05 rotation_timing_val not set" << std::endl;
 563     {
 564         accesslog_rotate_default_map_type rotatedata;
 565         l7vs::error_code vs_err;
 566
 567         std::string no_thorw_error_msg = "exception throw!!";
 568
 569         std::string       l7cf_file_path = "./test_cf_files/l7vs.cf";
 570
 571         //std::string       l7vsd_accesslog_rotate_type_val = "size";
 572         //std::string       l7vsd_accesslog_rotate_type_val = "date";
 573         std::string       l7vsd_accesslog_rotate_type_val = "datesize";
 574         std::string       l7vsd_accesslog_rotate_max_backup_index_val = "1";
 575         std::string       l7vsd_accesslog_rotate_max_filesize_val = "10M";
 576         std::string       l7vsd_accesslog_rotate_rotation_timing_val = "year";
 577         //std::string       l7vsd_accesslog_rotation_timing_value_val = "05/05 01:31";
 578
 579
 580         pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_KEY, l7vsd_accesslog_rotate_type_val );
 581         pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_MAX_BACKUP_INDEX_KEY, l7vsd_accesslog_rotate_max_backup_index_val);
 582         pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_MAX_FILE_SIZE_KEY, l7vsd_accesslog_rotate_max_filesize_val);
 583         pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_TIMING_KEY, l7vsd_accesslog_rotate_rotation_timing_val);
 584         //pm.setStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_TIMING_VALUE_KEY, l7vsd_accesslog_rotation_timing_value_val);
 585
 586
 587         try {
 588
 589             implTest.access_log_rotate_loadConf();
 590             BOOST_ERROR(no_thorw_error_msg);
 591         }
 592         catch ( const std::logic_error& ex ) {
 593             // unit_test[11] エラーが発生していること
 594             std::string ex_msg = "Not Exist Log RotaionTiming " + l7vsd_accesslog_rotate_rotation_timing_val + " Setting.";
 595             BOOST_CHECK_EQUAL(ex.what(), ex_msg);
 596         }
 597
 598         pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_KEY );
 599         pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_MAX_BACKUP_INDEX_KEY );
 600         pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_MAX_FILE_SIZE_KEY );
 601         pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_TIMING_KEY );
 602         //pm.deleteStringValue(PARAM_COMP_LOGGER, ACCESS_LOG_ROTATION_TIMING_VALUE_KEY );
 603
 604     }
 605
 606
 607     BOOST_MESSAGE( "----- logger_access_manager_access_log_rotate_loadConf_test end -----" );
 608 }
 609
 610
 611
 612 void logger_access_manager_getInstance_constructor_test()
 613 {
 614
 615     BOOST_MESSAGE( "----- logger_access_manager_getInstance_constructor_test start -----" );
 616
 617     logger_access_manager_test implTest;
 618
 619     // unit_test[1] コンストラクタでメンバ変数が初期化されているか。
 620     BOOST_CHECK_EQUAL(implTest.get_rotate_default_load_flag(), false);
 621     // unit_test[2] コンストラクタでメンバ変数が初期化されているか。
 622     BOOST_CHECK_EQUAL(implTest.call_get_rotate_default_verbose_displayed_contents(), "");
 623     // unit_test[3] コンストラクタでメンバ変数が初期化されているか。
 624     BOOST_CHECK(implTest.get_access_log_default_data().size() == 0);
 625     // unit_test[4] コンストラクタでメンバ変数が初期化されているか。
 626     BOOST_CHECK(implTest.get_logimp_access_map().size() == 0);
 627
 628     BOOST_MESSAGE( "----- logger_access_manager_getInstance_constructor_test end -----" );
 629 }
 630
 631
 632 void logger_access_manager_find_and_erase_logger_implement_access_test()
 633 {
 634
 635     BOOST_MESSAGE( "----- logger_access_manager_find_and_erase_logger_implement_access_test start -----" );
 636
 637     logger_access_manager_test implTest;
 638
 639     l7vs::logger_implement_access::rtn_init_flag = true;
 640
 641     l7vs::logger_implement_access::rtn_checkRotateParameterComp_flag = true;
 642
 643     l7vs::logger_implement_access::rtn_setAcLoggerConf_flag = true;
 644
 645     std::cout << "find_logger_implement_access normal case01 size" << std::endl;
 646     {
 647         std::string aclogFilename = "aclog1";
 648         accesslog_rotate_default_map_type rotatedata;
 649         l7vs::error_code vs_err;
 650
 651         rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_TYPE , "size" ) );
 652         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_TYPE , "date" ) );
 653         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_TYPE , "datesize" ) );
 654         rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_MAX_BACKUP_INDEX , "1" ) );
 655
 656         rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_MAX_FILESIZE , "10M" ) );
 657
 658         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "year" ) );
 659         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "month" ) );
 660         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "week" ) );
 661         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "date" ) );
 662         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "hour" ) );
 663
 664         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "5/10 11:11" ) );
 665         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "11 5:5" ) );
 666
 667         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "sun 10:10" ) );
 668         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "mon 10:10" ) );
 669         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "tue 10:10" ) );
 670         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "wed 10:10" ) );
 671         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "thu 10:10" ) );
 672         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "fri 10:10" ) );
 673         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "sat 10:10" ) );
 674
 675         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "12:21" ) );
 676         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "55" ) );
 677
 678         l7vs::logger_implement_access::rtn_init_flag = true;
 679
 680         logger_implement_access *acinstance = implTest.find_logger_implement_access(aclogFilename,rotatedata,vs_err);
 681
 682         // unit_test[1] エラーが発生していないこと
 683         BOOST_CHECK( vs_err == false );
 684         // unit_test[2] ファイルがマップに登録されていること
 685         BOOST_CHECK( implTest.get_logimp_access_map().find(aclogFilename) != implTest.get_logimp_access_map().end() );
 686         // unit_test[3] アクセスログのインスタンスが生成されていること
 687         BOOST_CHECK( acinstance != NULL );
 688
 689         vs_err.setter( false , "" );
 690         implTest.erase_logger_implement_access(aclogFilename,vs_err);
 691
 692         // unit_test[4] エラーが発生していないこと
 693         BOOST_CHECK( vs_err == false );
 694         // unit_test[5] ファイルがマップに登録されていないこと
 695         BOOST_CHECK( implTest.get_logimp_access_map().find(aclogFilename) == implTest.get_logimp_access_map().end() );
 696
 697     }
 698
 699     std::cout << "find_logger_implement_access normal case02 size 0" << std::endl;
 700     {
 701         std::string aclogFilename = "aclog2";
 702         accesslog_rotate_default_map_type rotatedata;
 703         l7vs::error_code vs_err;
 704
 705         rotatedata.clear();
 706
 707         l7vs::logger_implement_access::rtn_init_flag = true;
 708
 709         logger_implement_access *acinstance = implTest.find_logger_implement_access(aclogFilename,rotatedata,vs_err);
 710
 711         // unit_test[6] エラーが発生していないこと
 712         BOOST_CHECK( vs_err == false );
 713         // unit_test[7] ファイルがマップに登録されていること
 714         BOOST_CHECK( implTest.get_logimp_access_map().find(aclogFilename) != implTest.get_logimp_access_map().end() );
 715         // unit_test[8] アクセスログのインスタンスが生成されていること
 716         BOOST_CHECK( acinstance != NULL );
 717
 718         vs_err.setter( false , "" );
 719         implTest.erase_logger_implement_access(aclogFilename,vs_err);
 720
 721         // unit_test[9] エラーが発生していないこと
 722         BOOST_CHECK( vs_err == false );
 723         // unit_test[10] ファイルがマップに登録されていないこと
 724         BOOST_CHECK( implTest.get_logimp_access_map().find(aclogFilename) == implTest.get_logimp_access_map().end() );
 725
 726     }
 727
 728
 729     std::cout << "find_logger_implement_access vs_err case01 init err" << std::endl;
 730     {
 731         std::string aclogFilename = "aclog3";
 732         accesslog_rotate_default_map_type rotatedata;
 733         l7vs::error_code vs_err;
 734
 735         rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_TYPE , "size" ) );
 736         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_TYPE , "date" ) );
 737         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_TYPE , "datesize" ) );
 738         rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_MAX_BACKUP_INDEX , "1" ) );
 739
 740         rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_MAX_FILESIZE , "10M" ) );
 741
 742         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "year" ) );
 743         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "month" ) );
 744         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "week" ) );
 745         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "date" ) );
 746         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "hour" ) );
 747
 748         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "5/10 11:11" ) );
 749         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "11 5:5" ) );
 750
 751         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "sun 10:10" ) );
 752         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "mon 10:10" ) );
 753         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "tue 10:10" ) );
 754         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "wed 10:10" ) );
 755         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "thu 10:10" ) );
 756         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "fri 10:10" ) );
 757         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "sat 10:10" ) );
 758
 759         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "12:21" ) );
 760         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "55" ) );
 761
 762         l7vs::logger_implement_access::rtn_init_flag = false;
 763
 764
 765         logger_implement_access *acinstance = implTest.find_logger_implement_access(aclogFilename,rotatedata,vs_err);
 766
 767         // unit_test[11] エラーが発生していること
 768         BOOST_CHECK( vs_err == true );
 769         // unit_test[12] エラーメッセージが格納されていること
 770         BOOST_CHECK( vs_err.get_message() == "logger_implement_access initialize err." );
 771         // unit_test[13] アクセスログのインスタンスが生成されていないこと
 772         BOOST_CHECK( acinstance == NULL );
 773
 774         l7vs::logger_implement_access::rtn_init_flag = false;
 775
 776         vs_err.setter( false , "" );
 777         implTest.erase_logger_implement_access(aclogFilename,vs_err);
 778
 779         // unit_test[14] エラーが発生していること
 780         BOOST_CHECK( vs_err == true );
 781         // unit_test[15] ファイルがマップに登録されていないこと
 782         BOOST_CHECK( vs_err.get_message() == "access log erase instance find err." );
 783
 784     }
 785
 786
 787     std::cout << "find_logger_implement_access vs_err case02 init err size0" << std::endl;
 788     {
 789         std::string aclogFilename = "aclog4";
 790         accesslog_rotate_default_map_type rotatedata;
 791         l7vs::error_code vs_err;
 792
 793         rotatedata.clear();
 794
 795         l7vs::logger_implement_access::rtn_init_flag = false;
 796
 797
 798         logger_implement_access *acinstance = implTest.find_logger_implement_access(aclogFilename,rotatedata,vs_err);
 799
 800         // unit_test[16] エラーが発生していること
 801         BOOST_CHECK( vs_err == true );
 802         // unit_test[17] エラーメッセージが格納されていること
 803         BOOST_CHECK( vs_err.get_message() == "logger_implement_access initialize err." );
 804         // unit_test[18] アクセスログのインスタンスが生成されていないこと
 805         BOOST_CHECK( acinstance == NULL );
 806
 807         l7vs::logger_implement_access::rtn_init_flag = false;
 808
 809         vs_err.setter( false , "" );
 810         implTest.erase_logger_implement_access(aclogFilename,vs_err);
 811
 812         // unit_test[19] エラーが発生していること
 813         BOOST_CHECK( vs_err == true );
 814         // unit_test[20] ファイルがマップに登録されていないこと
 815         BOOST_CHECK( vs_err.get_message() == "access log erase instance find err." );
 816
 817     }
 818
 819     std::cout << "find_logger_implement_access vs_err case02 init err size0" << std::endl;
 820     {
 821         std::string aclogFilename = "aclog4";
 822         accesslog_rotate_default_map_type rotatedata;
 823         l7vs::error_code vs_err;
 824
 825         rotatedata.clear();
 826
 827         l7vs::logger_implement_access::rtn_init_flag = false;
 828
 829
 830         logger_implement_access *acinstance = implTest.find_logger_implement_access(aclogFilename,rotatedata,vs_err);
 831
 832         // unit_test[21] エラーが発生していること
 833         BOOST_CHECK( vs_err == true );
 834         // unit_test[22] エラーメッセージが格納されていること
 835         BOOST_CHECK( vs_err.get_message() == "logger_implement_access initialize err." );
 836         // unit_test[23] アクセスログのインスタンスが生成されていないこと
 837         BOOST_CHECK( acinstance == NULL );
 838
 839         l7vs::logger_implement_access::rtn_init_flag = false;
 840
 841         vs_err.setter( false , "" );
 842         implTest.erase_logger_implement_access(aclogFilename,vs_err);
 843
 844         // unit_test[24] エラーが発生していること
 845         BOOST_CHECK( vs_err == true );
 846         // unit_test[25] ファイルがマップに登録されていないこと
 847         BOOST_CHECK( vs_err.get_message() == "access log erase instance find err." );
 848
 849     }
 850
 851     std::cout << "find_logger_implement_access etc case01 find⇒find⇒find⇒erase⇒erase⇒erase⇒erase" << std::endl;
 852     {
 853         std::string aclogFilename = "aclog4";
 854         accesslog_rotate_default_map_type rotatedata;
 855         l7vs::error_code vs_err;
 856
 857         rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_TYPE , "size" ) );
 858
 859         l7vs::logger_implement_access::rtn_init_flag = true;
 860
 861         vs_err.setter( false , "" );
 862         logger_implement_access *acinstance = implTest.find_logger_implement_access(aclogFilename,rotatedata,vs_err);
 863
 864         // unit_test[26] エラーが発生していないこと
 865         BOOST_CHECK( vs_err == false );
 866         // unit_test[27] エラーメッセージが格納されていること
 867         BOOST_CHECK( vs_err.get_message() == "" );
 868         // unit_test[28] アクセスログのインスタンスが生成されていないこと
 869         BOOST_CHECK( acinstance != NULL );
 870
 871         vs_err.setter( false , "" );
 872         logger_implement_access *acinstance2 = implTest.find_logger_implement_access(aclogFilename,rotatedata,vs_err);
 873
 874         // unit_test[29] エラーが発生していないこと
 875         BOOST_CHECK( vs_err == false );
 876         // unit_test[30] エラーメッセージが格納されていること
 877         BOOST_CHECK( vs_err.get_message() == "" );
 878         // unit_test[31] アクセスログのインスタンスが生成されていること
 879         BOOST_CHECK( acinstance == acinstance2 );
 880
 881         vs_err.setter( false , "" );
 882         logger_implement_access *acinstance3 = implTest.find_logger_implement_access(aclogFilename,rotatedata,vs_err);
 883
 884         // unit_test[32] エラーが発生していないこと
 885         BOOST_CHECK( vs_err == false );
 886         // unit_test[33] エラーメッセージが格納されていること
 887         BOOST_CHECK( vs_err.get_message() == "" );
 888         // unit_test[34] アクセスログのインスタンスが生成されていること
 889         BOOST_CHECK( acinstance == acinstance3 );
 890
 891         vs_err.setter( false , "" );
 892         implTest.erase_logger_implement_access(aclogFilename,vs_err);
 893
 894         // unit_test[35] エラーが発生していないこと
 895         BOOST_CHECK( vs_err == false );
 896         // unit_test[36] エラーメッセージが格納されていないこと
 897         BOOST_CHECK( vs_err.get_message() == "" );
 898
 899         vs_err.setter( false , "" );
 900         implTest.erase_logger_implement_access(aclogFilename,vs_err);
 901
 902         // unit_test[37] エラーが発生していないこと
 903         BOOST_CHECK( vs_err == false );
 904         // unit_test[38] エラーメッセージが格納されていないこと
 905         BOOST_CHECK( vs_err.get_message() == "" );
 906
 907         vs_err.setter( false , "" );
 908         implTest.erase_logger_implement_access(aclogFilename,vs_err);
 909
 910         // unit_test[39] エラーが発生していないこと
 911         BOOST_CHECK( vs_err == false );
 912         // unit_test[40] エラーメッセージが格納されていないこと
 913         BOOST_CHECK( vs_err.get_message() == "" );
 914
 915         vs_err.setter( false , "" );
 916         implTest.erase_logger_implement_access(aclogFilename,vs_err);
 917
 918         // unit_test[41] エラーが発生していること
 919         BOOST_CHECK( vs_err == true );
 920         // unit_test[42] エラーメッセージが格納されていること
 921         BOOST_CHECK( vs_err.get_message() == "access log erase instance find err." );
 922
 923     }
 924
 925     std::cout << "find_logger_implement_access etc case01 erase⇒erase⇒erase⇒erase" << std::endl;
 926     {
 927         std::string aclogFilename = "aclog4";
 928         accesslog_rotate_default_map_type rotatedata;
 929         l7vs::error_code vs_err;
 930
 931         rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_TYPE , "size" ) );
 932
 933         l7vs::logger_implement_access::rtn_init_flag = true;
 934
 935         vs_err.setter( false , "" );
 936         implTest.erase_logger_implement_access(aclogFilename,vs_err);
 937
 938         // unit_test[43] エラーが発生していないこと
 939         BOOST_CHECK( vs_err == true );
 940         // unit_test[44] エラーメッセージが格納されていないこと
 941         BOOST_CHECK( vs_err.get_message() == "access log erase instance find err." );
 942
 943         vs_err.setter( false , "" );
 944         implTest.erase_logger_implement_access(aclogFilename,vs_err);
 945
 946         // unit_test[45] エラーが発生していないこと
 947         BOOST_CHECK( vs_err == true );
 948         // unit_test[46] エラーメッセージが格納されていないこと
 949         BOOST_CHECK( vs_err.get_message() == "access log erase instance find err." );
 950
 951         vs_err.setter( false , "" );
 952         implTest.erase_logger_implement_access(aclogFilename,vs_err);
 953
 954         // unit_test[47] エラーが発生していないこと
 955         BOOST_CHECK( vs_err == true );
 956         // unit_test[48] エラーメッセージが格納されていないこと
 957         BOOST_CHECK( vs_err.get_message() == "access log erase instance find err." );
 958
 959     }
 960
 961
 962
 963
 964     BOOST_MESSAGE( "----- logger_access_manager_find_and_erase_logger_implement_access_test end -----" );
 965 }
 966
 967 void logger_access_manager_get_rotate_default_verbose_displayed_contents_test()
 968 {
 969
 970     BOOST_MESSAGE( "----- logger_access_manager_get_rotate_default_verbose_displayed_contents_test start -----" );
 971
 972     logger_access_manager_test implTest;
 973
 974     std::string test_Msg = "default_info";
 975     std::string rtn_Msg = "";
 976
 977     implTest.set_rotate_default_verbose_displayed_contents(test_Msg);
 978
 979     rtn_Msg = implTest.call_get_rotate_default_verbose_displayed_contents();
 980
 981     // unit_test[1] コンストラクタでメンバ変数が初期化されているか。
 982     BOOST_CHECK_EQUAL(test_Msg, rtn_Msg);
 983
 984     BOOST_MESSAGE( "----- logger_access_manager_get_rotate_default_verbose_displayed_contents_test end -----" );
 985 }
 986
 987
 988 void logger_logrotate_utility_loglotation_utility_logic_error_test()
 989 {
 990
 991     BOOST_MESSAGE( "----- logger_logrotate_utility_loglotation_utility_logic_error_test start -----" );
 992
 993     logger_access_manager_test implTest;
 994     std::string no_thorw_error_msg = "err_msg";
 995
 996     try {
 997
 998         logger_logrotate_utility::loglotation_utility_logic_error( 999, no_thorw_error_msg, __FILE__, __LINE__);
 999         BOOST_ERROR(no_thorw_error_msg);
1000
1001     }
1002     catch ( const std::logic_error& ex ) {
1003         // unit_test[1] コンストラクタでメンバ変数が初期化されているか。
1004         BOOST_CHECK_EQUAL(ex.what(), no_thorw_error_msg);
1005     }
1006
1007
1008     BOOST_MESSAGE( "----- logger_logrotate_utility_loglotation_utility_logic_error_test end -----" );
1009 }
1010
1011
1012 void logger_logrotate_utility_getRotationTimingValue_test()
1013 {
1014
1015     BOOST_MESSAGE( "----- logger_logrotate_utility_getRotationTimingValue_test start -----" );
1016 std::cout << "----- logger_logrotate_utility_getRotationTimingValue_test start -----\n";
1017
1018     logger_access_manager_test implTest;
1019     std::string no_thorw_error_msg = "err_msg";
1020
1021     // unit_test[1] loadConf method call
1022         //＊ローテーション日時を取得すること　年
1023
1024     LOG_ROTATION_TIMING_TAG rotation_timing = LOG_TIM_YEAR;
1025     std::string rotation_timing_value_key = "";
1026     std::string rtn_data = "";
1027
1028     rotation_timing_value_key = "05/05 01:31";
1029     rotation_timing = LOG_TIM_YEAR;
1030     rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1031         BOOST_CHECK_EQUAL( rtn_data , "05050131" );
1032
1033
1034         // unit_test[2] loadConf method call
1035         try {
1036         //＊ローテーション日時(年)が不正な時　区切り文字無し　すべて無し
1037     rotation_timing_value_key = "05050131";
1038     rotation_timing = LOG_TIM_YEAR;
1039         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1040         BOOST_ERROR(no_thorw_error_msg);
1041
1042         } catch( const std::logic_error& ex ) {
1043             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Year Error.");
1044         }
1045
1046
1047         // unit_test[3] loadConf method call
1048         try {
1049         //＊ローテーション日時(年)が不正な時　区切り文字無し　日付の区切りが無し
1050     rotation_timing_value_key = "0505 01:31";
1051     rotation_timing = LOG_TIM_YEAR;
1052         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1053         BOOST_ERROR(no_thorw_error_msg);
1054
1055         } catch( const std::logic_error& ex ) {
1056             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Year Error.");
1057         }
1058
1059         // unit_test[4] loadConf method call
1060         try{
1061         //＊ローテーション日時(年)が不正な時　区切り文字無し　日付、時間の間の区切りが無し
1062     rotation_timing_value_key = "05/0501:31";
1063     rotation_timing = LOG_TIM_YEAR;
1064         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1065         BOOST_ERROR(no_thorw_error_msg);
1066
1067         } catch( const std::logic_error& ex ) {
1068             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Year Error.");
1069         }
1070
1071         // unit_test[5] loadConf method call
1072         try{
1073         //＊ローテーション日時(年)が不正な時　区切り文字無し　時間の間の区切りが無し
1074     rotation_timing_value_key = "05/05 0131";
1075     rotation_timing = LOG_TIM_YEAR;
1076         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1077         BOOST_ERROR(no_thorw_error_msg);
1078
1079         } catch( const std::logic_error& ex ) {
1080             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Year Error.");
1081         }
1082
1083         // unit_test[6] loadConf method call
1084         try{
1085         //＊ローテーション日時(年)が不正な時　値無し　月が無し
1086     rotation_timing_value_key = "/05 01:31";
1087     rotation_timing = LOG_TIM_YEAR;
1088         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1089         BOOST_ERROR(no_thorw_error_msg);
1090
1091         } catch( const std::logic_error& ex ) {
1092             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Year Error.");
1093         }
1094
1095         // unit_test[7] loadConf method call
1096         try{
1097         //＊ローテーション日時(年)が不正な時　値無し　日が無し
1098     rotation_timing_value_key = "05/ 01:31";
1099     rotation_timing = LOG_TIM_YEAR;
1100         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1101         BOOST_ERROR(no_thorw_error_msg);
1102
1103         } catch( const std::logic_error& ex ) {
1104             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Year Error.");
1105         }
1106
1107         // unit_test[8] loadConf method call
1108         try{
1109         //＊ローテーション日時(年)が不正な時　値無し　時間が無し
1110     rotation_timing_value_key = "05/05 :31";
1111     rotation_timing = LOG_TIM_YEAR;
1112         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1113         BOOST_ERROR(no_thorw_error_msg);
1114
1115         } catch( const std::logic_error& ex ) {
1116             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Year Error.");
1117         }
1118
1119
1120         // unit_test[9] loadConf method call
1121         try{
1122         //＊ローテーション日時(年)が不正な時　値無し　分が無し
1123     rotation_timing_value_key = "05/05 01:";
1124     rotation_timing = LOG_TIM_YEAR;
1125
1126         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1127         BOOST_ERROR(no_thorw_error_msg);
1128
1129         } catch( const std::logic_error& ex ) {
1130             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Year Error.");
1131         }
1132
1133
1134         // unit_test[10] loadConf method call
1135         try{
1136         //＊ローテーション日時(年)が不正な時　値不正　月が不正
1137     rotation_timing_value_key = "a/05 01:31";
1138     rotation_timing = LOG_TIM_YEAR;
1139         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1140         BOOST_ERROR(no_thorw_error_msg);
1141
1142         } catch( const std::logic_error& ex ) {
1143             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Year Error.");
1144         }
1145
1146         // unit_test[11] loadConf method call
1147         try{
1148         //＊ローテーション日時(年)が不正な時　値不正　日が不正
1149     rotation_timing_value_key = "05/b 01:31";
1150     rotation_timing = LOG_TIM_YEAR;
1151         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1152         BOOST_ERROR(no_thorw_error_msg);
1153
1154         } catch( const std::logic_error& ex ) {
1155             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Year Error.");
1156         }
1157
1158         // unit_test[12] loadConf method call
1159         try{
1160         //＊ローテーション日時(年)が不正な時　値不正　時間が不正
1161     rotation_timing_value_key = "05/05 c:31";
1162     rotation_timing = LOG_TIM_YEAR;
1163         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1164         BOOST_ERROR(no_thorw_error_msg);
1165
1166         } catch( const std::logic_error& ex ) {
1167             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Year Error.");
1168         }
1169
1170         // unit_test[13] loadConf method call
1171         try{
1172         //＊ローテーション日時(年)が不正な時　値不正　分が不正
1173     rotation_timing_value_key = "05/05 01:d";
1174     rotation_timing = LOG_TIM_YEAR;
1175         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1176         BOOST_ERROR(no_thorw_error_msg);
1177
1178         } catch( const std::logic_error& ex ) {
1179             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Year Error.");
1180         }
1181
1182         // unit_test[14] loadConf method call
1183         try{
1184         //＊ローテーション日時(年)が不正な時　値範囲不正　月が不正
1185     rotation_timing_value_key = "13/05 01:31";
1186     rotation_timing = LOG_TIM_YEAR;
1187         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1188         BOOST_ERROR(no_thorw_error_msg);
1189
1190         } catch( const std::logic_error& ex ) {
1191             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Year Error.");
1192         }
1193
1194         // unit_test[15] loadConf method call
1195         try{
1196         //＊ローテーション日時(年)が不正な時　値範囲不正　日が不正
1197     rotation_timing_value_key = "05/32 01:31";
1198     rotation_timing = LOG_TIM_YEAR;
1199         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1200         BOOST_ERROR(no_thorw_error_msg);
1201
1202         } catch( const std::logic_error& ex ) {
1203             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Year Error.");
1204         }
1205
1206         // unit_test[16] loadConf method call
1207         try{
1208         //＊ローテーション日時(年)が不正な時　値範囲不正　時間が不正
1209     rotation_timing_value_key = "05/05 24:31";
1210     rotation_timing = LOG_TIM_YEAR;
1211         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1212         BOOST_ERROR(no_thorw_error_msg);
1213
1214         } catch( const std::logic_error& ex ) {
1215             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Year Error.");
1216         }
1217
1218         // unit_test[17] loadConf method call
1219         try{
1220         //＊ローテーション日時(年)が不正な時　値範囲不正　時間が不正
1221     rotation_timing_value_key = "05/05 01:60";
1222     rotation_timing = LOG_TIM_YEAR;
1223         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1224         BOOST_ERROR(no_thorw_error_msg);
1225
1226         } catch( const std::logic_error& ex ) {
1227             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Year Error.");
1228         }
1229
1230         // unit_test[18] loadConf method call
1231         try{
1232         //＊ローテーション日時(年)が不正な時　日付不正　存在しない日付
1233     rotation_timing_value_key = "04/31 01:31";
1234     rotation_timing = LOG_TIM_YEAR;
1235         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1236         BOOST_ERROR(no_thorw_error_msg);
1237
1238         } catch( const std::logic_error& ex ) {
1239             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Year Error.");
1240         }
1241
1242         // unit_test[19] loadConf method call
1243         try{
1244         //＊ローテーション日時(年)が存在しなかった時にエラーとなること
1245     rotation_timing_value_key = "";
1246     rotation_timing = LOG_TIM_YEAR;
1247         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1248         BOOST_ERROR(no_thorw_error_msg);
1249
1250         } catch( const std::logic_error& ex ) {
1251             BOOST_CHECK_EQUAL(ex.what(), "Not Exist Log RotaionTiming Year Setting.");
1252         }
1253
1254         // unit_test[20] loadConf method call
1255         //＊ローテーション日時を取得すること　月
1256     rotation_timing_value_key = "15 18:21";
1257     rotation_timing = LOG_TIM_MONTH;
1258         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1259         BOOST_CHECK_EQUAL(rtn_data, "151821");
1260
1261
1262         // unit_test[21] loadConf method call
1263         try{
1264         //＊ローテーション日時(月)が不正な時　区切り文字無し　すべて無し
1265     rotation_timing_value_key = "151821";
1266     rotation_timing = LOG_TIM_MONTH;
1267         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1268         BOOST_ERROR(no_thorw_error_msg);
1269
1270         } catch( const std::logic_error& ex ) {
1271             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Month Error.");
1272         }
1273
1274         // unit_test[22] loadConf method call
1275         try{
1276         //＊ローテーション日時(月)が不正な時　区切り文字無し　日付、時間の間の区切りが無し
1277     rotation_timing_value_key = "1518:21";
1278     rotation_timing = LOG_TIM_MONTH;
1279         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1280         BOOST_ERROR(no_thorw_error_msg);
1281
1282         } catch( const std::logic_error& ex ) {
1283             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Month Error.");
1284         }
1285
1286         // unit_test[23] loadConf method call
1287         try{
1288         //＊ローテーション日時(月)が不正な時　区切り文字無し　時間と分の間の区切りが無し
1289     rotation_timing_value_key = "15 1821";
1290     rotation_timing = LOG_TIM_MONTH;
1291         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1292         BOOST_ERROR(no_thorw_error_msg);
1293
1294         } catch( const std::logic_error& ex ) {
1295             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Month Error.");
1296         }
1297
1298         // unit_test[24] loadConf method call
1299         try{
1300         //＊ローテーション日時(月)が不正な時　値無し　日が無し
1301     rotation_timing_value_key = " 18:21";
1302     rotation_timing = LOG_TIM_MONTH;
1303         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1304         BOOST_ERROR(no_thorw_error_msg);
1305
1306         } catch( const std::logic_error& ex ) {
1307             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Month Error.");
1308         }
1309
1310         // unit_test[25] loadConf method call
1311         try{
1312         //＊ローテーション日時(月)が不正な時　値無し　時間が無し
1313     rotation_timing_value_key = "15 :21";
1314     rotation_timing = LOG_TIM_MONTH;
1315         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1316         BOOST_ERROR(no_thorw_error_msg);
1317
1318         } catch( const std::logic_error& ex ) {
1319             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Month Error.");
1320         }
1321
1322         // unit_test[26] loadConf method call
1323         try{
1324         //＊ローテーション日時(月)が不正な時　値無し　分が無し
1325     rotation_timing_value_key = "15 18:";
1326     rotation_timing = LOG_TIM_MONTH;
1327         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1328         BOOST_ERROR(no_thorw_error_msg);
1329
1330         } catch( const std::logic_error& ex ) {
1331             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Month Error.");
1332         }
1333
1334         // unit_test[27] loadConf method call
1335         try{
1336         //＊ローテーション日時(月)が不正な時　値不正　日が不正
1337     rotation_timing_value_key = "a 18:21";
1338     rotation_timing = LOG_TIM_MONTH;
1339         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1340         BOOST_ERROR(no_thorw_error_msg);
1341
1342         } catch( const std::logic_error& ex ) {
1343             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Month Error.");
1344         }
1345
1346         // unit_test[28] loadConf method call
1347         try{
1348         //＊ローテーション日時(月)が不正な時　値不正　時間が不正
1349     rotation_timing_value_key = "15 b:21";
1350     rotation_timing = LOG_TIM_MONTH;
1351         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1352         BOOST_ERROR(no_thorw_error_msg);
1353
1354         } catch( const std::logic_error& ex ) {
1355             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Month Error.");
1356         }
1357
1358         // unit_test[29] loadConf method call
1359         try{
1360         //＊ローテーション日時(月)が不正な時　値不正　分が不正
1361     rotation_timing_value_key = "15 18:c";
1362     rotation_timing = LOG_TIM_MONTH;
1363         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1364         BOOST_ERROR(no_thorw_error_msg);
1365
1366         } catch( const std::logic_error& ex ) {
1367             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Month Error.");
1368         }
1369
1370         // unit_test[30] loadConf method call
1371         try{
1372         //＊ローテーション日時(月)が不正な時　値範囲不正　日が不正
1373     rotation_timing_value_key = "0 18:21";
1374     rotation_timing = LOG_TIM_MONTH;
1375         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1376         BOOST_ERROR(no_thorw_error_msg);
1377
1378         } catch( const std::logic_error& ex ) {
1379             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Month Error.");
1380         }
1381
1382         // unit_test[31] loadConf method call
1383         try{
1384         //＊ローテーション日時(月)が不正な時　値範囲不正　時間が不正
1385     rotation_timing_value_key = "15 -1:21";
1386     rotation_timing = LOG_TIM_MONTH;
1387         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1388         BOOST_ERROR(no_thorw_error_msg);
1389
1390         } catch( const std::logic_error& ex ) {
1391             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Month Error.");
1392         }
1393
1394         // unit_test[32] loadConf method call
1395         try{
1396         //＊ローテーション日時(月)が不正な時　値範囲不正　時間が不正
1397     rotation_timing_value_key = "15 18:-15";
1398     rotation_timing = LOG_TIM_MONTH;
1399         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1400         BOOST_ERROR(no_thorw_error_msg);
1401
1402         } catch( const std::logic_error& ex ) {
1403             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Month Error.");
1404         }
1405
1406         // unit_test[33] loadConf method call
1407         try{
1408         //＊ローテーション日時(月)が存在しなかった時にエラーとなること
1409     rotation_timing_value_key = "";
1410     rotation_timing = LOG_TIM_MONTH;
1411         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1412         BOOST_ERROR(no_thorw_error_msg);
1413
1414         } catch( const std::logic_error& ex ) {
1415             BOOST_CHECK_EQUAL(ex.what(), "Not Exist Log RotaionTiming Month Setting.");
1416         }
1417
1418         // unit_test[34] loadConf method call
1419         //＊ローテーション日時を取得すること　週
1420     rotation_timing_value_key = "mon 23:59";
1421     rotation_timing = LOG_TIM_WEEK;
1422         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1423         BOOST_CHECK_EQUAL(rtn_data, "12359");           //0:日 1:月 2:火 3:水 4:木 5:金 6:土
1424
1425
1426         // unit_test[35] loadConf method call
1427         try{
1428         //＊ローテーション日時(週)が不正な時　区切り文字無し　すべて無し
1429     rotation_timing_value_key = "mon2359";
1430     rotation_timing = LOG_TIM_WEEK;
1431         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1432         BOOST_ERROR(no_thorw_error_msg);
1433
1434         } catch( const std::logic_error& ex ) {
1435             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Week Error.");
1436         }
1437
1438         // unit_test[36] loadConf method call
1439         try{
1440         //＊ローテーション日時(週)が不正な時　区切り文字無し　週、時間の間の区切りが無し
1441     rotation_timing_value_key = "mon23:59";
1442     rotation_timing = LOG_TIM_WEEK;
1443         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1444         BOOST_ERROR(no_thorw_error_msg);
1445
1446         } catch( const std::logic_error& ex ) {
1447             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Week Error.");
1448         }
1449
1450         // unit_test[37] loadConf method call
1451         try{
1452         //＊ローテーション日時(週)が不正な時　区切り文字無し　時間と分の間の区切りが無し
1453     rotation_timing_value_key = "mon 2359";
1454     rotation_timing = LOG_TIM_WEEK;
1455         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1456         BOOST_ERROR(no_thorw_error_msg);
1457
1458         } catch( const std::logic_error& ex ) {
1459             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Week Error.");
1460         }
1461
1462
1463         // unit_test[38] loadConf method call
1464         try{
1465         //＊ローテーション日時(週)が不正な時　値無し　週が無し
1466     rotation_timing_value_key = " 23:59";
1467     rotation_timing = LOG_TIM_WEEK;
1468         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1469         BOOST_ERROR(no_thorw_error_msg);
1470
1471         } catch( const std::logic_error& ex ) {
1472             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Week Error.");
1473         }
1474
1475         // unit_test[39] loadConf method call
1476         try{
1477         //＊ローテーション日時(週)が不正な時　値無し　時間が無し
1478     rotation_timing_value_key = "mon :59";
1479     rotation_timing = LOG_TIM_WEEK;
1480         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1481         BOOST_ERROR(no_thorw_error_msg);
1482
1483         } catch( const std::logic_error& ex ) {
1484             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Week Error.");
1485         }
1486
1487         // unit_test[40] loadConf method call
1488         try{
1489         //＊ローテーション日時(週)が不正な時　値無し　分が無し
1490     rotation_timing_value_key = "mon 23:";
1491     rotation_timing = LOG_TIM_WEEK;
1492         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1493         BOOST_ERROR(no_thorw_error_msg);
1494
1495         } catch( const std::logic_error& ex ) {
1496             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Week Error.");
1497         }
1498
1499         // unit_test[41] loadConf method call
1500         try{
1501         //＊ローテーション日時(週)が不正な時　値不正　週が不正
1502     rotation_timing_value_key = "monday 23:59";
1503     rotation_timing = LOG_TIM_WEEK;
1504         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1505         BOOST_ERROR(no_thorw_error_msg);
1506
1507         } catch( const std::logic_error& ex ) {
1508             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Week Error.");
1509         }
1510
1511         // unit_test[42] loadConf method call
1512         try{
1513         //＊ローテーション日時(週)が不正な時　値不正　時間が不正
1514     rotation_timing_value_key = "mon a:59";
1515     rotation_timing = LOG_TIM_WEEK;
1516         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1517         BOOST_ERROR(no_thorw_error_msg);
1518
1519         } catch( const std::logic_error& ex ) {
1520             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Week Error.");
1521         }
1522
1523         // unit_test[43] loadConf method call
1524         try{
1525         //＊ローテーション日時(週)が不正な時　値不正　分が不正
1526     rotation_timing_value_key = "mon 23:b";
1527     rotation_timing = LOG_TIM_WEEK;
1528         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1529         BOOST_ERROR(no_thorw_error_msg);
1530
1531         } catch( const std::logic_error& ex ) {
1532             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Week Error.");
1533         }
1534
1535         // unit_test[44] loadConf method call
1536         try{
1537         //＊ローテーション日時(週)が不正な時　値範囲不正　日が不正
1538     rotation_timing_value_key = "0 18:21";
1539     rotation_timing = LOG_TIM_WEEK;
1540         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1541         BOOST_ERROR(no_thorw_error_msg);
1542
1543         } catch( const std::logic_error& ex ) {
1544             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Week Error.");
1545         }
1546
1547         // unit_test[45] loadConf method call
1548         try{
1549         //＊ローテーション日時(週)が不正な時　値範囲不正　時間が不正
1550     rotation_timing_value_key = "mon 99:59";
1551     rotation_timing = LOG_TIM_WEEK;
1552         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1553         BOOST_ERROR(no_thorw_error_msg);
1554
1555         } catch( const std::logic_error& ex ) {
1556             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Week Error.");
1557         }
1558
1559         // unit_test[46] loadConf method call
1560         try{
1561         //＊ローテーション日時(週)が不正な時　値範囲不正　時間が不正
1562     rotation_timing_value_key = "mon 23:100";
1563     rotation_timing = LOG_TIM_WEEK;
1564         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1565         BOOST_ERROR(no_thorw_error_msg);
1566
1567         } catch( const std::logic_error& ex ) {
1568             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Week Error.");
1569         }
1570
1571         // unit_test[47] loadConf method call
1572         try{
1573         //＊ローテーション日時(週)が存在しなかった時にエラーとなること
1574     rotation_timing_value_key = "";
1575     rotation_timing = LOG_TIM_WEEK;
1576         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1577         BOOST_ERROR(no_thorw_error_msg);
1578
1579         } catch( const std::logic_error& ex ) {
1580             BOOST_CHECK_EQUAL(ex.what(), "Not Exist Log RotaionTiming Week Setting.");
1581         }
1582
1583         // unit_test[48] loadConf method call
1584         //＊ローテーション日時を取得すること　日
1585     rotation_timing_value_key = "12:00";
1586     rotation_timing = LOG_TIM_DATE;
1587         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1588         BOOST_CHECK_EQUAL(rtn_data, "1200");
1589
1590         // unit_test[49] loadConf method call
1591         try{
1592         //＊ローテーション日時(日)が不正な時　区切り文字無し　時間と分の間の区切りが無し
1593     rotation_timing_value_key = "1200";
1594     rotation_timing = LOG_TIM_DATE;
1595         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1596         BOOST_ERROR(no_thorw_error_msg);
1597
1598         } catch( const std::logic_error& ex ) {
1599             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Date Error.");
1600         }
1601
1602         // unit_test[50] loadConf method call
1603         try{
1604         //＊ローテーション日時(日)が不正な時　値無し　時間が無し
1605     rotation_timing_value_key = ":00";
1606     rotation_timing = LOG_TIM_DATE;
1607         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1608         BOOST_ERROR(no_thorw_error_msg);
1609
1610         } catch( const std::logic_error& ex ) {
1611             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Date Error.");
1612         }
1613
1614         // unit_test[51] loadConf method call
1615         try{
1616         //＊ローテーション日時(日)が不正な時　値無し　分が無し
1617     rotation_timing_value_key = "12:";
1618     rotation_timing = LOG_TIM_DATE;
1619         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1620         BOOST_ERROR(no_thorw_error_msg);
1621
1622         } catch( const std::logic_error& ex ) {
1623             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Date Error.");
1624         }
1625
1626         // unit_test[52] loadConf method call
1627         try{
1628         //＊ローテーション日時(日)が不正な時　値不正　時間が不正
1629     rotation_timing_value_key = "a:00";
1630     rotation_timing = LOG_TIM_DATE;
1631         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1632         BOOST_ERROR(no_thorw_error_msg);
1633
1634         } catch( const std::logic_error& ex ) {
1635             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Date Error.");
1636         }
1637
1638         // unit_test[53] loadConf method call
1639         try{
1640         //＊ローテーション日時(日)が不正な時　値不正　分が不正
1641     rotation_timing_value_key = "12:b";
1642     rotation_timing = LOG_TIM_DATE;
1643         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1644         BOOST_ERROR(no_thorw_error_msg);
1645
1646         } catch( const std::logic_error& ex ) {
1647             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Date Error.");
1648         }
1649
1650         // unit_test[54] loadConf method call
1651         try{
1652         //＊ローテーション日時(日)が不正な時　値範囲不正　時間が不正
1653     rotation_timing_value_key = "-21:00";
1654     rotation_timing = LOG_TIM_DATE;
1655         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1656         BOOST_ERROR(no_thorw_error_msg);
1657
1658         } catch( const std::logic_error& ex ) {
1659             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Date Error.");
1660         }
1661
1662         // unit_test[55] loadConf method call
1663         try{
1664         //＊ローテーション日時(日)が不正な時　値範囲不正　時間が不正
1665     rotation_timing_value_key = "12:-59";
1666     rotation_timing = LOG_TIM_DATE;
1667         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1668         BOOST_ERROR(no_thorw_error_msg);
1669
1670         } catch( const std::logic_error& ex ) {
1671             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Date Error.");
1672         }
1673
1674         // unit_test[56] loadConf method call
1675         try{
1676         //＊ローテーション日時(日)が存在しなかった時にエラーとなること
1677     rotation_timing_value_key = "";
1678     rotation_timing = LOG_TIM_DATE;
1679         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1680         BOOST_ERROR(no_thorw_error_msg);
1681
1682         } catch( const std::logic_error& ex ) {
1683             BOOST_CHECK_EQUAL(ex.what(), "Not Exist Log RotaionTiming Date Setting.");
1684         }
1685
1686
1687         // unit_test[57] loadConf method call
1688         //＊ローテーション日時を取得すること　時
1689     rotation_timing_value_key = "45";
1690     rotation_timing = LOG_TIM_HOUR;
1691         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1692         BOOST_CHECK_EQUAL(rtn_data, "45");
1693
1694         // unit_test[58] loadConf method call
1695         try{
1696         //＊ローテーション日時(日)が不正な時　値無し　分が無し
1697     rotation_timing_value_key = "";
1698     rotation_timing = LOG_TIM_HOUR;
1699         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1700         BOOST_ERROR(no_thorw_error_msg);
1701
1702         } catch( const std::logic_error& ex ) {
1703             BOOST_CHECK_EQUAL(ex.what(), "Not Exist Log RotaionTiming Hour Setting.");
1704         }
1705
1706         // unit_test[59] loadConf method call
1707         try{
1708         //＊ローテーション日時(日)が不正な時　値不正　分が不正
1709     rotation_timing_value_key = "a";
1710     rotation_timing = LOG_TIM_HOUR;
1711         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1712         BOOST_ERROR(no_thorw_error_msg);
1713
1714         } catch( const std::logic_error& ex ) {
1715             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Hour Error.");
1716         }
1717
1718         // unit_test[60] loadConf method call
1719         try{
1720         //＊ローテーション日時(日)が不正な時　値範囲不正　分が不正
1721     rotation_timing_value_key = "120";
1722     rotation_timing = LOG_TIM_HOUR;
1723         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1724         BOOST_ERROR(no_thorw_error_msg);
1725
1726         } catch( const std::logic_error& ex ) {
1727             BOOST_CHECK_EQUAL(ex.what(), "Parse Timing Hour Error.");
1728         }
1729
1730         // unit_test[61] loadConf method call
1731         try{
1732         //＊ローテーション日時(日)が存在しなかった時にエラーとなること
1733     rotation_timing_value_key = "";
1734     rotation_timing = LOG_TIM_HOUR;
1735         rtn_data = logger_logrotate_utility::check_rotate_timing_value( rotation_timing_value_key, rotation_timing );
1736         BOOST_ERROR(no_thorw_error_msg);
1737
1738         } catch( const std::logic_error& ex ) {
1739             BOOST_CHECK_EQUAL(ex.what(), "Not Exist Log RotaionTiming Hour Setting.");
1740         }
1741
1742
1743 std::cout << "----- logger_logrotate_utility_getRotationTimingValue_test end -----\n";
1744
1745     BOOST_MESSAGE( "----- logger_logrotate_utility_getRotationTimingValue_test end -----" );
1746 }
1747
1748
1749 void logger_logrotate_utility_set_appender_test()
1750 {
1751
1752     BOOST_MESSAGE( "----- logger_logrotate_utility_set_appender_test start -----" );
1753
1754     logger_access_manager_test implTest;
1755     std::string no_thorw_error_msg = "err_msg";
1756     appender_property log_property;
1757
1758     log_property.log_filename_key                = "";
1759     log_property.log_filename_value              = "";
1760     log_property.rotation_key                    = "";
1761     log_property.rotation_value                  = LOG_ROT_SIZE;
1762     log_property.max_backup_index_key            = "";
1763     log_property.max_backup_index_value          = 1;
1764     log_property.max_file_size_key               = "";
1765     log_property.max_file_size_value             = 1;
1766     log_property.rotation_timing_key             = "";
1767     log_property.rotation_timing_value           = LOG_TIM_YEAR;
1768     log_property.rotation_timing_value_key       = "";
1769     log_property.rotation_timing_value_value     = "";
1770
1771     char *logger_layout = (char*)LOGGER_ACCESS_LAYOUT;
1772
1773     std::string log_category = "./test";
1774
1775     std::cout << "set_appender normal case01 size" << std::endl;
1776     {
1777         no_thorw_error_msg = "exception throw";
1778
1779         log_category = "./test1";
1780
1781         log_property.log_filename_key                = "";
1782         log_property.log_filename_value              = log_category;
1783         log_property.rotation_key                    = "";
1784         log_property.rotation_value                  = LOG_ROT_SIZE;
1785         log_property.max_backup_index_key            = "";
1786         log_property.max_backup_index_value          = 1;
1787         log_property.max_file_size_key               = "";
1788         log_property.max_file_size_value             = (100U * 1024 * 1024);
1789         log_property.rotation_timing_key             = "";
1790         log_property.rotation_timing_value           = LOG_TIM_YEAR;
1791         log_property.rotation_timing_value_key       = "";
1792         log_property.rotation_timing_value_value     = "";
1793
1794         try {
1795
1796             logger_logrotate_utility::set_appender(log_property,logger_layout,log_category);
1797             std::cout << "set_appender succeed\n";
1798         }
1799         catch ( const std::logic_error& ex ) {
1800             // unit_test[1] コンストラクタでメンバ変数が初期化されているか。
1801             BOOST_ERROR(no_thorw_error_msg);
1802         }
1803
1804     }
1805
1806     std::cout << "set_appender normal case02 date" << std::endl;
1807     {
1808         no_thorw_error_msg = "exception throw";
1809
1810         log_category = "./test2";
1811
1812         log_property.log_filename_key                = "";
1813         log_property.log_filename_value              = log_category;
1814         log_property.rotation_key                    = "";
1815         log_property.rotation_value                  = LOG_ROT_DATE;
1816         log_property.max_backup_index_key            = "";
1817         log_property.max_backup_index_value          = 1;
1818         log_property.max_file_size_key               = "";
1819         log_property.max_file_size_value             = (100U * 1024 * 1024);
1820         log_property.rotation_timing_key             = "";
1821         log_property.rotation_timing_value           = LOG_TIM_YEAR;
1822         log_property.rotation_timing_value_key       = "";
1823         log_property.rotation_timing_value_value     = "05050131";
1824
1825         try {
1826
1827             logger_logrotate_utility::set_appender(log_property,logger_layout,log_category);
1828             std::cout << "set_appender succeed\n";
1829         }
1830         catch ( const std::logic_error& ex ) {
1831             // unit_test[1] コンストラクタでメンバ変数が初期化されているか。
1832             BOOST_ERROR(no_thorw_error_msg);
1833         }
1834
1835     }
1836
1837     std::cout << "set_appender normal case03 datesize" << std::endl;
1838     {
1839         no_thorw_error_msg = "exception throw";
1840
1841         log_category = "./test3";
1842
1843         log_property.log_filename_key                = "";
1844         log_property.log_filename_value              = log_category;
1845         log_property.rotation_key                    = "";
1846         log_property.rotation_value                  = LOG_ROT_DATESIZE;
1847         log_property.max_backup_index_key            = "";
1848         log_property.max_backup_index_value          = 1;
1849         log_property.max_file_size_key               = "";
1850         log_property.max_file_size_value             = (100U * 1024 * 1024);
1851         log_property.rotation_timing_key             = "";
1852         log_property.rotation_timing_value           = LOG_TIM_YEAR;
1853         log_property.rotation_timing_value_key       = "";
1854         log_property.rotation_timing_value_value     = "05050131";
1855
1856         try {
1857
1858             logger_logrotate_utility::set_appender(log_property,logger_layout,log_category);
1859             std::cout << "set_appender succeed\n";
1860         }
1861         catch ( const std::logic_error& ex ) {
1862             // unit_test[1] コンストラクタでメンバ変数が初期化されているか。
1863             BOOST_ERROR(no_thorw_error_msg);
1864         }
1865
1866     }
1867
1868 /*
1869     std::cout << "set_appender err case01 size" << std::endl;
1870     {
1871         no_thorw_error_msg = "not exception throw";
1872
1873         log_category = "./test4";
1874
1875         log_property.log_filename_key                = "";
1876         //log_property.log_filename_value              = "";
1877         log_property.log_filename_value              = "";
1878         log_property.rotation_key                    = "";
1879         log_property.rotation_value                  = LOG_ROT_SIZE;
1880         log_property.max_backup_index_key            = "";
1881         log_property.max_backup_index_value          = 1;
1882         log_property.max_file_size_key               = "";
1883         log_property.max_file_size_value             = (100U * 1024 * 1024);
1884         log_property.rotation_timing_key             = "";
1885         log_property.rotation_timing_value           = LOG_TIM_YEAR;
1886         log_property.rotation_timing_value_key       = "";
1887         log_property.rotation_timing_value_value     = "";
1888
1889         try {
1890
1891             logger_logrotate_utility::set_appender(log_property,logger_layout,log_category);
1892
1893             BOOST_ERROR(no_thorw_error_msg);
1894
1895         }
1896         catch ( const std::logic_error& ex ) {
1897             // unit_test[1] コンストラクタでメンバ変数が初期化されているか。
1898             no_thorw_error_msg = "File Create Failed:" + log_property.log_filename_value;
1899             BOOST_ERROR(no_thorw_error_msg);
1900         }
1901
1902     }
1903
1904     std::cout << "set_appender err case02 date" << std::endl;
1905     {
1906         no_thorw_error_msg = "not exception throw";
1907
1908         log_category = "./test5";
1909
1910         log_property.log_filename_key                = "";
1911         log_property.log_filename_value              = "";
1912         log_property.rotation_key                    = "";
1913         log_property.rotation_value                  = LOG_ROT_DATE;
1914         log_property.max_backup_index_key            = "";
1915         log_property.max_backup_index_value          = 1;
1916         log_property.max_file_size_key               = "";
1917         log_property.max_file_size_value             = (100U * 1024 * 1024);
1918         log_property.rotation_timing_key             = "";
1919         log_property.rotation_timing_value           = LOG_TIM_YEAR;
1920         log_property.rotation_timing_value_key       = "";
1921         log_property.rotation_timing_value_value     = "05050131";
1922
1923         try {
1924
1925             logger_logrotate_utility::set_appender(log_property,logger_layout,log_category);
1926
1927             BOOST_ERROR(no_thorw_error_msg);
1928
1929         }
1930         catch ( const std::logic_error& ex ) {
1931             // unit_test[1] コンストラクタでメンバ変数が初期化されているか。
1932             no_thorw_error_msg = "File Create Failed:" + log_property.log_filename_value;
1933             BOOST_ERROR(no_thorw_error_msg);
1934         }
1935
1936     }
1937
1938     std::cout << "set_appender err case03 datesize" << std::endl;
1939     {
1940         no_thorw_error_msg = "not exception throw";
1941
1942         log_category = "./test6";
1943
1944         log_property.log_filename_key                = "";
1945         log_property.log_filename_value              = "";
1946         log_property.rotation_key                    = "";
1947         log_property.rotation_value                  = LOG_ROT_DATESIZE;
1948         log_property.max_backup_index_key            = "";
1949         log_property.max_backup_index_value          = 1;
1950         log_property.max_file_size_key               = "";
1951         log_property.max_file_size_value             = (100U * 1024 * 1024);
1952         log_property.rotation_timing_key             = "";
1953         log_property.rotation_timing_value           = LOG_TIM_YEAR;
1954         log_property.rotation_timing_value_key       = "";
1955         log_property.rotation_timing_value_value     = "05050131";
1956
1957         try {
1958
1959             logger_logrotate_utility::set_appender(log_property,logger_layout,log_category);
1960
1961             BOOST_ERROR(no_thorw_error_msg);
1962         }
1963         catch ( const std::logic_error& ex ) {
1964             // unit_test[1] コンストラクタでメンバ変数が初期化されているか。
1965             no_thorw_error_msg = "File Create Failed:" + log_property.log_filename_value;
1966             BOOST_CHECK_EQUAL(ex.what(), no_thorw_error_msg);
1967         }
1968
1969     }
1970
1971     std::cout << "set_appender err case04 etc" << std::endl;
1972     {
1973         no_thorw_error_msg = "not exception throw";
1974
1975         log_category = "./test7";
1976
1977         log_property.log_filename_key                = "";
1978         log_property.log_filename_value              = log_category;
1979         log_property.rotation_key                    = "";
1980         log_property.rotation_value                  = LOG_ROT_DATESIZE;
1981         log_property.max_backup_index_key            = "";
1982         log_property.max_backup_index_value          = -100;
1983         log_property.max_file_size_key               = "";
1984         log_property.max_file_size_value             = -1;
1985         log_property.rotation_timing_key             = "";
1986         log_property.rotation_timing_value           = LOG_TIM_YEAR;
1987         log_property.rotation_timing_value_key       = "";
1988         log_property.rotation_timing_value_value     = "zzz";
1989
1990         try {
1991
1992             logger_logrotate_utility::set_appender(log_property,logger_layout,log_category);
1993
1994             BOOST_ERROR(no_thorw_error_msg);
1995         }
1996         catch ( const std::logic_error& ex ) {
1997             // unit_test[1] コンストラクタでメンバ変数が初期化されているか。
1998             no_thorw_error_msg = "File Create Failed:" + log_property.log_filename_value;
1999             BOOST_CHECK_EQUAL(ex.what(), no_thorw_error_msg);
2000         }
2001
2002     }
2003 */
2004
2005     BOOST_MESSAGE( "----- logger_logrotate_utility_set_appender_test end -----" );
2006 }
2007
2008
2009 void logger_logrotate_utility_acccess_log_LogrotateParamCheck_test()
2010 {
2011
2012     BOOST_MESSAGE( "----- logger_logrotate_utility_acccess_log_LogrotateParamCheck_test start -----" );
2013
2014     bool rtn_flag = true;
2015     accesslog_rotate_map_type rotatedata;
2016     appender_property log_property;
2017
2018     log_property.log_filename_key                = "";
2019     log_property.log_filename_value              = "";
2020     log_property.rotation_key                    = "";
2021     log_property.rotation_value                  = LOG_ROT_DATESIZE;
2022     log_property.max_backup_index_key            = "";
2023     log_property.max_backup_index_value          = 0;
2024     log_property.max_file_size_key               = "";
2025     log_property.max_file_size_value             = 0;
2026     log_property.rotation_timing_key             = "";
2027     log_property.rotation_timing_value           = LOG_TIM_YEAR;
2028     log_property.rotation_timing_value_key       = "";
2029     log_property.rotation_timing_value_value     = "";
2030
2031     std::cout << "acccess_log_LogrotateParamCheck normal case01 size" << std::endl;
2032     {
2033         rotatedata.clear();
2034
2035         rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_TYPE , "size" ) );
2036         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_TYPE , "date" ) );
2037         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_TYPE , "datesize" ) );
2038         rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_MAX_BACKUP_INDEX , "1" ) );
2039
2040         rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_MAX_FILESIZE , "1000K" ) );
2041
2042         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "year" ) );
2043         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "month" ) );
2044         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "week" ) );
2045         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "date" ) );
2046         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "hour" ) );
2047
2048         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "5/10 11:11" ) );
2049         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "11 5:5" ) );
2050
2051         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "sun 10:10" ) );
2052         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "mon 10:10" ) );
2053         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "tue 10:10" ) );
2054         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "wed 10:10" ) );
2055         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "thu 10:10" ) );
2056         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "fri 10:10" ) );
2057         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "sat 10:10" ) );
2058
2059         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "12:21" ) );
2060         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "55" ) );
2061
2062
2063         log_property.log_filename_key                = "";
2064         log_property.log_filename_value              = "";
2065         log_property.rotation_key                    = "";
2066         log_property.rotation_value                  = LOG_ROT_DATESIZE;
2067         log_property.max_backup_index_key            = "";
2068         log_property.max_backup_index_value          = 0;
2069         log_property.max_file_size_key               = "";
2070         log_property.max_file_size_value             = 0;
2071         log_property.rotation_timing_key             = "";
2072         log_property.rotation_timing_value           = LOG_TIM_YEAR;
2073         log_property.rotation_timing_value_key       = "";
2074         log_property.rotation_timing_value_value     = "";
2075
2076
2077         rtn_flag = logger_logrotate_utility::acccess_log_LogrotateParamCheck(
2078                                             rotatedata,
2079                                             log_property);
2080
2081         BOOST_CHECK_EQUAL(rtn_flag, true);
2082
2083         BOOST_CHECK(log_property.rotation_value == LOG_ROT_SIZE);
2084         BOOST_CHECK(log_property.max_backup_index_value == 1);
2085         BOOST_CHECK(log_property.max_file_size_value == (1000U * 1024));
2086
2087     }
2088
2089     std::cout << "acccess_log_LogrotateParamCheck normal case02 date" << std::endl;
2090     {
2091         rotatedata.clear();
2092
2093         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_TYPE , "size" ) );
2094         rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_TYPE , "date" ) );
2095         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_TYPE , "datesize" ) );
2096         rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_MAX_BACKUP_INDEX , "1" ) );
2097
2098         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_MAX_FILESIZE , "1000K" ) );
2099
2100         rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "year" ) );
2101         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "month" ) );
2102         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "week" ) );
2103         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "date" ) );
2104         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "hour" ) );
2105
2106         rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "05/05 01:31" ) );
2107         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "11 5:5" ) );
2108
2109         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "sun 10:10" ) );
2110         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "mon 10:10" ) );
2111         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "tue 10:10" ) );
2112         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "wed 10:10" ) );
2113         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "thu 10:10" ) );
2114         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "fri 10:10" ) );
2115         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "sat 10:10" ) );
2116
2117         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "12:21" ) );
2118         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "55" ) );
2119
2120
2121         log_property.log_filename_key                = "";
2122         log_property.log_filename_value              = "";
2123         log_property.rotation_key                    = "";
2124         log_property.rotation_value                  = LOG_ROT_DATESIZE;
2125         log_property.max_backup_index_key            = "";
2126         log_property.max_backup_index_value          = 0;
2127         log_property.max_file_size_key               = "";
2128         log_property.max_file_size_value             = 0;
2129         log_property.rotation_timing_key             = "";
2130         log_property.rotation_timing_value           = LOG_TIM_YEAR;
2131         log_property.rotation_timing_value_key       = "";
2132         log_property.rotation_timing_value_value     = "";
2133
2134
2135         rtn_flag = logger_logrotate_utility::acccess_log_LogrotateParamCheck(
2136                                             rotatedata,
2137                                             log_property);
2138
2139         BOOST_CHECK_EQUAL(rtn_flag, true);
2140
2141         BOOST_CHECK(log_property.rotation_value == LOG_ROT_DATE);
2142         BOOST_CHECK(log_property.max_backup_index_value == 1);
2143         BOOST_CHECK(log_property.rotation_timing_value == LOG_TIM_YEAR);
2144         BOOST_CHECK(log_property.rotation_timing_value_value == "05050131");
2145
2146     }
2147
2148     std::cout << "acccess_log_LogrotateParamCheck normal case03 datesize" << std::endl;
2149     {
2150         rotatedata.clear();
2151
2152         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_TYPE , "size" ) );
2153         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_TYPE , "date" ) );
2154         rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_TYPE , "datesize" ) );
2155         rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_MAX_BACKUP_INDEX , "1" ) );
2156
2157         rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_MAX_FILESIZE , "1000K" ) );
2158
2159         rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "year" ) );
2160         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "month" ) );
2161         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "week" ) );
2162         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "date" ) );
2163         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "hour" ) );
2164
2165         rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "05/05 01:31" ) );
2166         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "11 5:5" ) );
2167
2168         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "sun 10:10" ) );
2169         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "mon 10:10" ) );
2170         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "tue 10:10" ) );
2171         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "wed 10:10" ) );
2172         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "thu 10:10" ) );
2173         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "fri 10:10" ) );
2174         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "sat 10:10" ) );
2175
2176         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "12:21" ) );
2177         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "55" ) );
2178
2179
2180         log_property.log_filename_key                = "";
2181         log_property.log_filename_value              = "";
2182         log_property.rotation_key                    = "";
2183         log_property.rotation_value                  = LOG_ROT_DATESIZE;
2184         log_property.max_backup_index_key            = "";
2185         log_property.max_backup_index_value          = 0;
2186         log_property.max_file_size_key               = "";
2187         log_property.max_file_size_value             = 0;
2188         log_property.rotation_timing_key             = "";
2189         log_property.rotation_timing_value           = LOG_TIM_YEAR;
2190         log_property.rotation_timing_value_key       = "";
2191         log_property.rotation_timing_value_value     = "";
2192
2193
2194         rtn_flag = logger_logrotate_utility::acccess_log_LogrotateParamCheck(
2195                                             rotatedata,
2196                                             log_property);
2197
2198         BOOST_CHECK_EQUAL(rtn_flag, true);
2199
2200         BOOST_CHECK(log_property.rotation_value == LOG_ROT_DATESIZE);
2201         BOOST_CHECK(log_property.max_backup_index_value == 1);
2202         BOOST_CHECK(log_property.max_file_size_value == (1000U * 1024));
2203         BOOST_CHECK(log_property.rotation_timing_value == LOG_TIM_YEAR);
2204         BOOST_CHECK(log_property.rotation_timing_value_value == "05050131");
2205
2206     }
2207
2208     std::cout << "acccess_log_LogrotateParamCheck err case01 datesize no size" << std::endl;
2209     {
2210         rotatedata.clear();
2211
2212         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_TYPE , "size" ) );
2213         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_TYPE , "date" ) );
2214         rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_TYPE , "datesize" ) );
2215         rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_MAX_BACKUP_INDEX , "1" ) );
2216
2217         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_MAX_FILESIZE , "1000K" ) );
2218
2219         rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "year" ) );
2220         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "month" ) );
2221         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "week" ) );
2222         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "date" ) );
2223         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "hour" ) );
2224
2225         rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "05/05 01:31" ) );
2226         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "11 5:5" ) );
2227
2228         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "sun 10:10" ) );
2229         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "mon 10:10" ) );
2230         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "tue 10:10" ) );
2231         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "wed 10:10" ) );
2232         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "thu 10:10" ) );
2233         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "fri 10:10" ) );
2234         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "sat 10:10" ) );
2235
2236         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "12:21" ) );
2237         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "55" ) );
2238
2239
2240         log_property.log_filename_key                = "";
2241         log_property.log_filename_value              = "";
2242         log_property.rotation_key                    = "";
2243         log_property.rotation_value                  = LOG_ROT_DATESIZE;
2244         log_property.max_backup_index_key            = "";
2245         log_property.max_backup_index_value          = 0;
2246         log_property.max_file_size_key               = "";
2247         log_property.max_file_size_value             = 0;
2248         log_property.rotation_timing_key             = "";
2249         log_property.rotation_timing_value           = LOG_TIM_YEAR;
2250         log_property.rotation_timing_value_key       = "";
2251         log_property.rotation_timing_value_value     = "";
2252
2253
2254         rtn_flag = logger_logrotate_utility::acccess_log_LogrotateParamCheck(
2255                                             rotatedata,
2256                                             log_property);
2257
2258         BOOST_CHECK_EQUAL(rtn_flag, false);
2259
2260     }
2261
2262     std::cout << "acccess_log_LogrotateParamCheck err case02 datesize no date" << std::endl;
2263     {
2264         rotatedata.clear();
2265
2266         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_TYPE , "size" ) );
2267         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_TYPE , "date" ) );
2268         rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_TYPE , "datesize" ) );
2269         rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_MAX_BACKUP_INDEX , "1" ) );
2270
2271         rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_MAX_FILESIZE , "1000K" ) );
2272
2273         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "year" ) );
2274         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "month" ) );
2275         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "week" ) );
2276         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "date" ) );
2277         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATE_ROTATION_TIMING , "hour" ) );
2278
2279         rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "05/05 01:31" ) );
2280         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "11 5:5" ) );
2281
2282         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "sun 10:10" ) );
2283         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "mon 10:10" ) );
2284         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "tue 10:10" ) );
2285         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "wed 10:10" ) );
2286         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "thu 10:10" ) );
2287         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "fri 10:10" ) );
2288         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "sat 10:10" ) );
2289
2290         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "12:21" ) );
2291         //rotatedata.insert( make_pair( ACCESS_LOG_ROTATION_TIMING_VALUE , "55" ) );
2292
2293
2294         log_property.log_filename_key                = "";
2295         log_property.log_filename_value              = "";
2296         log_property.rotation_key                    = "";
2297         log_property.rotation_value                  = LOG_ROT_DATESIZE;
2298         log_property.max_backup_index_key            = "";
2299         log_property.max_backup_index_value          = 0;
2300         log_property.max_file_size_key               = "";
2301         log_property.max_file_size_value             = 0;
2302         log_property.rotation_timing_key             = "";
2303         log_property.rotation_timing_value           = LOG_TIM_YEAR;
2304         log_property.rotation_timing_value_key       = "";
2305         log_property.rotation_timing_value_value     = "";
2306
2307
2308         rtn_flag = logger_logrotate_utility::acccess_log_LogrotateParamCheck(
2309                                             rotatedata,
2310                                             log_property);
2311
2312         BOOST_CHECK_EQUAL(rtn_flag, false);
2313
2314     }
2315
2316     BOOST_MESSAGE( "----- logger_logrotate_utility_acccess_log_LogrotateParamCheck_test end -----" );
2317 }
2318
2319 test_suite*
2320 init_unit_test_suite(int argc, char* argv[])
2321 {
2322
2323     test_suite* test = BOOST_TEST_SUITE("logger_access_manager_test");
2324     test->add(BOOST_TEST_CASE(logger_access_manager_getInstance_constructor_test));
2325     test->add(BOOST_TEST_CASE(logger_access_manager_access_log_rotate_loadConf_test));
2326     test->add(BOOST_TEST_CASE(logger_access_manager_find_and_erase_logger_implement_access_test));
2327     test->add(BOOST_TEST_CASE(logger_access_manager_get_rotate_default_verbose_displayed_contents_test));
2328     test->add(BOOST_TEST_CASE(logger_logrotate_utility_loglotation_utility_logic_error_test));
2329     test->add(BOOST_TEST_CASE(logger_logrotate_utility_getRotationTimingValue_test));
2330     test->add(BOOST_TEST_CASE(logger_logrotate_utility_set_appender_test));
2331     test->add(BOOST_TEST_CASE(logger_logrotate_utility_acccess_log_LogrotateParamCheck_test));
2332
2333     return test;
2334
2335 }
2336