tests/datetime/datetime.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        tests/datetime/datetime.cpp
   3 // Purpose:     wxDateTime unit test
   4 // Author:      Vadim Zeitlin
   5 // Created:     2004-06-23 (extracted from samples/console/console.cpp)
   6 // RCS-ID:      $Id$
   7 // Copyright:   (c) 2004 Vadim Zeitlin <vadim@wxwindows.org>
   8 ///////////////////////////////////////////////////////////////////////////////
   9
  10 // ----------------------------------------------------------------------------
  11 // headers
  12 // ----------------------------------------------------------------------------
  13
  14 #include "wx/wxprec.h"
  15
  16 #ifdef __BORLANDC__
  17     #pragma hdrstop
  18 #endif
  19
  20 #ifndef WX_PRECOMP
  21 #endif // WX_PRECOMP
  22
  23 #include "wx/datetime.h"
  24
  25 #include "wx/cppunit.h"
  26
  27 // ----------------------------------------------------------------------------
  28 // broken down date representation used for testing
  29 // ----------------------------------------------------------------------------
  30
  31 struct Date
  32 {
  33     wxDateTime::wxDateTime_t day;
  34     wxDateTime::Month month;
  35     int year;
  36     wxDateTime::wxDateTime_t hour, min, sec;
  37     double jdn;
  38     wxDateTime::WeekDay wday;
  39     time_t gmticks, ticks;
  40
  41     void Init(const wxDateTime::Tm& tm)
  42     {
  43         day = tm.mday;
  44         month = tm.mon;
  45         year = tm.year;
  46         hour = tm.hour;
  47         min = tm.min;
  48         sec = tm.sec;
  49         jdn = 0.0;
  50         gmticks = ticks = -1;
  51     }
  52
  53     wxDateTime DT() const
  54         { return wxDateTime(day, month, year, hour, min, sec); }
  55
  56     bool SameDay(const wxDateTime::Tm& tm) const
  57     {
  58         return day == tm.mday && month == tm.mon && year == tm.year;
  59     }
  60
  61     wxString Format() const
  62     {
  63         wxString s;
  64         s.Printf(_T("%02d:%02d:%02d %10s %02d, %4d%s"),
  65                  hour, min, sec,
  66                  wxDateTime::GetMonthName(month).c_str(),
  67                  day,
  68                  abs(wxDateTime::ConvertYearToBC(year)),
  69                  year > 0 ? _T("AD") : _T("BC"));
  70         return s;
  71     }
  72
  73     wxString FormatDate() const
  74     {
  75         wxString s;
  76         s.Printf(_T("%02d-%s-%4d%s"),
  77                  day,
  78                  wxDateTime::GetMonthName(month, wxDateTime::Name_Abbr).c_str(),
  79                  abs(wxDateTime::ConvertYearToBC(year)),
  80                  year > 0 ? _T("AD") : _T("BC"));
  81         return s;
  82     }
  83 };
  84
  85 // ----------------------------------------------------------------------------
  86 // test data
  87 // ----------------------------------------------------------------------------
  88
  89 static const Date testDates[] =
  90 {
  91     {  1, wxDateTime::Jan,  1970, 00, 00, 00, 2440587.5, wxDateTime::Thu,         0,     -3600 },
  92     {  7, wxDateTime::Feb,  2036, 00, 00, 00, 2464730.5, wxDateTime::Thu,        -1,        -1 },
  93     {  8, wxDateTime::Feb,  2036, 00, 00, 00, 2464731.5, wxDateTime::Fri,        -1,        -1 },
  94     {  1, wxDateTime::Jan,  2037, 00, 00, 00, 2465059.5, wxDateTime::Thu,        -1,        -1 },
  95     {  1, wxDateTime::Jan,  2038, 00, 00, 00, 2465424.5, wxDateTime::Fri,        -1,        -1 },
  96     { 21, wxDateTime::Jan,  2222, 00, 00, 00, 2532648.5, wxDateTime::Mon,        -1,        -1 },
  97     { 29, wxDateTime::May,  1976, 12, 00, 00, 2442928.0, wxDateTime::Sat, 202219200, 202212000 },
  98     { 29, wxDateTime::Feb,  1976, 00, 00, 00, 2442837.5, wxDateTime::Sun, 194400000, 194396400 },
  99     {  1, wxDateTime::Jan,  1900, 12, 00, 00, 2415021.0, wxDateTime::Mon,        -1,        -1 },
 100     {  1, wxDateTime::Jan,  1900, 00, 00, 00, 2415020.5, wxDateTime::Mon,        -1,        -1 },
 101     { 15, wxDateTime::Oct,  1582, 00, 00, 00, 2299160.5, wxDateTime::Fri,        -1,        -1 },
 102     {  4, wxDateTime::Oct,  1582, 00, 00, 00, 2299149.5, wxDateTime::Mon,        -1,        -1 },
 103     {  1, wxDateTime::Mar,     1, 00, 00, 00, 1721484.5, wxDateTime::Thu,        -1,        -1 },
 104     {  1, wxDateTime::Jan,     1, 00, 00, 00, 1721425.5, wxDateTime::Mon,        -1,        -1 },
 105     { 31, wxDateTime::Dec,     0, 00, 00, 00, 1721424.5, wxDateTime::Sun,        -1,        -1 },
 106     {  1, wxDateTime::Jan,     0, 00, 00, 00, 1721059.5, wxDateTime::Sat,        -1,        -1 },
 107     { 12, wxDateTime::Aug, -1234, 00, 00, 00, 1270573.5, wxDateTime::Fri,        -1,        -1 },
 108     { 12, wxDateTime::Aug, -4000, 00, 00, 00,  260313.5, wxDateTime::Sat,        -1,        -1 },
 109     { 24, wxDateTime::Nov, -4713, 00, 00, 00,      -0.5, wxDateTime::Mon,        -1,        -1 },
 110 };
 111
 112
 113 // ----------------------------------------------------------------------------
 114 // test class
 115 // ----------------------------------------------------------------------------
 116
 117 class DateTimeTestCase : public CppUnit::TestCase
 118 {
 119 public:
 120     DateTimeTestCase() { }
 121
 122 private:
 123     CPPUNIT_TEST_SUITE( DateTimeTestCase );
 124         CPPUNIT_TEST( TestLeapYears );
 125         CPPUNIT_TEST( TestTimeSet );
 126         CPPUNIT_TEST( TestTimeJDN );
 127         CPPUNIT_TEST( TestTimeWNumber );
 128         CPPUNIT_TEST( TestTimeWDays );
 129         CPPUNIT_TEST( TestTimeDST );
 130         CPPUNIT_TEST( TestTimeFormat );
 131         CPPUNIT_TEST( TestTimeTicks );
 132         CPPUNIT_TEST( TestTimeParse );
 133         CPPUNIT_TEST( TestTimeArithmetics );
 134     CPPUNIT_TEST_SUITE_END();
 135
 136     void TestLeapYears();
 137     void TestTimeSet();
 138     void TestTimeJDN();
 139     void TestTimeWNumber();
 140     void TestTimeWDays();
 141     void TestTimeDST();
 142     void TestTimeFormat();
 143     void TestTimeTicks();
 144     void TestTimeParse();
 145     void TestTimeArithmetics();
 146
 147     DECLARE_NO_COPY_CLASS(DateTimeTestCase)
 148 };
 149
 150 // register in the unnamed registry so that these tests are run by default
 151 CPPUNIT_TEST_SUITE_REGISTRATION( DateTimeTestCase );
 152
 153 // also include in it's own registry so that these tests can be run alone
 154 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( DateTimeTestCase, "DateTimeTestCase" );
 155
 156 // ============================================================================
 157 // implementation
 158 // ============================================================================
 159
 160 // test leap years detection
 161 void DateTimeTestCase::TestLeapYears()
 162 {
 163     static const struct LeapYearTestData
 164     {
 165         int year;
 166         bool isLeap;
 167     } years[] =
 168     {
 169         { 1900, false },
 170         { 1990, false },
 171         { 1976, true },
 172         { 2000, true },
 173         { 2030, false },
 174         { 1984, true },
 175         { 2100, false },
 176         { 2400, true },
 177     };
 178
 179     for ( size_t n = 0; n < WXSIZEOF(years); n++ )
 180     {
 181         const LeapYearTestData& y = years[n];
 182
 183         CPPUNIT_ASSERT( wxDateTime::IsLeapYear(y.year) == y.isLeap );
 184     }
 185 }
 186
 187 // test constructing wxDateTime objects
 188 void DateTimeTestCase::TestTimeSet()
 189 {
 190     for ( size_t n = 0; n < WXSIZEOF(testDates); n++ )
 191     {
 192         const Date& d1 = testDates[n];
 193         wxDateTime dt = d1.DT();
 194
 195         Date d2;
 196         d2.Init(dt.GetTm());
 197
 198         wxString s1 = d1.Format(),
 199                  s2 = d2.Format();
 200
 201         CPPUNIT_ASSERT( s1 == s2 );
 202     }
 203 }
 204
 205 // test conversions to JDN &c
 206 void DateTimeTestCase::TestTimeJDN()
 207 {
 208     for ( size_t n = 0; n < WXSIZEOF(testDates); n++ )
 209     {
 210         const Date& d = testDates[n];
 211         wxDateTime dt(d.day, d.month, d.year, d.hour, d.min, d.sec);
 212         double jdn = dt.GetJulianDayNumber();
 213
 214         CPPUNIT_ASSERT( jdn == d.jdn );
 215
 216         dt.Set(jdn);
 217         CPPUNIT_ASSERT( dt.GetJulianDayNumber() == jdn );
 218     }
 219 }
 220
 221 // test week days computation
 222 void DateTimeTestCase::TestTimeWDays()
 223 {
 224     // test GetWeekDay()
 225     size_t n;
 226     for ( n = 0; n < WXSIZEOF(testDates); n++ )
 227     {
 228         const Date& d = testDates[n];
 229         wxDateTime dt(d.day, d.month, d.year, d.hour, d.min, d.sec);
 230
 231         wxDateTime::WeekDay wday = dt.GetWeekDay();
 232         CPPUNIT_ASSERT( wday == d.wday );
 233     }
 234
 235     // test SetToWeekDay()
 236     struct WeekDateTestData
 237     {
 238         Date date;                  // the real date (precomputed)
 239         int nWeek;                  // its week index in the month
 240         wxDateTime::WeekDay wday;   // the weekday
 241         wxDateTime::Month month;    // the month
 242         int year;                   // and the year
 243
 244         wxString Format() const
 245         {
 246             wxString s, which;
 247             switch ( nWeek < -1 ? -nWeek : nWeek )
 248             {
 249                 case 1: which = _T("first"); break;
 250                 case 2: which = _T("second"); break;
 251                 case 3: which = _T("third"); break;
 252                 case 4: which = _T("fourth"); break;
 253                 case 5: which = _T("fifth"); break;
 254
 255                 case -1: which = _T("last"); break;
 256             }
 257
 258             if ( nWeek < -1 )
 259             {
 260                 which += _T(" from end");
 261             }
 262
 263             s.Printf(_T("The %s %s of %s in %d"),
 264                      which.c_str(),
 265                      wxDateTime::GetWeekDayName(wday).c_str(),
 266                      wxDateTime::GetMonthName(month).c_str(),
 267                      year);
 268
 269             return s;
 270         }
 271     };
 272
 273     // the array data was generated by the following python program
 274     /*
 275 from DateTime import *
 276 from whrandom import *
 277 from string import *
 278
 279 monthNames = [ 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec' ]
 280 wdayNames = [ 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun' ]
 281
 282 week = DateTimeDelta(7)
 283
 284 for n in range(20):
 285     year = randint(1900, 2100)
 286     month = randint(1, 12)
 287     day = randint(1, 28)
 288     dt = DateTime(year, month, day)
 289     wday = dt.day_of_week
 290
 291     countFromEnd = choice([-1, 1])
 292     weekNum = 0;
 293
 294     while dt.month is month:
 295         dt = dt - countFromEnd * week
 296         weekNum = weekNum + countFromEnd
 297
 298     data = { 'day': rjust(`day`, 2), 'month': monthNames[month - 1], 'year': year, 'weekNum': rjust(`weekNum`, 2), 'wday': wdayNames[wday] }
 299
 300     print "{ { %(day)s, wxDateTime::%(month)s, %(year)d }, %(weekNum)d, "\
 301           "wxDateTime::%(wday)s, wxDateTime::%(month)s, %(year)d }," % data
 302     */
 303
 304     static const WeekDateTestData weekDatesTestData[] =
 305     {
 306         { { 20, wxDateTime::Mar, 2045 },  3, wxDateTime::Mon, wxDateTime::Mar, 2045 },
 307         { {  5, wxDateTime::Jun, 1985 }, -4, wxDateTime::Wed, wxDateTime::Jun, 1985 },
 308         { { 12, wxDateTime::Nov, 1961 }, -3, wxDateTime::Sun, wxDateTime::Nov, 1961 },
 309         { { 27, wxDateTime::Feb, 2093 }, -1, wxDateTime::Fri, wxDateTime::Feb, 2093 },
 310         { {  4, wxDateTime::Jul, 2070 }, -4, wxDateTime::Fri, wxDateTime::Jul, 2070 },
 311         { {  2, wxDateTime::Apr, 1906 }, -5, wxDateTime::Mon, wxDateTime::Apr, 1906 },
 312         { { 19, wxDateTime::Jul, 2023 }, -2, wxDateTime::Wed, wxDateTime::Jul, 2023 },
 313         { {  5, wxDateTime::May, 1958 }, -4, wxDateTime::Mon, wxDateTime::May, 1958 },
 314         { { 11, wxDateTime::Aug, 1900 },  2, wxDateTime::Sat, wxDateTime::Aug, 1900 },
 315         { { 14, wxDateTime::Feb, 1945 },  2, wxDateTime::Wed, wxDateTime::Feb, 1945 },
 316         { { 25, wxDateTime::Jul, 1967 }, -1, wxDateTime::Tue, wxDateTime::Jul, 1967 },
 317         { {  9, wxDateTime::May, 1916 }, -4, wxDateTime::Tue, wxDateTime::May, 1916 },
 318         { { 20, wxDateTime::Jun, 1927 },  3, wxDateTime::Mon, wxDateTime::Jun, 1927 },
 319         { {  2, wxDateTime::Aug, 2000 },  1, wxDateTime::Wed, wxDateTime::Aug, 2000 },
 320         { { 20, wxDateTime::Apr, 2044 },  3, wxDateTime::Wed, wxDateTime::Apr, 2044 },
 321         { { 20, wxDateTime::Feb, 1932 }, -2, wxDateTime::Sat, wxDateTime::Feb, 1932 },
 322         { { 25, wxDateTime::Jul, 2069 },  4, wxDateTime::Thu, wxDateTime::Jul, 2069 },
 323         { {  3, wxDateTime::Apr, 1925 },  1, wxDateTime::Fri, wxDateTime::Apr, 1925 },
 324         { { 21, wxDateTime::Mar, 2093 },  3, wxDateTime::Sat, wxDateTime::Mar, 2093 },
 325         { {  3, wxDateTime::Dec, 2074 }, -5, wxDateTime::Mon, wxDateTime::Dec, 2074 },
 326     };
 327
 328     wxDateTime dt;
 329     for ( n = 0; n < WXSIZEOF(weekDatesTestData); n++ )
 330     {
 331         const WeekDateTestData& wd = weekDatesTestData[n];
 332
 333         dt.SetToWeekDay(wd.wday, wd.nWeek, wd.month, wd.year);
 334
 335         const Date& d = wd.date;
 336         CPPUNIT_ASSERT( d.SameDay(dt.GetTm()) );
 337     }
 338 }
 339
 340 // test the computation of (ISO) week numbers
 341 void DateTimeTestCase::TestTimeWNumber()
 342 {
 343     struct WeekNumberTestData
 344     {
 345         Date date;                          // the date
 346         wxDateTime::wxDateTime_t week;      // the week number in the year
 347         wxDateTime::wxDateTime_t wmon;      // the week number in the month
 348         wxDateTime::wxDateTime_t wmon2;     // same but week starts with Sun
 349         wxDateTime::wxDateTime_t dnum;      // day number in the year
 350     };
 351
 352     // data generated with the following python script:
 353     /*
 354 from DateTime import *
 355 from whrandom import *
 356 from string import *
 357
 358 monthNames = [ 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec' ]
 359 wdayNames = [ 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun' ]
 360
 361 def GetMonthWeek(dt):
 362     weekNumMonth = dt.iso_week[1] - DateTime(dt.year, dt.month, 1).iso_week[1] + 1
 363     if weekNumMonth < 0:
 364         weekNumMonth = weekNumMonth + 53
 365     return weekNumMonth
 366
 367 def GetLastSundayBefore(dt):
 368     if dt.iso_week[2] == 7:
 369         return dt
 370     else:
 371         return dt - DateTimeDelta(dt.iso_week[2])
 372
 373 for n in range(20):
 374     year = randint(1900, 2100)
 375     month = randint(1, 12)
 376     day = randint(1, 28)
 377     dt = DateTime(year, month, day)
 378     dayNum = dt.day_of_year
 379     weekNum = dt.iso_week[1]
 380     weekNumMonth = GetMonthWeek(dt)
 381
 382     weekNumMonth2 = 0
 383     dtSunday = GetLastSundayBefore(dt)
 384
 385     while dtSunday >= GetLastSundayBefore(DateTime(dt.year, dt.month, 1)):
 386         weekNumMonth2 = weekNumMonth2 + 1
 387         dtSunday = dtSunday - DateTimeDelta(7)
 388
 389     data = { 'day': rjust(`day`, 2), \
 390              'month': monthNames[month - 1], \
 391              'year': year, \
 392              'weekNum': rjust(`weekNum`, 2), \
 393              'weekNumMonth': weekNumMonth, \
 394              'weekNumMonth2': weekNumMonth2, \
 395              'dayNum': rjust(`dayNum`, 3) }
 396
 397     print "        { { %(day)s, "\
 398           "wxDateTime::%(month)s, "\
 399           "%(year)d }, "\
 400           "%(weekNum)s, "\
 401           "%(weekNumMonth)s, "\
 402           "%(weekNumMonth2)s, "\
 403           "%(dayNum)s }," % data
 404
 405     */
 406     static const WeekNumberTestData weekNumberTestDates[] =
 407     {
 408         { { 27, wxDateTime::Dec, 1966 }, 52, 5, 5, 361 },
 409         { { 22, wxDateTime::Jul, 1926 }, 29, 4, 4, 203 },
 410         { { 22, wxDateTime::Oct, 2076 }, 43, 4, 4, 296 },
 411         { {  1, wxDateTime::Jul, 1967 }, 26, 1, 1, 182 },
 412         { {  8, wxDateTime::Nov, 2004 }, 46, 2, 2, 313 },
 413         { { 21, wxDateTime::Mar, 1920 }, 12, 3, 4,  81 },
 414         { {  7, wxDateTime::Jan, 1965 },  1, 2, 2,   7 },
 415         { { 19, wxDateTime::Oct, 1999 }, 42, 4, 4, 292 },
 416         { { 13, wxDateTime::Aug, 1955 }, 32, 2, 2, 225 },
 417         { { 18, wxDateTime::Jul, 2087 }, 29, 3, 3, 199 },
 418         { {  2, wxDateTime::Sep, 2028 }, 35, 1, 1, 246 },
 419         { { 28, wxDateTime::Jul, 1945 }, 30, 5, 4, 209 },
 420         { { 15, wxDateTime::Jun, 1901 }, 24, 3, 3, 166 },
 421         { { 10, wxDateTime::Oct, 1939 }, 41, 3, 2, 283 },
 422         { {  3, wxDateTime::Dec, 1965 }, 48, 1, 1, 337 },
 423         { { 23, wxDateTime::Feb, 1940 },  8, 4, 4,  54 },
 424         { {  2, wxDateTime::Jan, 1987 },  1, 1, 1,   2 },
 425         { { 11, wxDateTime::Aug, 2079 }, 32, 2, 2, 223 },
 426         { {  2, wxDateTime::Feb, 2063 },  5, 1, 1,  33 },
 427         { { 16, wxDateTime::Oct, 1942 }, 42, 3, 3, 289 },
 428     };
 429
 430     for ( size_t n = 0; n < WXSIZEOF(weekNumberTestDates); n++ )
 431     {
 432         const WeekNumberTestData& wn = weekNumberTestDates[n];
 433         const Date& d = wn.date;
 434
 435         wxDateTime dt = d.DT();
 436
 437         wxDateTime::wxDateTime_t
 438             week = dt.GetWeekOfYear(wxDateTime::Monday_First),
 439             wmon = dt.GetWeekOfMonth(wxDateTime::Monday_First),
 440             wmon2 = dt.GetWeekOfMonth(wxDateTime::Sunday_First),
 441             dnum = dt.GetDayOfYear();
 442
 443         CPPUNIT_ASSERT( dnum == wn.dnum );
 444         CPPUNIT_ASSERT( wmon == wn.wmon );
 445         CPPUNIT_ASSERT( wmon2 == wn.wmon2 );
 446         CPPUNIT_ASSERT( week == wn.week );
 447
 448         wxDateTime dt2(1, wxDateTime::Jan, d.year);
 449         dt2.SetToTheWeek(wn.week, dt.GetWeekDay());
 450         CPPUNIT_ASSERT( dt2 == dt );
 451     }
 452 }
 453
 454 // test DST applicability
 455 void DateTimeTestCase::TestTimeDST()
 456 {
 457     // taken from http://www.energy.ca.gov/daylightsaving.html
 458     static const Date datesDST[2][2004 - 1900 + 1] =
 459     {
 460         {
 461             { 1, wxDateTime::Apr, 1990 },
 462             { 7, wxDateTime::Apr, 1991 },
 463             { 5, wxDateTime::Apr, 1992 },
 464             { 4, wxDateTime::Apr, 1993 },
 465             { 3, wxDateTime::Apr, 1994 },
 466             { 2, wxDateTime::Apr, 1995 },
 467             { 7, wxDateTime::Apr, 1996 },
 468             { 6, wxDateTime::Apr, 1997 },
 469             { 5, wxDateTime::Apr, 1998 },
 470             { 4, wxDateTime::Apr, 1999 },
 471             { 2, wxDateTime::Apr, 2000 },
 472             { 1, wxDateTime::Apr, 2001 },
 473             { 7, wxDateTime::Apr, 2002 },
 474             { 6, wxDateTime::Apr, 2003 },
 475             { 4, wxDateTime::Apr, 2004 },
 476         },
 477         {
 478             { 28, wxDateTime::Oct, 1990 },
 479             { 27, wxDateTime::Oct, 1991 },
 480             { 25, wxDateTime::Oct, 1992 },
 481             { 31, wxDateTime::Oct, 1993 },
 482             { 30, wxDateTime::Oct, 1994 },
 483             { 29, wxDateTime::Oct, 1995 },
 484             { 27, wxDateTime::Oct, 1996 },
 485             { 26, wxDateTime::Oct, 1997 },
 486             { 25, wxDateTime::Oct, 1998 },
 487             { 31, wxDateTime::Oct, 1999 },
 488             { 29, wxDateTime::Oct, 2000 },
 489             { 28, wxDateTime::Oct, 2001 },
 490             { 27, wxDateTime::Oct, 2002 },
 491             { 26, wxDateTime::Oct, 2003 },
 492             { 31, wxDateTime::Oct, 2004 },
 493         }
 494     };
 495
 496     for ( int year = 1990; year < 2005; year++ )
 497     {
 498         wxDateTime dtBegin = wxDateTime::GetBeginDST(year, wxDateTime::USA),
 499                    dtEnd = wxDateTime::GetEndDST(year, wxDateTime::USA);
 500
 501         size_t n = year - 1990;
 502         const Date& dBegin = datesDST[0][n];
 503         const Date& dEnd = datesDST[1][n];
 504
 505         CPPUNIT_ASSERT( dBegin.SameDay(dtBegin.GetTm()) );
 506         CPPUNIT_ASSERT( dEnd.SameDay(dtEnd.GetTm()) );
 507     }
 508 }
 509
 510 // test wxDateTime -> text conversion
 511 void DateTimeTestCase::TestTimeFormat()
 512 {
 513     // some information may be lost during conversion, so store what kind
 514     // of info should we recover after a round trip
 515     enum CompareKind
 516     {
 517         CompareNone,        // don't try comparing
 518         CompareBoth,        // dates and times should be identical
 519         CompareDate,        // dates only
 520         CompareTime         // time only
 521     };
 522
 523     static const struct
 524     {
 525         CompareKind compareKind;
 526         const wxChar *format;
 527     } formatTestFormats[] =
 528     {
 529        { CompareBoth, _T("---> %c") },
 530        { CompareDate, _T("Date is %A, %d of %B, in year %Y") },
 531        { CompareBoth, _T("Date is %x, time is %X") },
 532        { CompareTime, _T("Time is %H:%M:%S or %I:%M:%S %p") },
 533        { CompareNone, _T("The day of year: %j, the week of year: %W") },
 534        { CompareDate, _T("ISO date without separators: %Y%m%d") },
 535     };
 536
 537     static const Date formatTestDates[] =
 538     {
 539         { 29, wxDateTime::May, 1976, 18, 30, 00 },
 540         { 31, wxDateTime::Dec, 1999, 23, 30, 00 },
 541 #if 0
 542         // this test can't work for other centuries because it uses two digit
 543         // years in formats, so don't even try it
 544         { 29, wxDateTime::May, 2076, 18, 30, 00 },
 545         { 29, wxDateTime::Feb, 2400, 02, 15, 25 },
 546         { 01, wxDateTime::Jan,  -52, 03, 16, 47 },
 547 #endif
 548     };
 549
 550     for ( size_t d = 0; d < WXSIZEOF(formatTestDates) + 1; d++ )
 551     {
 552         wxDateTime dt = d == 0 ? wxDateTime::Now() : formatTestDates[d - 1].DT();
 553         for ( size_t n = 0; n < WXSIZEOF(formatTestFormats); n++ )
 554         {
 555             wxString s = dt.Format(formatTestFormats[n].format);
 556
 557             // what can we recover?
 558             int kind = formatTestFormats[n].compareKind;
 559
 560             // convert back
 561             wxDateTime dt2;
 562             const wxChar *result = dt2.ParseFormat(s, formatTestFormats[n].format);
 563             if ( !result )
 564             {
 565                 // converion failed - should it have?
 566                 CPPUNIT_ASSERT( kind == CompareNone );
 567             }
 568             else // conversion succeeded
 569             {
 570                 // should have parsed the entire string
 571                 CPPUNIT_ASSERT( !*result );
 572
 573                 switch ( kind )
 574                 {
 575                     case CompareBoth:
 576                         CPPUNIT_ASSERT( dt2 == dt );
 577                         break;
 578
 579                     case CompareDate:
 580                         CPPUNIT_ASSERT( dt.IsSameDate(dt2) );
 581                         break;
 582
 583                     case CompareTime:
 584                         CPPUNIT_ASSERT( dt.IsSameTime(dt2) );
 585                         break;
 586                 }
 587             }
 588         }
 589     }
 590 }
 591
 592 void DateTimeTestCase::TestTimeTicks()
 593 {
 594     for ( size_t n = 0; n < WXSIZEOF(testDates); n++ )
 595     {
 596         const Date& d = testDates[n];
 597         if ( d.ticks == -1 )
 598             continue;
 599
 600         wxDateTime dt = d.DT();
 601         long ticks = (dt.GetValue() / 1000).ToLong();
 602         CPPUNIT_ASSERT( ticks == d.ticks );
 603
 604         dt = d.DT().ToTimezone(wxDateTime::GMT0);
 605         ticks = (dt.GetValue() / 1000).ToLong();
 606         CPPUNIT_ASSERT( ticks == d.gmticks );
 607     }
 608 }
 609
 610 // test text -> wxDateTime conversion
 611 void DateTimeTestCase::TestTimeParse()
 612 {
 613     static const struct ParseTestData
 614     {
 615         const wxChar *format;
 616         Date date;
 617         bool good;
 618     } parseTestDates[] =
 619     {
 620         { _T("Sat, 18 Dec 1999 00:46:40 +0100"), { 18, wxDateTime::Dec, 1999, 00, 46, 40 }, true },
 621         { _T("Wed, 1 Dec 1999 05:17:20 +0300"),  {  1, wxDateTime::Dec, 1999, 03, 17, 20 }, true },
 622     };
 623
 624     for ( size_t n = 0; n < WXSIZEOF(parseTestDates); n++ )
 625     {
 626         const wxChar *format = parseTestDates[n].format;
 627
 628         wxDateTime dt;
 629         if ( dt.ParseRfc822Date(format) )
 630         {
 631             CPPUNIT_ASSERT( parseTestDates[n].good );
 632
 633             wxDateTime dtReal = parseTestDates[n].date.DT();
 634             CPPUNIT_ASSERT( dt == dtReal );
 635         }
 636         else // failed to parse
 637         {
 638             CPPUNIT_ASSERT( !parseTestDates[n].good );
 639         }
 640     }
 641 }
 642
 643 void DateTimeTestCase::TestTimeArithmetics()
 644 {
 645     static const wxDateSpan testArithmData[] =
 646     {
 647         wxDateSpan::Day(),
 648         wxDateSpan::Week(),
 649         wxDateSpan::Month(),
 650         wxDateSpan::Year(),
 651     };
 652
 653     // the test will *not* work with arbitrary date!
 654     wxDateTime dt(2, wxDateTime::Dec, 1999),
 655                dt1,
 656                dt2;
 657
 658     for ( size_t n = 0; n < WXSIZEOF(testArithmData); n++ )
 659     {
 660         const wxDateSpan& span = testArithmData[n];
 661         dt1 = dt + span;
 662         dt2 = dt - span;
 663
 664         CPPUNIT_ASSERT( dt1 - span == dt );
 665         CPPUNIT_ASSERT( dt2 + span == dt );
 666         CPPUNIT_ASSERT( dt2 + 2*span == dt1 );
 667     }
 668 }
 669