l7vsd/unit_tests/l7vs_logger/time_size_policy_test.cpp

   1 #include "../../l7vsd/logger/time_and_size_based_rolling_policy.cpp"
   2 #include "../../l7vsd/logger/strict_time_based_rolling_policy.cpp"
   3
   4 #include <iostream>
   5 #include <fstream>
   6 #include <dlfcn.h>
   7 #include <time.h>
   8
   9 #include <boost/test/unit_test.hpp>
  10 #include <log4cxx/pattern/datepatternconverter.h>
  11 #include <log4cxx/pattern/filedatepatternconverter.h>
  12
  13 #define LOG_DATE_FORMAT "%Y%m%d%H%M"
  14
  15 using namespace boost::unit_test_framework;
  16
  17 int triggeringPolicyAddRefCalled;
  18
  19 int triggeringPolicyReleaseRefCalled;
  20
  21 int parseFileNamePatternCalled;
  22
  23 int getDatePatternConverterCalled;
  24 bool getDatePatternConverterReturnNull = false;
  25
  26 int formatFileNameCalled = 0;
  27 LogString formatFileNameArgBuf = "";
  28 ObjectPtr formatFileNameArgObj = 0;
  29
  30 int localtime_rCalled = 0;
  31 time_t localtime_rArg = 0;
  32 bool localtime_rFail = false;
  33
  34 int equalsIgnoreCaseCalled = 0;
  35 bool equalsIgnoreCaseReturns = false;
  36
  37 int timeCalled = 0;
  38 time_t timeArg = 0;
  39 time_t timeReturns = 0;
  40 bool timeReturnNow = true;
  41
  42 int strftimeCalled = 0;
  43 bool strftimeFail = false;
  44 std::string strftimeArgFormat = "";
  45
  46 int mktimeCalled = 0;
  47 bool mktimeFail = false;
  48
  49 int fileListCalled = 0;
  50 std::vector<LogString> fileListReturns;
  51
  52 int fileDeleteFileCalled = 0;
  53 std::vector<std::string> fileDeleteFiles;
  54
  55 int fixedPolicySetOptionCalled = 0;
  56 std::string fixedPolicySetOptionArgOption = "";
  57 std::string fixedPolicySetOptionArgValue = "";
  58
  59 int fixedPolicyActivateOptionsCalled = 0;
  60
  61 int fixedPolicyInitializeCalled = 0;
  62 std::string fixedPolicyInitializeArgFile = "";
  63 bool fixedPolicyInitializeArgAppend = false;
  64
  65 int fixedPolicyRolloverCalled = 0;
  66 std::string fixedPolicyRolloverArgActiveFile = "";
  67
  68
  69 extern "C" {
  70 void triggeringPolicyAddRef_(log4cxx::rolling::TriggeringPolicy* ts) {
  71         ++triggeringPolicyAddRefCalled;
  72 }
  73
  74 void triggeringPolicyReleaseRef_(log4cxx::rolling::TriggeringPolicy* ts) {
  75         ++triggeringPolicyReleaseRefCalled;
  76 }
  77
  78 void parseFileNamePattern_(log4cxx::rolling::RollingPolicyBase* ts) {
  79         ++parseFileNamePatternCalled;
  80 }
  81
  82 log4cxx::pattern::PatternConverterPtr getDatePatternConverter_(log4cxx::rolling::RollingPolicyBase* ts) {
  83         ++getDatePatternConverterCalled;
  84         if (getDatePatternConverterReturnNull) {
  85                 return 0;
  86         }
  87
  88         std::vector<LogString> altOptions;
  89         altOptions.push_back(LOG4CXX_STR("yyyy-MM-dd"));
  90         return log4cxx::pattern::DatePatternConverter::newInstance(altOptions);
  91 }
  92
  93 struct tm* localtime_r_(const time_t* timep, struct tm* result) {
  94         ++localtime_rCalled;
  95         localtime_rArg = *timep;
  96         if (localtime_rFail) {
  97                 return 0;
  98         }
  99         return ((struct tm* (*)(const time_t*, struct tm*)) dlsym(RTLD_NEXT, "localtime_r"))(timep, result);
 100 }
 101
 102 bool equalsIgnoreCase_(const LogString& s1, const LogString& upper, const LogString& lower) {
 103         ++equalsIgnoreCaseCalled;
 104         if ("rotationtimingvalue" == lower) return true;
 105         if ("rotationtiming" == lower) return true;
 106         if ("imaxbackupindex" == lower) return true;
 107
 108         return false;
 109 }
 110
 111 void formatFileName_(log4cxx::rolling::RollingPolicyBase* ts, log4cxx::helpers::ObjectPtr& obj, LogString& buf, log4cxx::helpers::Pool& p) {
 112         ++formatFileNameCalled;
 113         formatFileNameArgObj = obj;
 114         buf = formatFileNameArgBuf;
 115 }
 116
 117
 118
 119 time_t time_(time_t* t) {
 120         ++timeCalled;
 121         if (timeReturnNow) {
 122                 return ((time_t (*)(time_t*)) dlsym(RTLD_NEXT, "time"))(t);
 123         }
 124         *t = timeArg;
 125         return timeReturns;
 126 }
 127
 128 size_t strftime_(char* s, size_t max, const char* format, const struct tm* tm) {
 129         ++strftimeCalled;
 130         strftimeArgFormat = format;
 131         if (strftimeFail) {
 132                 return -1;
 133         }
 134         return ((size_t (*)(char*, size_t, const char*, const struct tm*)) dlsym(RTLD_NEXT, "strftime"))(s, max, format, tm);
 135 }
 136
 137 time_t mktime_(struct tm* tm) {
 138         ++mktimeCalled;
 139         if (mktimeFail) {
 140                 return -1;
 141         }
 142         return ((time_t (*)(struct tm*)) dlsym(RTLD_NEXT, "mktime"))(tm);
 143 }
 144
 145 std::vector<LogString> fileList_(log4cxx::File* ts, log4cxx::helpers::Pool& p) {
 146         ++fileListCalled;
 147         return fileListReturns;
 148 }
 149
 150 bool fileDeleteFile_(log4cxx::File* ts, log4cxx::helpers::Pool& p) {
 151         ++fileDeleteFileCalled;
 152         LogString filename = ts->getName();
 153         fileDeleteFiles.push_back(filename);
 154         return true;
 155 }
 156
 157 void fixedPolicySetOption_(log4cxx::rolling::FixedWindowRollingPolicy* ts, const LogString&option, const LogString& value) {
 158         ++fixedPolicySetOptionCalled;
 159         fixedPolicySetOptionArgOption = option;
 160         fixedPolicySetOptionArgValue = value;
 161 }
 162
 163 void fixedPolicyActivateOptions_(log4cxx::rolling::FixedWindowRollingPolicy* ts, log4cxx::helpers::Pool& p) {
 164         ++fixedPolicyActivateOptionsCalled;
 165 }
 166
 167 log4cxx::rolling::RolloverDescriptionPtr fixedPolicyInitialize_(log4cxx::rolling::FixedWindowRollingPolicy* ts, const LogString& file, const bool append, log4cxx::helpers::Pool& p) {
 168         ++fixedPolicyInitializeCalled;
 169         fixedPolicyInitializeArgFile = file;
 170         fixedPolicyInitializeArgAppend = append;
 171         log4cxx::rolling::RolloverDescriptionPtr desc;
 172         return desc;
 173 }
 174
 175 log4cxx::rolling::RolloverDescriptionPtr fixedPolicyRollover_(log4cxx::rolling::FixedWindowRollingPolicy* ts, const LogString& activeFile, log4cxx::helpers::Pool& p) {
 176         ++fixedPolicyRolloverCalled;
 177         fixedPolicyRolloverArgActiveFile = activeFile;
 178         log4cxx::rolling::RolloverDescriptionPtr desc;
 179         return desc;
 180 }
 181
 182 void _ZNK7log4cxx7rolling16TriggeringPolicy6addRefEv(log4cxx::rolling::TriggeringPolicy* ts) __attribute__((weak,alias("triggeringPolicyAddRef_")));
 183
 184 void _ZNK7log4cxx7rolling16TriggeringPolicy10releaseRefEv(log4cxx::rolling::TriggeringPolicy* ts) __attribute__((weak,alias("triggeringPolicyReleaseRef_")));
 185
 186 void _ZN7log4cxx7rolling17RollingPolicyBase20parseFileNamePatternEv(log4cxx::rolling::RollingPolicyBase* ts) __attribute__((weak,alias("parseFileNamePattern_")));
 187
 188 log4cxx::pattern::PatternConverterPtr _ZNK7log4cxx7rolling17RollingPolicyBase23getDatePatternConverterEv(log4cxx::rolling::RollingPolicyBase* ts) __attribute__((weak,alias("getDatePatternConverter_")));
 189
 190 void _ZNK7log4cxx7rolling17RollingPolicyBase14formatFileNameERNS_7helpers10ObjectPtrTINS2_6ObjectEEERSsRNS2_4PoolE(log4cxx::rolling::RollingPolicyBase* ts, log4cxx::helpers::ObjectPtr& obj,LogString& buf, log4cxx::helpers::Pool& p) __attribute__((weak,alias("formatFileName_")));
 191
 192 struct tm* localtime_r(const time_t* timep, struct tm* result) __attribute__((weak,alias("localtime_r_")));
 193
 194 bool _ZN7log4cxx7helpers12StringHelper16equalsIgnoreCaseERKSsS3_S3_(LogString& s1, LogString& upper, LogString& lower) __attribute__((weak,alias("equalsIgnoreCase_")));
 195
 196 time_t time(time_t* t) __attribute__((weak,alias("time_")));
 197
 198 size_t strftime(char* s, size_t max, const char* format, const struct tm* tm) __attribute__((weak,alias("strftime_")));
 199
 200 time_t mktime(struct tm* tm) __attribute__((weak,alias("mktime_")));
 201
 202 std::vector<LogString> _ZNK7log4cxx4File4listERNS_7helpers4PoolE(log4cxx::File* ts, log4cxx::helpers::Pool& p) __attribute__((weak,alias("fileList_")));
 203
 204 bool _ZNK7log4cxx4File10deleteFileERNS_7helpers4PoolE(log4cxx::File* ts, log4cxx::helpers::Pool& p) __attribute__((weak,alias("fileDeleteFile_")));
 205
 206 void _ZN7log4cxx7rolling24FixedWindowRollingPolicy9setOptionERKSsS3_(log4cxx::rolling::FixedWindowRollingPolicy* ts, const LogString& option, const LogString& value) __attribute__((weak,alias("fixedPolicySetOption_")));
 207
 208 void _ZN7log4cxx7rolling24FixedWindowRollingPolicy15activateOptionsERNS_7helpers4PoolE(log4cxx::rolling::FixedWindowRollingPolicy* ts, log4cxx::helpers::Pool& p) __attribute__((weak,alias("fixedPolicyActivateOptions_")));
 209
 210 log4cxx::rolling::RolloverDescriptionPtr _ZN7log4cxx7rolling24FixedWindowRollingPolicy10initializeERKSsbRNS_7helpers4PoolE(log4cxx::rolling::FixedWindowRollingPolicy* ts, const LogString& file, const bool append, log4cxx::helpers::Pool& p) __attribute__((weak,alias("fixedPolicyInitialize_")));
 211
 212 log4cxx::rolling::RolloverDescriptionPtr _ZN7log4cxx7rolling24FixedWindowRollingPolicy8rolloverERKSsRNS_7helpers4PoolE(log4cxx::rolling::FixedWindowRollingPolicy* ts, const LogString& activeFile, log4cxx::helpers::Pool& p) __attribute__((weak,alias("fixedPolicyRollover_")));
 213
 214 }
 215
 216 class TestTimeSizePolicy : public log4cxx::rolling::TimeAndSizeBasedRollingPolicy
 217 {
 218 public:
 219         time_t getNextCheckProperty() { return log4cxx::rolling::StrictTimeBasedRollingPolicy::nextCheck; }
 220         void setNextCheckProperty(time_t val) { log4cxx::rolling::StrictTimeBasedRollingPolicy::nextCheck = val; }
 221         time_t getNextCheck(time_t now_time) { return log4cxx::rolling::StrictTimeBasedRollingPolicy::getNextCheck(now_time); }
 222
 223         log4cxx::pattern::PatternMap getFormatSpecifiers() { return log4cxx::rolling::StrictTimeBasedRollingPolicy::getFormatSpecifiers(); };
 224
 225 };
 226
 227
 228 void time_size_policy_constructor_test()
 229 {
 230         BOOST_MESSAGE( "----- time_size_policy_constructor_test start -----" );
 231
 232         TestTimeSizePolicy p;
 233
 234         //＊nextCheckが初期化されていること
 235         BOOST_CHECK_EQUAL(p.getNextCheckProperty(), 0);
 236
 237         //＊rotationTimingが初期化されているkと
 238         BOOST_CHECK_EQUAL(p.getRotationTiming(), LOG_TIM_YEAR);
 239
 240         //＊rotationTimingValueが初期化されていること
 241         BOOST_CHECK_EQUAL(p.getRotationTimingValue(), "");
 242
 243         //＊maxFileSizeが初期化されていること
 244         BOOST_CHECK_EQUAL(p.getMaxFileSize(), (unsigned long long)DEFAULT_MAX_FILE_SIZE);
 245
 246         BOOST_MESSAGE( "----- time_size_policy_constructor_test end -----" );
 247
 248 }
 249
 250
 251 void time_size_policy_addref_test()
 252 {
 253         BOOST_MESSAGE( "----- time_size_policy_addref_test start -----" );
 254
 255         TestTimeSizePolicy p;
 256
 257         //＊triggerinPolicyのaddrefを呼んでいること
 258         triggeringPolicyAddRefCalled = 0;
 259         p.addRef();
 260         BOOST_CHECK_EQUAL(triggeringPolicyAddRefCalled, 1);
 261
 262         BOOST_MESSAGE( "----- time_size_policy_addref_test end -----" );
 263 }
 264
 265 void time_size_policy_releaseref_test()
 266 {
 267         BOOST_MESSAGE( "----- time_size_policy_releaseref_test start -----" );
 268
 269         TestTimeSizePolicy p;
 270
 271         //＊triggeringPolicyのreleaserefを呼んでいること
 272         triggeringPolicyReleaseRefCalled = 0;
 273         p.releaseRef();
 274         BOOST_CHECK_EQUAL(triggeringPolicyReleaseRefCalled, 1);
 275
 276
 277         BOOST_MESSAGE( "----- time_size_policy_releaseref_test end -----" );
 278 }
 279
 280 void time_size_policy_activateoptions_test()
 281 {
 282         BOOST_MESSAGE( "----- time_size_policy_activateoptions_test start -----" );
 283
 284         TestTimeSizePolicy p;
 285         log4cxx::helpers::Pool pool;
 286 #define DATE_PATTERN "test.log.%d{%Y-%m-%d_%H-%M}"
 287
 288         //＊rotationTimingValueが設定されていなかった時にIlligalStateExceptionを投げること
 289         p.setFileNamePattern(DATE_PATTERN);
 290         p.setRotationTimingValue("");
 291         BOOST_CHECK_THROW(p.activateOptions(pool), log4cxx::helpers::IllegalStateException);
 292
 293         //＊FixedRollingPolicyのactivateOptionsを呼んでいること
 294         fixedPolicyActivateOptionsCalled = 0;
 295         p.setRotationTimingValue("02111615");
 296         p.activateOptions(pool);
 297         BOOST_CHECK_EQUAL(fixedPolicyActivateOptionsCalled, 1);
 298
 299
 300         BOOST_MESSAGE( "----- time_size_policy_activateoptions_test end -----" );
 301 }
 302
 303 void time_size_policy_get_rotation_timing_value_test()
 304 {
 305         BOOST_MESSAGE( "----- time_size_policy_get_rotation_timing_value_test start -----" );
 306         TestTimeSizePolicy p;
 307
 308         //＊設定されているrotationTimingValueを取得すること
 309         p.setRotationTimingValue("2020");
 310         BOOST_CHECK_EQUAL(p.getRotationTimingValue(), "2020");
 311
 312         BOOST_MESSAGE( "----- time_size_policy_get_rotation_timing_value_test end -----" );
 313 }
 314
 315 void time_size_policy_set_rotation_timing_value_test()
 316 {
 317         BOOST_MESSAGE( "----- time_size_policy_set_rotation_timing_value_test start -----" );
 318         TestTimeSizePolicy p;
 319
 320         //＊rotationTimingValueを設定すること
 321         p.setRotationTimingValue("12311152");
 322         BOOST_CHECK_EQUAL(p.getRotationTimingValue(), "12311152");
 323
 324
 325         BOOST_MESSAGE( "----- time_size_policy_set_rotation_timing_value_test end -----" );
 326 }
 327
 328 void time_size_policy_get_rotation_timing_test()
 329 {
 330         BOOST_MESSAGE( "----- time_size_policy_get_rotation_timing_test start -----" );
 331         TestTimeSizePolicy p;
 332
 333         //＊設定されているrotationTimingを取得すること
 334         p.setRotationTiming(LOG_TIM_MONTH);
 335         BOOST_CHECK_EQUAL(p.getRotationTiming(), LOG_TIM_MONTH);
 336
 337
 338         BOOST_MESSAGE( "----- time_size_policy_get_rotation_timing_test end -----" );
 339 }
 340
 341 void time_size_policy_set_rotation_timing_test()
 342 {
 343         BOOST_MESSAGE( "----- time_size_policy_set_rotation_timing_test start -----" );
 344         TestTimeSizePolicy p;
 345
 346         //＊rotationTimingを設定すること
 347         p.setRotationTiming(LOG_TIM_HOUR);
 348         BOOST_CHECK_EQUAL(p.getRotationTiming(), LOG_TIM_HOUR);
 349
 350
 351         BOOST_MESSAGE( "----- time_size_policy_set_rotation_timing_test end -----" );
 352 }
 353
 354 void time_size_policy_get_max_file_size_test()
 355 {
 356         BOOST_MESSAGE( "----- time_size_policy_get_max_file_size_test start -----" );
 357         TestTimeSizePolicy p;
 358
 359         //＊設定されているmaxFileSizeを取得すること
 360         p.setMaxFileSize(12345);
 361         BOOST_CHECK_EQUAL(p.getMaxFileSize(), 12345U);
 362
 363
 364         BOOST_MESSAGE( "----- time_size_policy_get_max_file_size_test end -----" );
 365 }
 366
 367 void time_size_policy_set_max_file_size_test()
 368 {
 369         BOOST_MESSAGE( "----- time_size_policy_set_max_file_size_test start -----" );
 370         TestTimeSizePolicy p;
 371
 372         //＊maxFileSizeを設定すること
 373         p.setMaxFileSize(564565);
 374         BOOST_CHECK_EQUAL(p.getMaxFileSize(), 564565U);
 375
 376
 377         BOOST_MESSAGE( "----- time_size_policy_set_max_file_size_test end -----" );
 378 }
 379
 380 void time_size_policy_set_option_test()
 381 {
 382         BOOST_MESSAGE( "----- time_size_policy_set_option_test start -----" );
 383         TestTimeSizePolicy p;
 384
 385         //＊rotationTimingを設定すること
 386         p.setRotationTimingValue("");
 387         p.setOption("rotationtimingvalue", "05050101");
 388         BOOST_CHECK_EQUAL(p.getRotationTimingValue(), "05050101");
 389
 390         //＊rotationTimingValueを設定すること
 391         p.setRotationTiming(LOG_TIM_YEAR);
 392         p.setOption("rotationtiming", "1");
 393         BOOST_CHECK_EQUAL(p.getRotationTiming(), LOG_TIM_MONTH);
 394
 395         //＊FixedWindowRollingPolicyのsetOptionを呼んでいること
 396         p.setMaxIndex(0);
 397         fixedPolicySetOptionCalled = 0;
 398         fixedPolicySetOptionArgOption = "";
 399         fixedPolicySetOptionArgValue = "";
 400         p.setOption("maxindex", "123");
 401         BOOST_CHECK_EQUAL(fixedPolicySetOptionCalled, 1);
 402         BOOST_CHECK_EQUAL(fixedPolicySetOptionArgOption, "maxindex");
 403         BOOST_CHECK_EQUAL(fixedPolicySetOptionArgValue, "123");
 404
 405         //＊maxFileSizeを設定すること
 406         p.setMaxFileSize(0);
 407         p.setOption("maxfilesize", "55555");
 408         BOOST_CHECK_EQUAL(p.getMaxFileSize(), 55555U);
 409
 410         BOOST_MESSAGE( "----- time_size_policy_set_option_index_test end -----" );
 411 }
 412
 413 void time_size_policy_initialize_test()
 414 {
 415         BOOST_MESSAGE( "----- time_size_policy_initialize_test start -----" );
 416         TestTimeSizePolicy p;
 417         log4cxx::helpers::Pool pool;
 418
 419         log4cxx::rolling::RolloverDescriptionPtr ret;
 420
 421 #define CURRENT_ACTIVE_FILE "test_current_active_file"
 422
 423         //＊timeを呼び出していること
 424         timeCalled = 0;
 425         p.setRotationTiming(LOG_TIM_YEAR);
 426         p.setRotationTimingValue("02111615");
 427         ret = p.initialize(CURRENT_ACTIVE_FILE, true, pool);
 428         BOOST_CHECK_EQUAL(timeCalled, 1);
 429         BOOST_CHECK_EQUAL(ret, (log4cxx::rolling::RolloverDescriptionPtr)0);
 430
 431         //＊timeが失敗した時に空のRolloverDescriptionが帰ってくること
 432         timeCalled = 0;
 433         timeReturnNow = false;
 434         timeReturns = -1;
 435         p.setRotationTiming(LOG_TIM_YEAR);
 436         p.setRotationTimingValue("02111615");
 437         ret = p.initialize(CURRENT_ACTIVE_FILE, true, pool);
 438         BOOST_CHECK_EQUAL(timeCalled, 1);
 439         BOOST_CHECK_EQUAL(ret, (log4cxx::rolling::RolloverDescriptionPtr)0);
 440         timeReturnNow = true;
 441         timeReturns = 0;
 442
 443         //＊getNextCheckを呼び出していること(nextCheckが変更されていること)
 444         struct tm test_time;
 445         memset(&test_time, 0, sizeof(struct tm));
 446         test_time.tm_year = 108;
 447         test_time.tm_mon = 1;
 448         test_time.tm_mday = 12;
 449         test_time.tm_hour = 16;
 450         test_time.tm_min = 4;
 451         time_t test_now = mktime(&test_time);
 452         test_time.tm_year = 109;
 453         test_time.tm_mon = 0;
 454         test_time.tm_mday = 15;
 455         test_time.tm_hour = 12;
 456         test_time.tm_min = 0;
 457         time_t test_next = mktime(&test_time);
 458         timeReturnNow = false;
 459         timeArg = test_now;
 460         p.setRotationTiming(LOG_TIM_YEAR);
 461         p.setRotationTimingValue("01151200");
 462         p.setNextCheckProperty(0);
 463         ret = p.initialize(CURRENT_ACTIVE_FILE, true, pool);
 464         BOOST_CHECK_EQUAL(ret, (log4cxx::rolling::RolloverDescriptionPtr)0);
 465         BOOST_CHECK_EQUAL(p.getNextCheckProperty(), test_next);
 466         timeReturnNow = true;
 467         timeArg = 0;
 468
 469         //＊getNextCheckが失敗した時に空のRolloverDescriptionが帰ってくること
 470         p.setRotationTiming(LOG_TIM_YEAR);
 471         p.setRotationTimingValue("AAAAAA");
 472         ret = p.initialize(CURRENT_ACTIVE_FILE, true, pool);
 473         BOOST_CHECK_EQUAL(ret, (log4cxx::rolling::RolloverDescriptionPtr)0);
 474
 475         //＊FixedWindowRollingPolicyのinitializeを呼んでいること
 476         fixedPolicyInitializeCalled = 0;
 477         fixedPolicyInitializeArgFile = "";
 478         fixedPolicyInitializeArgAppend = false;
 479         p.setRotationTiming(LOG_TIM_YEAR);
 480         p.setRotationTimingValue("02111615");
 481         ret = p.initialize(CURRENT_ACTIVE_FILE, true, pool);
 482         BOOST_CHECK_EQUAL(fixedPolicyInitializeCalled, 1);
 483         BOOST_CHECK_EQUAL(ret, (log4cxx::rolling::RolloverDescriptionPtr)0);
 484         BOOST_CHECK_EQUAL(fixedPolicyInitializeArgFile, CURRENT_ACTIVE_FILE);
 485         BOOST_CHECK_EQUAL(fixedPolicyInitializeArgAppend, true);
 486
 487 #undef CURRENT_ACTIVE_FILE
 488
 489         BOOST_MESSAGE( "----- time_size_policy_initialize_test end -----" );
 490 }
 491
 492 void time_size_policy_get_next_check_test()
 493 {
 494         BOOST_MESSAGE( "----- time_size_policy_get_next_check_test start -----" );
 495         TestTimeSizePolicy p;
 496
 497         time_t nc_ret;
 498         struct tm nc_time;
 499         struct tm test_time;
 500         memset(&test_time, 0, sizeof(struct tm));
 501         time_t test_now = 0;
 502
 503         //＊localtime_rを呼び出していること
 504         test_time.tm_year = 108;
 505         test_time.tm_mon = 1;
 506         test_time.tm_mday = 12;
 507         test_time.tm_hour = 16;
 508         test_time.tm_min = 4;
 509         test_now = mktime(&test_time);
 510         p.setRotationTiming(LOG_TIM_YEAR);
 511         p.setRotationTimingValue("01151200");
 512         localtime_rCalled = 0;
 513         nc_ret = p.getNextCheck(test_now);
 514         BOOST_CHECK(!(nc_ret == -1));
 515         BOOST_CHECK_EQUAL(localtime_rCalled, 1);
 516
 517         //＊localtime_rが失敗した時に-1を返すこと
 518         test_time.tm_year = 108;
 519         test_time.tm_mon = 1;
 520         test_time.tm_mday = 12;
 521         test_time.tm_hour = 16;
 522         test_time.tm_min = 4;
 523         test_now = mktime(&test_time);
 524         p.setRotationTiming(LOG_TIM_YEAR);
 525         p.setRotationTimingValue("01151200");
 526         localtime_rFail = true;
 527         nc_ret = p.getNextCheck(test_now);
 528         BOOST_CHECK(nc_ret == -1);
 529         localtime_rFail = false;
 530
 531         //＊strftimeをLOG_DATE_FORMATを引数に呼び出していること
 532         test_time.tm_year = 108;
 533         test_time.tm_mon = 1;
 534         test_time.tm_mday = 12;
 535         test_time.tm_hour = 16;
 536         test_time.tm_min = 4;
 537         test_now = mktime(&test_time);
 538         p.setRotationTiming(LOG_TIM_YEAR);
 539         p.setRotationTimingValue("01151200");
 540         strftimeCalled = 0;
 541         strftimeArgFormat = "";
 542         nc_ret = p.getNextCheck(test_now);
 543         BOOST_CHECK(!(nc_ret == -1));
 544         BOOST_CHECK_EQUAL(strftimeCalled, 1);
 545         BOOST_CHECK_EQUAL(strftimeArgFormat.c_str(), LOG_DATE_FORMAT);
 546
 547         //＊strftimeが失敗したときに-1を返すこと
 548         test_time.tm_year = 108;
 549         test_time.tm_mon = 1;
 550         test_time.tm_mday = 12;
 551         test_time.tm_hour = 16;
 552         test_time.tm_min = 4;
 553         test_now = mktime(&test_time);
 554         p.setRotationTiming(LOG_TIM_YEAR);
 555         p.setRotationTimingValue("01151200");
 556         strftimeFail = true;
 557         nc_ret = p.getNextCheck(test_now);
 558         BOOST_CHECK(nc_ret == -1);
 559         strftimeFail = false;
 560
 561         //＊rotationTimingValueに不正な値が入っていた場合、-1を返すこと 年
 562         test_time.tm_year = 108;
 563         test_time.tm_mon = 1;
 564         test_time.tm_mday = 12;
 565         test_time.tm_hour = 16;
 566         test_time.tm_min = 4;
 567         test_now = mktime(&test_time);
 568         p.setRotationTiming(LOG_TIM_YEAR);
 569         p.setRotationTimingValue("AAAAAA");
 570         nc_ret = p.getNextCheck(test_now);
 571         BOOST_CHECK(nc_ret == -1);
 572
 573         //＊mktimeを呼び出している事　年
 574         test_time.tm_year = 108;
 575         test_time.tm_mon = 1;
 576         test_time.tm_mday = 12;
 577         test_time.tm_hour = 16;
 578         test_time.tm_min = 4;
 579         test_now = mktime(&test_time);
 580         p.setRotationTiming(LOG_TIM_YEAR);
 581         p.setRotationTimingValue("01151200");
 582         mktimeCalled = 0;
 583         nc_ret = p.getNextCheck(test_now);
 584         BOOST_CHECK(!(nc_ret == -1));
 585         BOOST_CHECK_EQUAL(mktimeCalled, 1);
 586
 587         //＊mktimeが失敗した時 -1を返すこと　年
 588         test_time.tm_year = 108;
 589         test_time.tm_mon = 1;
 590         test_time.tm_mday = 12;
 591         test_time.tm_hour = 16;
 592         test_time.tm_min = 4;
 593         test_now = mktime(&test_time);
 594         p.setRotationTiming(LOG_TIM_YEAR);
 595         p.setRotationTimingValue("01151200");
 596         mktimeFail = true;
 597         nc_ret = p.getNextCheck(test_now);
 598         BOOST_CHECK(nc_ret == -1);
 599         mktimeFail = false;
 600
 601         //＊nextCheckを取得すること　年　設定日時が未来の場合
 602         test_time.tm_year = 108;
 603         test_time.tm_mon = 1;
 604         test_time.tm_mday = 12;
 605         test_time.tm_hour = 16;
 606         test_time.tm_min = 4;
 607         test_now = mktime(&test_time);          //2008/02/12 16:04
 608         p.setRotationTiming(LOG_TIM_YEAR);
 609         p.setRotationTimingValue("03100945");   //03/10 09:45
 610         nc_ret = p.getNextCheck(test_now);
 611         BOOST_CHECK(!(nc_ret == -1));
 612         localtime_r(&nc_ret, &nc_time);         //2008/03/10 09:45
 613         BOOST_CHECK_EQUAL(nc_time.tm_year, 108);
 614         BOOST_CHECK_EQUAL(nc_time.tm_mon, 2);
 615         BOOST_CHECK_EQUAL(nc_time.tm_mday, 10);
 616         BOOST_CHECK_EQUAL(nc_time.tm_hour, 9);
 617         BOOST_CHECK_EQUAL(nc_time.tm_min, 45);
 618
 619         //＊nextCheckを取得すること　年　設定日時が現在の場合(来年に設定)
 620         test_time.tm_year = 108;
 621         test_time.tm_mon = 1;
 622         test_time.tm_mday = 12;
 623         test_time.tm_hour = 16;
 624         test_time.tm_min = 4;
 625         test_now = mktime(&test_time);          //2008/02/12 16:04
 626         p.setRotationTiming(LOG_TIM_YEAR);
 627         p.setRotationTimingValue("02121604");   //02/12 16:04
 628         nc_ret = p.getNextCheck(test_now);
 629         BOOST_CHECK(!(nc_ret == -1));
 630         localtime_r(&nc_ret, &nc_time);         //2009/02/12 16:04
 631         BOOST_CHECK_EQUAL(nc_time.tm_year, 109);
 632         BOOST_CHECK_EQUAL(nc_time.tm_mon, 1);
 633         BOOST_CHECK_EQUAL(nc_time.tm_mday, 12);
 634         BOOST_CHECK_EQUAL(nc_time.tm_hour, 16);
 635         BOOST_CHECK_EQUAL(nc_time.tm_min, 4);
 636
 637         //＊nextCheckを取得すること　年　設定日時が過去の場合(来年に設定)
 638         test_time.tm_year = 108;
 639         test_time.tm_mon = 1;
 640         test_time.tm_mday = 12;
 641         test_time.tm_hour = 16;
 642         test_time.tm_min = 4;
 643         test_now = mktime(&test_time);          //2008/02/12 16:04
 644         p.setRotationTiming(LOG_TIM_YEAR);
 645         p.setRotationTimingValue("01151500");   //01/15 15:00
 646         nc_ret = p.getNextCheck(test_now);
 647         BOOST_CHECK(!(nc_ret == -1));
 648         localtime_r(&nc_ret, &nc_time);         //2009/01/15 15:00
 649         BOOST_CHECK_EQUAL(nc_time.tm_year, 109);
 650         BOOST_CHECK_EQUAL(nc_time.tm_mon, 0);
 651         BOOST_CHECK_EQUAL(nc_time.tm_mday, 15);
 652         BOOST_CHECK_EQUAL(nc_time.tm_hour, 15);
 653         BOOST_CHECK_EQUAL(nc_time.tm_min, 0);
 654
 655
 656
 657         //＊rotationTimingValueに不正な値が入っていた場合、-1を返すこと 月
 658         test_time.tm_year = 108;
 659         test_time.tm_mon = 1;
 660         test_time.tm_mday = 12;
 661         test_time.tm_hour = 16;
 662         test_time.tm_min = 4;
 663         test_now = mktime(&test_time);
 664         p.setRotationTiming(LOG_TIM_MONTH);
 665         p.setRotationTimingValue("ZZZZZ");
 666         nc_ret = p.getNextCheck(test_now);
 667         BOOST_CHECK(nc_ret == -1);
 668
 669         //＊mktimeを呼び出している事　月
 670         test_time.tm_year = 108;
 671         test_time.tm_mon = 1;
 672         test_time.tm_mday = 12;
 673         test_time.tm_hour = 16;
 674         test_time.tm_min = 4;
 675         test_now = mktime(&test_time);
 676         p.setRotationTiming(LOG_TIM_MONTH);
 677         p.setRotationTimingValue("151200");
 678         mktimeCalled = 0;
 679         nc_ret = p.getNextCheck(test_now);
 680         BOOST_CHECK(!(nc_ret == -1));
 681         BOOST_CHECK_EQUAL(mktimeCalled, 1);
 682
 683         //＊mktimeが失敗した時 -1を返すこと　月
 684         test_time.tm_year = 108;
 685         test_time.tm_mon = 1;
 686         test_time.tm_mday = 12;
 687         test_time.tm_hour = 16;
 688         test_time.tm_min = 4;
 689         test_now = mktime(&test_time);
 690         p.setRotationTiming(LOG_TIM_MONTH);
 691         p.setRotationTimingValue("151200");
 692         mktimeFail = true;
 693         nc_ret = p.getNextCheck(test_now);
 694         BOOST_CHECK(nc_ret == -1);
 695         mktimeFail = false;
 696
 697         //＊nextCheckを取得すること　月　設定日時が未来の場合
 698         test_time.tm_year = 108;
 699         test_time.tm_mon = 11;
 700         test_time.tm_mday = 15;
 701         test_time.tm_hour = 1;
 702         test_time.tm_min = 5;
 703         test_now = mktime(&test_time);          //2008/12/15 01:05
 704         p.setRotationTiming(LOG_TIM_MONTH);
 705         p.setRotationTimingValue("200945");     //20 09:45
 706         nc_ret = p.getNextCheck(test_now);
 707         BOOST_CHECK(!(nc_ret == -1));
 708         localtime_r(&nc_ret, &nc_time);         //2008/12/20 09:45
 709         BOOST_CHECK_EQUAL(nc_time.tm_year, 108);
 710         BOOST_CHECK_EQUAL(nc_time.tm_mon, 11);
 711         BOOST_CHECK_EQUAL(nc_time.tm_mday, 20);
 712         BOOST_CHECK_EQUAL(nc_time.tm_hour, 9);
 713         BOOST_CHECK_EQUAL(nc_time.tm_min, 45);
 714
 715         //＊設定日付が存在しない日の場合、存在する日に修正すること
 716         test_time.tm_year = 108;
 717         test_time.tm_mon = 1;
 718         test_time.tm_mday = 15;
 719         test_time.tm_hour = 14;
 720         test_time.tm_min = 30;
 721         test_now = mktime(&test_time);          //2008/02/15 14:30
 722         p.setRotationTiming(LOG_TIM_MONTH);
 723         p.setRotationTimingValue("310945");     //31 09:45
 724         nc_ret = p.getNextCheck(test_now);
 725         BOOST_CHECK(!(nc_ret == -1));
 726         localtime_r(&nc_ret, &nc_time);         //2008/02/28 09:45
 727         BOOST_CHECK_EQUAL(nc_time.tm_year, 108);
 728         BOOST_CHECK_EQUAL(nc_time.tm_mon, 1);
 729         BOOST_CHECK_EQUAL(nc_time.tm_mday, 28);
 730         BOOST_CHECK_EQUAL(nc_time.tm_hour, 9);
 731         BOOST_CHECK_EQUAL(nc_time.tm_min, 45);
 732
 733         //＊nextCheckを取得すること　月　設定日時が現在の場合(来月に設定)
 734         test_time.tm_year = 108;
 735         test_time.tm_mon = 11;
 736         test_time.tm_mday = 15;
 737         test_time.tm_hour = 1;
 738         test_time.tm_min = 5;
 739         test_now = mktime(&test_time);          //2008/12/15 01:05
 740         p.setRotationTiming(LOG_TIM_MONTH);
 741         p.setRotationTimingValue("150105");     //15 01:05
 742         nc_ret = p.getNextCheck(test_now);
 743         BOOST_CHECK(!(nc_ret == -1));
 744         localtime_r(&nc_ret, &nc_time);         //2009/01/15 01:05
 745         BOOST_CHECK_EQUAL(nc_time.tm_year, 109);
 746         BOOST_CHECK_EQUAL(nc_time.tm_mon, 0);
 747         BOOST_CHECK_EQUAL(nc_time.tm_mday, 15);
 748         BOOST_CHECK_EQUAL(nc_time.tm_hour, 1);
 749         BOOST_CHECK_EQUAL(nc_time.tm_min, 5);
 750
 751         //＊設定日付が存在しない日の場合、存在する日に修正すること
 752         test_time.tm_year = 108;
 753         test_time.tm_mon = 9;
 754         test_time.tm_mday = 31;
 755         test_time.tm_hour = 14;
 756         test_time.tm_min = 30;
 757         test_now = mktime(&test_time);          //2008/10/31 14:30
 758         p.setRotationTiming(LOG_TIM_MONTH);
 759         p.setRotationTimingValue("311430");     //31 14:30
 760         nc_ret = p.getNextCheck(test_now);
 761         BOOST_CHECK(!(nc_ret == -1));
 762         localtime_r(&nc_ret, &nc_time);         //2008/11/30 14:30
 763         BOOST_CHECK_EQUAL(nc_time.tm_year, 108);
 764         BOOST_CHECK_EQUAL(nc_time.tm_mon, 10);
 765         BOOST_CHECK_EQUAL(nc_time.tm_mday, 30);
 766         BOOST_CHECK_EQUAL(nc_time.tm_hour, 14);
 767         BOOST_CHECK_EQUAL(nc_time.tm_min, 30);
 768
 769         //＊nextCheckを取得すること　月　設定日時が過去の場合(来月に設定)
 770         test_time.tm_year = 108;
 771         test_time.tm_mon = 11;
 772         test_time.tm_mday = 15;
 773         test_time.tm_hour = 1;
 774         test_time.tm_min = 5;
 775         test_now = mktime(&test_time);          //2008/12/15 01:05
 776         p.setRotationTiming(LOG_TIM_MONTH);
 777         p.setRotationTimingValue("101200");     //10 12:00
 778         nc_ret = p.getNextCheck(test_now);
 779         BOOST_CHECK(!(nc_ret == -1));
 780         localtime_r(&nc_ret, &nc_time);         //2009/01/15 01:05
 781         BOOST_CHECK_EQUAL(nc_time.tm_year, 109);
 782         BOOST_CHECK_EQUAL(nc_time.tm_mon, 0);
 783         BOOST_CHECK_EQUAL(nc_time.tm_mday, 10);
 784         BOOST_CHECK_EQUAL(nc_time.tm_hour, 12);
 785         BOOST_CHECK_EQUAL(nc_time.tm_min, 0);
 786
 787         //＊設定日付が存在しない日の場合、存在する日に修正すること
 788         test_time.tm_year = 108;
 789         test_time.tm_mon = 2;
 790         test_time.tm_mday = 31;
 791         test_time.tm_hour = 14;
 792         test_time.tm_min = 0;
 793         test_now = mktime(&test_time);          //2008/03/31 14:00
 794         p.setRotationTiming(LOG_TIM_MONTH);
 795         p.setRotationTimingValue("311200");     //31 12:00
 796         nc_ret = p.getNextCheck(test_now);
 797         BOOST_CHECK(!(nc_ret == -1));
 798         localtime_r(&nc_ret, &nc_time);         //2008/04/30 12:00
 799         BOOST_CHECK_EQUAL(nc_time.tm_year, 108);
 800         BOOST_CHECK_EQUAL(nc_time.tm_mon, 3);
 801         BOOST_CHECK_EQUAL(nc_time.tm_mday, 30);
 802         BOOST_CHECK_EQUAL(nc_time.tm_hour, 12);
 803         BOOST_CHECK_EQUAL(nc_time.tm_min, 0);
 804
 805
 806
 807         //＊rotationTimingValueに不正な値が入っていた場合、-1を返すこと 週
 808         test_time.tm_year = 108;
 809         test_time.tm_mon = 1;
 810         test_time.tm_mday = 12;
 811         test_time.tm_hour = 16;
 812         test_time.tm_min = 4;
 813         test_now = mktime(&test_time);
 814         p.setRotationTiming(LOG_TIM_WEEK);
 815         p.setRotationTimingValue("ZZZZZ");
 816         nc_ret = p.getNextCheck(test_now);
 817         BOOST_CHECK(nc_ret == -1);
 818
 819         //＊mktimeを呼び出している事　週
 820         test_time.tm_year = 108;
 821         test_time.tm_mon = 1;
 822         test_time.tm_mday = 12;
 823         test_time.tm_hour = 16;
 824         test_time.tm_min = 4;
 825         test_now = mktime(&test_time);
 826         p.setRotationTiming(LOG_TIM_WEEK);
 827         p.setRotationTimingValue("51200");
 828         mktimeCalled = 0;
 829         nc_ret = p.getNextCheck(test_now);
 830         BOOST_CHECK(!(nc_ret == -1));
 831         BOOST_CHECK_EQUAL(mktimeCalled, 1);
 832
 833         //＊mktimeが失敗した時 -1を返すこと　週
 834         test_time.tm_year = 108;
 835         test_time.tm_mon = 1;
 836         test_time.tm_mday = 12;
 837         test_time.tm_hour = 16;
 838         test_time.tm_min = 4;
 839         test_now = mktime(&test_time);
 840         p.setRotationTiming(LOG_TIM_WEEK);
 841         p.setRotationTimingValue("51200");
 842         mktimeFail = true;
 843         nc_ret = p.getNextCheck(test_now);
 844         BOOST_CHECK(nc_ret == -1);
 845         mktimeFail = false;
 846
 847         //＊nextCheckを取得すること　週　設定日時が未来の場合
 848         test_time.tm_year = 108;
 849         test_time.tm_mon = 1;
 850         test_time.tm_mday = 13;
 851         test_time.tm_hour = 1;
 852         test_time.tm_min = 0;
 853         test_now = mktime(&test_time);          //2008/02/13 01:00(水)
 854         p.setRotationTiming(LOG_TIM_WEEK);
 855         p.setRotationTimingValue("41200");      //(木) 12:00
 856         nc_ret = p.getNextCheck(test_now);
 857         BOOST_CHECK(!(nc_ret == -1));
 858         localtime_r(&nc_ret, &nc_time);         //2008/02/14 12:00(木)
 859         BOOST_CHECK_EQUAL(nc_time.tm_year, 108);
 860         BOOST_CHECK_EQUAL(nc_time.tm_mon, 1);
 861         BOOST_CHECK_EQUAL(nc_time.tm_mday, 14);
 862         BOOST_CHECK_EQUAL(nc_time.tm_hour, 12);
 863         BOOST_CHECK_EQUAL(nc_time.tm_min, 0);
 864
 865         //＊nextCheckを取得すること　週　設定日時が現在の場合(翌週に設定)
 866         test_time.tm_year = 108;
 867         test_time.tm_mon = 1;
 868         test_time.tm_mday = 13;
 869         test_time.tm_hour = 1;
 870         test_time.tm_min = 0;
 871         test_now = mktime(&test_time);          //2008/02/13 01:00(水)
 872         p.setRotationTiming(LOG_TIM_WEEK);
 873         p.setRotationTimingValue("30100");      //(水) 1:00
 874         nc_ret = p.getNextCheck(test_now);
 875         BOOST_CHECK(!(nc_ret == -1));
 876         localtime_r(&nc_ret, &nc_time);         //2008/02/20 01:00(水)
 877         BOOST_CHECK_EQUAL(nc_time.tm_year, 108);
 878         BOOST_CHECK_EQUAL(nc_time.tm_mon, 1);
 879         BOOST_CHECK_EQUAL(nc_time.tm_mday, 20);
 880         BOOST_CHECK_EQUAL(nc_time.tm_hour, 1);
 881         BOOST_CHECK_EQUAL(nc_time.tm_min, 0);
 882
 883         //＊nextCheckを取得すること　月　設定日時が過去の場合(翌週に設定)
 884         test_time.tm_year = 108;
 885         test_time.tm_mon = 1;
 886         test_time.tm_mday = 13;
 887         test_time.tm_hour = 1;
 888         test_time.tm_min = 0;
 889         test_now = mktime(&test_time);          //2008/02/13 01:00(水)
 890         p.setRotationTiming(LOG_TIM_WEEK);
 891         p.setRotationTimingValue("20500");      //(火) 5:00
 892         nc_ret = p.getNextCheck(test_now);
 893         BOOST_CHECK(!(nc_ret == -1));
 894         localtime_r(&nc_ret, &nc_time);         //2008/02/19 01:00(火)
 895         BOOST_CHECK_EQUAL(nc_time.tm_year, 108);
 896         BOOST_CHECK_EQUAL(nc_time.tm_mon, 1);
 897         BOOST_CHECK_EQUAL(nc_time.tm_mday, 19);
 898         BOOST_CHECK_EQUAL(nc_time.tm_hour, 5);
 899         BOOST_CHECK_EQUAL(nc_time.tm_min, 0);
 900
 901
 902         //＊rotationTimingValueに不正な値が入っていた場合、-1を返すこと 日
 903         test_time.tm_year = 108;
 904         test_time.tm_mon = 1;
 905         test_time.tm_mday = 12;
 906         test_time.tm_hour = 16;
 907         test_time.tm_min = 4;
 908         test_now = mktime(&test_time);
 909         p.setRotationTiming(LOG_TIM_DATE);
 910         p.setRotationTimingValue("NNNN");
 911         nc_ret = p.getNextCheck(test_now);
 912         BOOST_CHECK(nc_ret == -1);
 913
 914         //＊mktimeを呼び出している事　日
 915         test_time.tm_year = 108;
 916         test_time.tm_mon = 1;
 917         test_time.tm_mday = 12;
 918         test_time.tm_hour = 16;
 919         test_time.tm_min = 4;
 920         test_now = mktime(&test_time);
 921         p.setRotationTiming(LOG_TIM_DATE);
 922         p.setRotationTimingValue("1200");
 923         mktimeCalled = 0;
 924         nc_ret = p.getNextCheck(test_now);
 925         BOOST_CHECK(!(nc_ret == -1));
 926         BOOST_CHECK_EQUAL(mktimeCalled, 1);
 927
 928         //＊mktimeが失敗した時 -1を返すこと　日
 929         test_time.tm_year = 108;
 930         test_time.tm_mon = 1;
 931         test_time.tm_mday = 12;
 932         test_time.tm_hour = 16;
 933         test_time.tm_min = 4;
 934         test_now = mktime(&test_time);
 935         p.setRotationTiming(LOG_TIM_DATE);
 936         p.setRotationTimingValue("1200");
 937         mktimeFail = true;
 938         nc_ret = p.getNextCheck(test_now);
 939         BOOST_CHECK(nc_ret == -1);
 940         mktimeFail = false;
 941
 942         //＊nextCheckを取得すること　日　設定日時が未来の場合
 943         test_time.tm_year = 108;
 944         test_time.tm_mon = 1;
 945         test_time.tm_mday = 13;
 946         test_time.tm_hour = 1;
 947         test_time.tm_min = 0;
 948         test_now = mktime(&test_time);          //2008/02/13 01:00
 949         p.setRotationTiming(LOG_TIM_DATE);
 950         p.setRotationTimingValue("2359");       //23:59
 951         nc_ret = p.getNextCheck(test_now);
 952         BOOST_CHECK(!(nc_ret == -1));
 953         localtime_r(&nc_ret, &nc_time);         //2008/02/13 23:59
 954         BOOST_CHECK_EQUAL(nc_time.tm_year, 108);
 955         BOOST_CHECK_EQUAL(nc_time.tm_mon, 1);
 956         BOOST_CHECK_EQUAL(nc_time.tm_mday, 13);
 957         BOOST_CHECK_EQUAL(nc_time.tm_hour, 23);
 958         BOOST_CHECK_EQUAL(nc_time.tm_min, 59);
 959
 960         //＊nextCheckを取得すること　日　設定日時が現在の場合(翌日に設定)
 961         test_time.tm_year = 108;
 962         test_time.tm_mon = 1;
 963         test_time.tm_mday = 13;
 964         test_time.tm_hour = 1;
 965         test_time.tm_min = 0;
 966         test_now = mktime(&test_time);          //2008/02/13 01:00
 967         p.setRotationTiming(LOG_TIM_DATE);
 968         p.setRotationTimingValue("0100");       //01:00
 969         nc_ret = p.getNextCheck(test_now);
 970         BOOST_CHECK(!(nc_ret == -1));
 971         localtime_r(&nc_ret, &nc_time);         //2008/02/14 01:00
 972         BOOST_CHECK_EQUAL(nc_time.tm_year, 108);
 973         BOOST_CHECK_EQUAL(nc_time.tm_mon, 1);
 974         BOOST_CHECK_EQUAL(nc_time.tm_mday, 14);
 975         BOOST_CHECK_EQUAL(nc_time.tm_hour, 1);
 976         BOOST_CHECK_EQUAL(nc_time.tm_min, 0);
 977
 978         //＊nextCheckを取得すること　日　設定日時が過去の場合(翌日に設定)
 979         test_time.tm_year = 108;
 980         test_time.tm_mon = 1;
 981         test_time.tm_mday = 13;
 982         test_time.tm_hour = 1;
 983         test_time.tm_min = 0;
 984         test_now = mktime(&test_time);          //2008/02/13 01:00
 985         p.setRotationTiming(LOG_TIM_DATE);
 986         p.setRotationTimingValue("0000");       //00:00
 987         nc_ret = p.getNextCheck(test_now);
 988         BOOST_CHECK(!(nc_ret == -1));
 989         localtime_r(&nc_ret, &nc_time);         //2008/02/14 00:00
 990         BOOST_CHECK_EQUAL(nc_time.tm_year, 108);
 991         BOOST_CHECK_EQUAL(nc_time.tm_mon, 1);
 992         BOOST_CHECK_EQUAL(nc_time.tm_mday, 14);
 993         BOOST_CHECK_EQUAL(nc_time.tm_hour, 0);
 994         BOOST_CHECK_EQUAL(nc_time.tm_min, 0);
 995
 996
 997
 998         //＊rotationTimingValueに不正な値が入っていた場合、-1を返すこと 日
 999         test_time.tm_year = 108;
1000         test_time.tm_mon = 1;
1001         test_time.tm_mday = 12;
1002         test_time.tm_hour = 16;
1003         test_time.tm_min = 4;
1004         test_now = mktime(&test_time);
1005         p.setRotationTiming(LOG_TIM_HOUR);
1006         p.setRotationTimingValue("SS");
1007         nc_ret = p.getNextCheck(test_now);
1008         BOOST_CHECK(nc_ret == -1);
1009
1010         //＊mktimeを呼び出している事　日
1011         test_time.tm_year = 108;
1012         test_time.tm_mon = 1;
1013         test_time.tm_mday = 12;
1014         test_time.tm_hour = 16;
1015         test_time.tm_min = 4;
1016         test_now = mktime(&test_time);
1017         p.setRotationTiming(LOG_TIM_HOUR);
1018         p.setRotationTimingValue("15");
1019         mktimeCalled = 0;
1020         nc_ret = p.getNextCheck(test_now);
1021         BOOST_CHECK(!(nc_ret == -1));
1022         BOOST_CHECK_EQUAL(mktimeCalled, 1);
1023
1024         //＊mktimeが失敗した時 -1を返すこと　日
1025         test_time.tm_year = 108;
1026         test_time.tm_mon = 1;
1027         test_time.tm_mday = 12;
1028         test_time.tm_hour = 16;
1029         test_time.tm_min = 4;
1030         test_now = mktime(&test_time);
1031         p.setRotationTiming(LOG_TIM_HOUR);
1032         p.setRotationTimingValue("15");
1033         mktimeFail = true;
1034         nc_ret = p.getNextCheck(test_now);
1035         BOOST_CHECK(nc_ret == -1);
1036         mktimeFail = false;
1037
1038         //＊nextCheckを取得すること　時間　設定日時が未来の場合
1039         test_time.tm_year = 108;
1040         test_time.tm_mon = 1;
1041         test_time.tm_mday = 13;
1042         test_time.tm_hour = 1;
1043         test_time.tm_min = 15;
1044         test_now = mktime(&test_time);          //2008/02/13 01:15
1045         p.setRotationTiming(LOG_TIM_HOUR);
1046         p.setRotationTimingValue("30");         //30
1047         nc_ret = p.getNextCheck(test_now);
1048         BOOST_CHECK(!(nc_ret == -1));
1049         localtime_r(&nc_ret, &nc_time);         //2008/02/13 01:30
1050         BOOST_CHECK_EQUAL(nc_time.tm_year, 108);
1051         BOOST_CHECK_EQUAL(nc_time.tm_mon, 1);
1052         BOOST_CHECK_EQUAL(nc_time.tm_mday, 13);
1053         BOOST_CHECK_EQUAL(nc_time.tm_hour, 1);
1054         BOOST_CHECK_EQUAL(nc_time.tm_min, 30);
1055
1056         //＊nextCheckを取得すること　時間　設定日時が現在の場合(次の時間に設定)
1057         test_time.tm_year = 108;
1058         test_time.tm_mon = 1;
1059         test_time.tm_mday = 13;
1060         test_time.tm_hour = 1;
1061         test_time.tm_min = 15;
1062         test_now = mktime(&test_time);          //2008/02/13 01:15
1063         p.setRotationTiming(LOG_TIM_HOUR);
1064         p.setRotationTimingValue("15");         //15
1065         nc_ret = p.getNextCheck(test_now);
1066         BOOST_CHECK(!(nc_ret == -1));
1067         localtime_r(&nc_ret, &nc_time);         //2008/02/13 02:15
1068         BOOST_CHECK_EQUAL(nc_time.tm_year, 108);
1069         BOOST_CHECK_EQUAL(nc_time.tm_mon, 1);
1070         BOOST_CHECK_EQUAL(nc_time.tm_mday, 13);
1071         BOOST_CHECK_EQUAL(nc_time.tm_hour, 2);
1072         BOOST_CHECK_EQUAL(nc_time.tm_min, 15);
1073
1074         //＊nextCheckを取得すること　時間　設定日時が過去の場合(次の時間に設定)
1075         test_time.tm_year = 108;
1076         test_time.tm_mon = 3;
1077         test_time.tm_mday = 30;
1078         test_time.tm_hour = 23;
1079         test_time.tm_min = 45;
1080         test_now = mktime(&test_time);          //2008/04/30 23:45
1081         p.setRotationTiming(LOG_TIM_HOUR);
1082         p.setRotationTimingValue("30");         //30
1083         nc_ret = p.getNextCheck(test_now);
1084         BOOST_CHECK(!(nc_ret == -1));
1085         localtime_r(&nc_ret, &nc_time);         //2008/05/01 00:30
1086         BOOST_CHECK_EQUAL(nc_time.tm_year, 108);
1087         BOOST_CHECK_EQUAL(nc_time.tm_mon, 4);
1088         BOOST_CHECK_EQUAL(nc_time.tm_mday, 1);
1089         BOOST_CHECK_EQUAL(nc_time.tm_hour, 0);
1090         BOOST_CHECK_EQUAL(nc_time.tm_min, 30);
1091
1092
1093         BOOST_MESSAGE( "----- time_size_policy_set_next_check_test end -----" );
1094 }
1095
1096 void time_size_policy_rollover_test()
1097 {
1098         BOOST_MESSAGE( "----- time_size_policy_rollover_test start -----" );
1099         TestTimeSizePolicy p;
1100         log4cxx::helpers::Pool pool;
1101         log4cxx::rolling::RolloverDescriptionPtr ret;
1102
1103 #define TEST_FILE_NAME "test_file_name"
1104 #define CURRENT_ACTIVE_FILE "current_active_file"
1105         //＊timeを呼び出していること
1106         timeCalled = 0;
1107         formatFileNameArgBuf = TEST_FILE_NAME;
1108         p.setRotationTiming(LOG_TIM_YEAR);
1109         p.setRotationTimingValue("02111615");
1110         ret = p.rollover(CURRENT_ACTIVE_FILE, pool);
1111         BOOST_CHECK_EQUAL(timeCalled, 1);
1112         BOOST_CHECK_EQUAL(ret, (log4cxx::rolling::RolloverDescriptionPtr)0);
1113
1114         //＊timeが失敗した時に空のRolloverDescriptionが帰ってくること
1115         timeCalled = 0;
1116         timeReturnNow = false;
1117         timeReturns = -1;
1118         formatFileNameArgBuf = TEST_FILE_NAME;
1119         p.setRotationTiming(LOG_TIM_YEAR);
1120         p.setRotationTimingValue("02111615");
1121         ret = p.rollover(CURRENT_ACTIVE_FILE, pool);
1122         BOOST_CHECK_EQUAL(timeCalled, 1);
1123         BOOST_CHECK_EQUAL(ret, (log4cxx::rolling::RolloverDescriptionPtr)0);
1124         timeReturnNow = true;
1125         timeReturns = 0;
1126
1127         //＊getNextCheckを呼び出していること(nextCheckが変更されていること)
1128         struct tm test_time;
1129         memset(&test_time, 0, sizeof(struct tm));
1130         test_time.tm_year = 108;
1131         test_time.tm_mon = 1;
1132         test_time.tm_mday = 12;
1133         test_time.tm_hour = 16;
1134         test_time.tm_min = 4;
1135         time_t test_now = mktime(&test_time);
1136         test_time.tm_year = 109;
1137         test_time.tm_mon = 0;
1138         test_time.tm_mday = 15;
1139         test_time.tm_hour = 12;
1140         test_time.tm_min = 0;
1141         time_t test_next = mktime(&test_time);
1142         timeReturnNow = false;
1143         timeArg = test_now;
1144         p.setRotationTiming(LOG_TIM_YEAR);
1145         p.setRotationTimingValue("01151200");
1146         p.setNextCheckProperty(0);
1147         ret = p.rollover(CURRENT_ACTIVE_FILE, pool);
1148         BOOST_CHECK_EQUAL(ret, (log4cxx::rolling::RolloverDescriptionPtr)0);
1149         BOOST_CHECK_EQUAL(p.getNextCheckProperty(), test_next);
1150         timeReturnNow = true;
1151         timeArg = 0;
1152
1153         //＊getNextCheckが失敗した時に空のRolloverDescriptionが帰ってくること
1154         p.setRotationTiming(LOG_TIM_YEAR);
1155         p.setRotationTimingValue("AAAAAA");
1156         ret = p.rollover(CURRENT_ACTIVE_FILE, pool);
1157         BOOST_CHECK_EQUAL(ret, (log4cxx::rolling::RolloverDescriptionPtr)0);
1158
1159         //＊FixedWindowRollingPolicyのrolloverを呼んでいること
1160         fixedPolicyRolloverCalled = 0;
1161         fixedPolicyRolloverArgActiveFile = "";
1162         p.setRotationTiming(LOG_TIM_YEAR);
1163         p.setRotationTimingValue("02111615");
1164         ret = p.rollover(CURRENT_ACTIVE_FILE, pool);
1165         BOOST_CHECK_EQUAL(fixedPolicyRolloverCalled, 1);
1166         BOOST_CHECK_EQUAL(fixedPolicyRolloverArgActiveFile, CURRENT_ACTIVE_FILE);
1167         BOOST_CHECK_EQUAL(ret, (log4cxx::rolling::RolloverDescriptionPtr)0);
1168 #undef CURRENT_ACTIVE_FILE
1169 #undef TEST_FILE_NAME
1170
1171         BOOST_MESSAGE( "----- time_size_policy_rollover_test end -----" );
1172 }
1173
1174 void time_size_policy_is_triggering_event_test()
1175 {
1176         BOOST_MESSAGE( "----- time_size_policy_is_triggering_event_test start -----" );
1177         TestTimeSizePolicy p;
1178
1179         bool ret;
1180         log4cxx::AppenderPtr argAppender;
1181         log4cxx::spi::LoggingEventPtr argEvent;
1182         LogString filename;
1183         size_t filelength = 50000;
1184
1185         //filelengthがmaxFileSizeに満たない場合
1186
1187         //＊timeを呼び出していること
1188         timeCalled = 0;
1189         timeReturnNow = false;
1190         timeArg = 10;
1191         p.setNextCheckProperty(5);
1192         p.setMaxFileSize(100000);
1193         ret = p.isTriggeringEvent(argAppender, argEvent, filename, filelength);
1194         BOOST_CHECK_EQUAL(timeCalled, 1);
1195         BOOST_CHECK_EQUAL(ret, true);
1196         timeArg = 0;
1197         timeReturnNow = true;
1198
1199         //＊timeが失敗した時に空のRolloverDescriptionが帰ってくること
1200         timeCalled = 0;
1201         timeReturnNow = false;
1202         timeReturns = -1;
1203         p.setNextCheckProperty(5);
1204         p.setMaxFileSize(100000);
1205         ret = p.isTriggeringEvent(argAppender, argEvent, filename, filelength);
1206         BOOST_CHECK_EQUAL(timeCalled, 1);
1207         BOOST_CHECK_EQUAL(ret, false);
1208         timeReturnNow = true;
1209         timeReturns = 0;
1210
1211         //＊timeで取得した時間とnextCheckを比較してtimeで取得した時間が大きい時にtrueを返却すること
1212         timeCalled = 0;
1213         timeReturnNow = false;
1214         timeArg = 10;
1215         p.setNextCheckProperty(5);
1216         p.setMaxFileSize(100000);
1217         ret = p.isTriggeringEvent(argAppender, argEvent, filename, filelength);
1218         BOOST_CHECK_EQUAL(timeCalled, 1);
1219         BOOST_CHECK_EQUAL(ret, true);
1220         timeArg = 0;
1221         timeReturnNow = true;
1222
1223         //＊nextCheckが大きい時にfalseを返すこと
1224         timeCalled = 0;
1225         timeReturnNow = false;
1226         timeArg = 5;
1227         p.setNextCheckProperty(10);
1228         p.setMaxFileSize(100000);
1229         ret = p.isTriggeringEvent(argAppender, argEvent, filename, filelength);
1230         BOOST_CHECK_EQUAL(timeCalled, 1);
1231         BOOST_CHECK_EQUAL(ret, false);
1232         timeArg = 0;
1233         timeReturnNow = true;
1234
1235
1236         //filelengthがmaxFileSizeに以上の場合
1237         filelength = 200000;
1238
1239         //＊timeを呼び出していないこと
1240         timeCalled = 0;
1241         timeReturnNow = false;
1242         timeArg = 10;
1243         p.setNextCheckProperty(5);
1244         p.setMaxFileSize(100000);
1245         ret = p.isTriggeringEvent(argAppender, argEvent, filename, filelength);
1246         BOOST_CHECK_EQUAL(timeCalled, 0);
1247         BOOST_CHECK_EQUAL(ret, true);
1248         timeArg = 0;
1249         timeReturnNow = true;
1250
1251         //＊timeで取得した時間とnextCheckを比較してtimeで取得した時間が大きい時かつ、ファイルサイズも超えている時ににtrueを返却すること
1252         timeCalled = 0;
1253         timeReturnNow = false;
1254         timeArg = 10;
1255         p.setNextCheckProperty(5);
1256         p.setMaxFileSize(100000);
1257         ret = p.isTriggeringEvent(argAppender, argEvent, filename, filelength);
1258         BOOST_CHECK_EQUAL(timeCalled, 0);
1259         BOOST_CHECK_EQUAL(ret, true);
1260         timeArg = 0;
1261         timeReturnNow = true;
1262
1263         //＊nextCheckが大きい時でもファイルサイズが超えていたらtrueを返すこと
1264         timeCalled = 0;
1265         timeReturnNow = false;
1266         timeArg = 5;
1267         p.setNextCheckProperty(10);
1268         p.setMaxFileSize(100000);
1269         ret = p.isTriggeringEvent(argAppender, argEvent, filename, filelength);
1270         BOOST_CHECK_EQUAL(timeCalled, 0);
1271         BOOST_CHECK_EQUAL(ret, true);
1272         timeArg = 0;
1273         timeReturnNow = true;
1274
1275
1276
1277         BOOST_MESSAGE( "----- time_size_policy_is_triggering_event_test end -----" );
1278 }
1279
1280 test_suite*
1281 init_unit_test_suite(int argc, char* argv[])
1282 {
1283         test_suite* test = BOOST_TEST_SUITE("logger_test");
1284
1285         test->add(BOOST_TEST_CASE(time_size_policy_constructor_test));
1286         test->add(BOOST_TEST_CASE(time_size_policy_addref_test));
1287         test->add(BOOST_TEST_CASE(time_size_policy_releaseref_test));
1288         test->add(BOOST_TEST_CASE(time_size_policy_activateoptions_test));
1289         test->add(BOOST_TEST_CASE(time_size_policy_get_rotation_timing_value_test));
1290         test->add(BOOST_TEST_CASE(time_size_policy_set_rotation_timing_value_test));
1291         test->add(BOOST_TEST_CASE(time_size_policy_get_rotation_timing_test));
1292         test->add(BOOST_TEST_CASE(time_size_policy_set_rotation_timing_test));
1293         test->add(BOOST_TEST_CASE(time_size_policy_get_max_file_size_test));
1294         test->add(BOOST_TEST_CASE(time_size_policy_set_max_file_size_test));
1295         test->add(BOOST_TEST_CASE(time_size_policy_set_option_test));
1296         test->add(BOOST_TEST_CASE(time_size_policy_initialize_test));
1297         test->add(BOOST_TEST_CASE(time_size_policy_get_next_check_test));
1298         test->add(BOOST_TEST_CASE(time_size_policy_rollover_test));
1299         test->add(BOOST_TEST_CASE(time_size_policy_is_triggering_event_test));
1300
1301         return test;
1302 };
1303