cacheddateformattestcase.cpp

log4cxx 0.10 unix下编译包

   apr_time_exp_t c;
   memset(&c, 0, sizeof(c));
   c.tm_year = 104;
   c.tm_mon = 11;
   c.tm_mday = 12;
   c.tm_hour = 19;
   c.tm_sec = 37;
   c.tm_usec = 23000;

   apr_time_t dec12;
   apr_status_t stat = apr_time_exp_gmt_get(&dec12, &c);
   const apr_status_t statOK = 0;
   LOGUNIT_ASSERT_EQUAL(statOK, stat);

   Pool p;

   LogString s;
   cachedFormat->format(s, dec12, p);

   LOGUNIT_ASSERT_EQUAL(
       (LogString) LOG4CXX_STR("2004-December-12 20:00:37,23 +0100"), s);

    memset(&c, 0, sizeof(c));
    c.tm_year = 104;
    c.tm_mon = 11;
    c.tm_mday = 31;
    c.tm_hour = 23;
    c.tm_sec = 13;
    c.tm_usec = 905000;

    apr_time_t jan1;
    stat = apr_time_exp_gmt_get(&jan1, &c);
    LOGUNIT_ASSERT_EQUAL(statOK, stat);

    s.erase(s.begin(), s.end());
    cachedFormat->format(s, jan1, p);

    LOGUNIT_ASSERT_EQUAL(
       (LogString) LOG4CXX_STR("2005-January-01 00:00:13,905 +0100"), s);
}


/**
 * Test when millisecond position moves but length remains constant.
 */
void test10() {
#if LOG4CXX_HAS_STD_LOCALE
  std::locale loco("C");
  std::locale* localeUS = &loco;
#else
  std::locale* localeUS = NULL;
#endif
  DateFormatPtr baseFormat = new SimpleDateFormat(
      LOG4CXX_STR("MMMM SSS EEEEEE"), localeUS);
  DateFormatPtr cachedFormat = new CachedDateFormat(baseFormat, 1000000);
  TimeZonePtr cet = TimeZone::getTimeZone(LOG4CXX_STR("GMT+1"));
  cachedFormat->setTimeZone(cet);

  apr_time_exp_t c;
  memset(&c, 0, sizeof(c));
  c.tm_year = 104;
  c.tm_mon = 9;
  c.tm_mday = 5;
  c.tm_hour = 21;
  c.tm_sec = 37;
  c.tm_usec = 23000;

  apr_time_t oct5;
  apr_status_t stat = apr_time_exp_gmt_get(&oct5, &c);
  const apr_status_t statOK = 0;
  LOGUNIT_ASSERT_EQUAL(statOK, stat);

  Pool p;

  LogString s;
  cachedFormat->format(s, oct5, p);

  LOGUNIT_ASSERT_EQUAL(
    (LogString) LOG4CXX_STR("October 023 Tuesday"), s);

  memset(&c, 0, sizeof(c));
  c.tm_year = 104;
  c.tm_mon = 10;
  c.tm_mday = 1;
  c.tm_usec = 23000;

  apr_time_t nov1;
  stat = apr_time_exp_gmt_get(&nov1, &c);
  LOGUNIT_ASSERT_EQUAL(statOK, stat);

  s.erase(s.begin(), s.end());
  cachedFormat->format(s, nov1, p);

  LOGUNIT_ASSERT_EQUAL(
     (LogString) LOG4CXX_STR("November 023 Monday"), s);

   nov1 += 961000;
   s.erase(s.begin(), s.end());
   cachedFormat->format(s, nov1, p);

   LOGUNIT_ASSERT_EQUAL(
      (LogString) LOG4CXX_STR("November 984 Monday"), s);
}

/**
 * Test that tests if caching is skipped if only "SS"
 *     is specified.
 */
void test11() {
   //
   //   Earlier versions could be tricked by "SS0" patterns.
   //
   LogString badPattern(LOG4CXX_STR("ss,SS0"));
   DateFormatPtr simpleFormat = new SimpleDateFormat(badPattern);
   DateFormatPtr gmtFormat = new CachedDateFormat(simpleFormat, 1000000);
   gmtFormat->setTimeZone(TimeZone::getGMT());

   //
   // The first request has to 100 ms after an ordinal second
   //    to push the literal zero out of the pattern check
   apr_time_t ticks = MICROSECONDS_PER_DAY * 11142L;
   apr_time_t jul2 = ticks + 120000;

   Pool p;

   LogString s;
   gmtFormat->format(s, jul2, p);

   LOGUNIT_ASSERT_EQUAL(
      (LogString) LOG4CXX_STR("00,1200"), s);

   jul2 = ticks + 87000;

   s.erase(s.begin(), s.end());
   gmtFormat->format(s, jul2, p);

   LOGUNIT_ASSERT_EQUAL(
      (LogString) LOG4CXX_STR("00,870"), s);
}

/**
 * Check pattern location for ISO8601
 */
void test12() {
   DateFormatPtr df = new SimpleDateFormat(LOG4CXX_STR("yyyy-MM-dd HH:mm:ss,SSS"));
   apr_time_t ticks = 11142L * MICROSECONDS_PER_DAY;

   Pool p;

   LogString formatted;
   df->format(formatted, ticks, p);

   int millisecondStart = CachedDateFormat::findMillisecondStart(ticks,
       formatted, df, p);
   LOGUNIT_ASSERT_EQUAL(20, millisecondStart);
}

/**
 * Check pattern location for DATE
 */
void test13() {
   DateFormatPtr df = new SimpleDateFormat(LOG4CXX_STR("yyyy-MM-dd"));
   apr_time_t ticks = 11142L * MICROSECONDS_PER_DAY;

   Pool p;

   LogString formatted;
   df->format(formatted, ticks, p);

   int millisecondStart = CachedDateFormat::findMillisecondStart(ticks,
       formatted, df, p);
   LOGUNIT_ASSERT_EQUAL((int) CachedDateFormat::NO_MILLISECONDS, millisecondStart);
}

/**
 * Check pattern location for ABSOLUTE
 */
void test14() {
   DateFormatPtr df = new SimpleDateFormat(LOG4CXX_STR("HH:mm:ss,SSS"));
   apr_time_t ticks = 11142L * MICROSECONDS_PER_DAY;

   Pool p;
   LogString formatted;
   df->format(formatted, ticks, p);

   int millisecondStart = CachedDateFormat::findMillisecondStart(ticks,
      formatted, df, p);
   LOGUNIT_ASSERT_EQUAL(9, millisecondStart);
}

/**
 * Check pattern location for single S
 */
void test15() {
   DateFormatPtr df = new SimpleDateFormat(LOG4CXX_STR("HH:mm:ss,S"));
   apr_time_t ticks = 11142L * MICROSECONDS_PER_DAY;

   Pool p;
   LogString formatted;
   df->format(formatted, ticks, p);

   int millisecondStart = CachedDateFormat::findMillisecondStart(ticks,
      formatted, df, p);
   LOGUNIT_ASSERT_EQUAL((int) CachedDateFormat::UNRECOGNIZED_MILLISECONDS, millisecondStart);
}

/**
 * Check pattern location for single SS
 */
void test16() {
   DateFormatPtr df = new SimpleDateFormat(LOG4CXX_STR("HH:mm:ss,SS"));
   apr_time_t ticks = 11142L * MICROSECONDS_PER_DAY;

   Pool p;
   LogString formatted;
   df->format(formatted, ticks, p);

   int millisecondStart =
      CachedDateFormat::findMillisecondStart(ticks, formatted, df, p);
   LOGUNIT_ASSERT_EQUAL((int) CachedDateFormat::UNRECOGNIZED_MILLISECONDS, millisecondStart);
}


/**
 * Check caching when multiple SSS appear in pattern
 */
void test17() {
    apr_time_t jul2 = 12602L * MICROSECONDS_PER_DAY;
    LogString badPattern(LOG4CXX_STR("HH:mm:ss,SSS HH:mm:ss,SSS"));
    DateFormatPtr simpleFormat = new SimpleDateFormat(badPattern);
    simpleFormat->setTimeZone(TimeZone::getGMT());
    DateFormatPtr cachedFormat = new CachedDateFormat(simpleFormat, 1000000);

    Pool p;
    LogString s;
    cachedFormat->format(s, jul2, p);

    LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:00,000 00:00:00,000"), s);
    jul2 += 120000;

    s.erase(s.begin(), s.end());
    simpleFormat->format(s, jul2, p);
    LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:00,120 00:00:00,120"), s);

    s.erase(s.begin(), s.end());
    cachedFormat->format(s, jul2, p);

    LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:00,120 00:00:00,120"), s) ;

    int maxValid = CachedDateFormat::getMaximumCacheValidity(badPattern);
    LOGUNIT_ASSERT_EQUAL(1000, maxValid);
}

/**
 * Check that patterns not containing microseconds
 * are reported as being able to be cached for a full second.
 */
void test18() {

    int maxValid =
       CachedDateFormat::getMaximumCacheValidity(
          LOG4CXX_STR("yyyy-MM-dd"));
    LOGUNIT_ASSERT_EQUAL(1000000, maxValid);
}

/**
 * Check that patterns not containing 3 microseconds
 * are reported as being able to be cached for a full second.
 */
void test19() {

    int maxValid =
       CachedDateFormat::getMaximumCacheValidity(
          LOG4CXX_STR("yyyy-MM-dd SSS"));
    LOGUNIT_ASSERT_EQUAL(1000000, maxValid);
}

/**
 * Check that patterns not containing 2 S's
 * are reported as being able to be cached for only a millisecond.
 */
void test20() {

    int maxValid =
       CachedDateFormat::getMaximumCacheValidity(
          LOG4CXX_STR("yyyy-MM-dd SS"));
    LOGUNIT_ASSERT_EQUAL(1000, maxValid);
}

/**
 * Check that patterns not containing multi S groups
 * are reported as being able to be cached for only a millisecond.
 */
void test21() {

    int maxValid =
       CachedDateFormat::getMaximumCacheValidity(
          LOG4CXX_STR("yyyy-MM-dd SSS SSS"));
    LOGUNIT_ASSERT_EQUAL(1000, maxValid);
}

};


LOGUNIT_TEST_SUITE_REGISTRATION(CachedDateFormatTestCase);