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
 329     wxDateTime dt;
 330     for ( n = 0; n < WXSIZEOF(weekDatesTestData); n++ )
 331     {
 332         const WeekDateTestData& wd = weekDatesTestData[n];
 333
 334         dt.SetToWeekDay(wd.wday, wd.nWeek, wd.month, wd.year);
 335
 336         const Date& d = wd.date;
 337         CPPUNIT_ASSERT( d.SameDay(dt.GetTm()) );
 338     }
 339 }
 340
 341 // test the computation of (ISO) week numbers
 342 void DateTimeTestCase::TestTimeWNumber()
 343 {
 344     struct WeekNumberTestData
 345     {
 346         Date date;                          // the date
 347         wxDateTime::wxDateTime_t week;      // the week number in the year
 348         wxDateTime::wxDateTime_t wmon;      // the week number in the month
 349         wxDateTime::wxDateTime_t wmon2;     // same but week starts with Sun
 350         wxDateTime::wxDateTime_t dnum;      // day number in the year
 351     };
 352
 353     // data generated with the following python script:
 354     /*
 355 from DateTime import *
 356 from whrandom import *
 357 from string import *
 358
 359 monthNames = [ 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec' ]
 360 wdayNames = [ 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun' ]
 361
 362 def GetMonthWeek(dt):
 363     weekNumMonth = dt.iso_week[1] - DateTime(dt.year, dt.month, 1).iso_week[1] + 1
 364     if weekNumMonth < 0:
 365         weekNumMonth = weekNumMonth + 53
 366     return weekNumMonth
 367
 368 def GetLastSundayBefore(dt):
 369     if dt.iso_week[2] == 7:
 370         return dt
 371     else:
 372         return dt - DateTimeDelta(dt.iso_week[2])
 373
 374 for n in range(20):
 375     year = randint(1900, 2100)
 376     month = randint(1, 12)
 377     day = randint(1, 28)
 378     dt = DateTime(year, month, day)
 379     dayNum = dt.day_of_year
 380     weekNum = dt.iso_week[1]
 381     weekNumMonth = GetMonthWeek(dt)
 382
 383     weekNumMonth2 = 0
 384     dtSunday = GetLastSundayBefore(dt)
 385
 386     while dtSunday >= GetLastSundayBefore(DateTime(dt.year, dt.month, 1)):
 387         weekNumMonth2 = weekNumMonth2 + 1
 388         dtSunday = dtSunday - DateTimeDelta(7)
 389
 390     data = { 'day': rjust(`day`, 2), \
 391              'month': monthNames[month - 1], \
 392              'year': year, \
 393              'weekNum': rjust(`weekNum`, 2), \
 394              'weekNumMonth': weekNumMonth, \
 395              'weekNumMonth2': weekNumMonth2, \
 396              'dayNum': rjust(`dayNum`, 3) }
 397
 398     print "        { { %(day)s, "\
 399           "wxDateTime::%(month)s, "\
 400           "%(year)d }, "\
 401           "%(weekNum)s, "\
 402           "%(weekNumMonth)s, "\
 403           "%(weekNumMonth2)s, "\
 404           "%(dayNum)s }," % data
 405
 406     */
 407     static const WeekNumberTestData weekNumberTestDates[] =
 408     {
 409         { { 27, wxDateTime::Dec, 1966 }, 52, 5, 5, 361 },
 410         { { 22, wxDateTime::Jul, 1926 }, 29, 4, 4, 203 },
 411         { { 22, wxDateTime::Oct, 2076 }, 43, 4, 4, 296 },
 412         { {  1, wxDateTime::Jul, 1967 }, 26, 1, 1, 182 },
 413         { {  8, wxDateTime::Nov, 2004 }, 46, 2, 2, 313 },
 414         { { 21, wxDateTime::Mar, 1920 }, 12, 3, 4,  81 },
 415         { {  7, wxDateTime::Jan, 1965 },  1, 2, 2,   7 },
 416         { { 19, wxDateTime::Oct, 1999 }, 42, 4, 4, 292 },
 417         { { 13, wxDateTime::Aug, 1955 }, 32, 2, 2, 225 },
 418         { { 18, wxDateTime::Jul, 2087 }, 29, 3, 3, 199 },
 419         { {  2, wxDateTime::Sep, 2028 }, 35, 1, 1, 246 },
 420         { { 28, wxDateTime::Jul, 1945 }, 30, 5, 4, 209 },
 421         { { 15, wxDateTime::Jun, 1901 }, 24, 3, 3, 166 },
 422         { { 10, wxDateTime::Oct, 1939 }, 41, 3, 2, 283 },
 423         { {  3, wxDateTime::Dec, 1965 }, 48, 1, 1, 337 },
 424         { { 23, wxDateTime::Feb, 1940 },  8, 4, 4,  54 },
 425         { {  2, wxDateTime::Jan, 1987 },  1, 1, 1,   2 },
 426         { { 11, wxDateTime::Aug, 2079 }, 32, 2, 2, 223 },
 427         { {  2, wxDateTime::Feb, 2063 },  5, 1, 1,  33 },
 428         { { 16, wxDateTime::Oct, 1942 }, 42, 3, 3, 289 },
 429         { { 30, wxDateTime::Dec, 2003 },  1, 5, 5, 364 },
 430         { {  2, wxDateTime::Jan, 2004 },  1, 1, 1,   2 },
 431     };
 432
 433     for ( size_t n = 0; n < WXSIZEOF(weekNumberTestDates); n++ )
 434     {
 435         const WeekNumberTestData& wn = weekNumberTestDates[n];
 436         const Date& d = wn.date;
 437
 438         wxDateTime dt = d.DT();
 439
 440         wxDateTime::wxDateTime_t
 441             week = dt.GetWeekOfYear(wxDateTime::Monday_First),
 442             wmon = dt.GetWeekOfMonth(wxDateTime::Monday_First),
 443             wmon2 = dt.GetWeekOfMonth(wxDateTime::Sunday_First),
 444             dnum = dt.GetDayOfYear();
 445
 446         CPPUNIT_ASSERT( dnum == wn.dnum );
 447         CPPUNIT_ASSERT( wmon == wn.wmon );
 448         CPPUNIT_ASSERT( wmon2 == wn.wmon2 );
 449         CPPUNIT_ASSERT( week == wn.week );
 450
 451         int year = d.year;
 452         if ( week == 1 && d.month != wxDateTime::Jan )
 453         {
 454             // this means we're in the first week of the next year
 455             year++;
 456         }
 457
 458         wxDateTime
 459             dt2 = wxDateTime::SetToWeekOfYear(year, week, dt.GetWeekDay());
 460         CPPUNIT_ASSERT( dt2 == dt );
 461     }
 462 }
 463
 464 // test DST applicability
 465 void DateTimeTestCase::TestTimeDST()
 466 {
 467     // taken from http://www.energy.ca.gov/daylightsaving.html
 468     static const Date datesDST[2][2004 - 1900 + 1] =
 469     {
 470         {
 471             { 1, wxDateTime::Apr, 1990 },
 472             { 7, wxDateTime::Apr, 1991 },
 473             { 5, wxDateTime::Apr, 1992 },
 474             { 4, wxDateTime::Apr, 1993 },
 475             { 3, wxDateTime::Apr, 1994 },
 476             { 2, wxDateTime::Apr, 1995 },
 477             { 7, wxDateTime::Apr, 1996 },
 478             { 6, wxDateTime::Apr, 1997 },
 479             { 5, wxDateTime::Apr, 1998 },
 480             { 4, wxDateTime::Apr, 1999 },
 481             { 2, wxDateTime::Apr, 2000 },
 482             { 1, wxDateTime::Apr, 2001 },
 483             { 7, wxDateTime::Apr, 2002 },
 484             { 6, wxDateTime::Apr, 2003 },
 485             { 4, wxDateTime::Apr, 2004 },
 486         },
 487         {
 488             { 28, wxDateTime::Oct, 1990 },
 489             { 27, wxDateTime::Oct, 1991 },
 490             { 25, wxDateTime::Oct, 1992 },
 491             { 31, wxDateTime::Oct, 1993 },
 492             { 30, wxDateTime::Oct, 1994 },
 493             { 29, wxDateTime::Oct, 1995 },
 494             { 27, wxDateTime::Oct, 1996 },
 495             { 26, wxDateTime::Oct, 1997 },
 496             { 25, wxDateTime::Oct, 1998 },
 497             { 31, wxDateTime::Oct, 1999 },
 498             { 29, wxDateTime::Oct, 2000 },
 499             { 28, wxDateTime::Oct, 2001 },
 500             { 27, wxDateTime::Oct, 2002 },
 501             { 26, wxDateTime::Oct, 2003 },
 502             { 31, wxDateTime::Oct, 2004 },
 503         }
 504     };
 505
 506     for ( int year = 1990; year < 2005; year++ )
 507     {
 508         wxDateTime dtBegin = wxDateTime::GetBeginDST(year, wxDateTime::USA),
 509                    dtEnd = wxDateTime::GetEndDST(year, wxDateTime::USA);
 510
 511         size_t n = year - 1990;
 512         const Date& dBegin = datesDST[0][n];
 513         const Date& dEnd = datesDST[1][n];
 514
 515         CPPUNIT_ASSERT( dBegin.SameDay(dtBegin.GetTm()) );
 516         CPPUNIT_ASSERT( dEnd.SameDay(dtEnd.GetTm()) );
 517     }
 518 }
 519
 520 // test wxDateTime -> text conversion
 521 void DateTimeTestCase::TestTimeFormat()
 522 {
 523     // some information may be lost during conversion, so store what kind
 524     // of info should we recover after a round trip
 525     enum CompareKind
 526     {
 527         CompareNone,        // don't try comparing
 528         CompareBoth,        // dates and times should be identical
 529         CompareDate,        // dates only
 530         CompareTime         // time only
 531     };
 532
 533     static const struct
 534     {
 535         CompareKind compareKind;
 536         const wxChar *format;
 537     } formatTestFormats[] =
 538     {
 539        { CompareBoth, _T("---> %c") },
 540        { CompareDate, _T("Date is %A, %d of %B, in year %Y") },
 541        { CompareBoth, _T("Date is %x, time is %X") },
 542        { CompareTime, _T("Time is %H:%M:%S or %I:%M:%S %p") },
 543        { CompareNone, _T("The day of year: %j, the week of year: %W") },
 544        { CompareDate, _T("ISO date without separators: %Y%m%d") },
 545     };
 546
 547     static const Date formatTestDates[] =
 548     {
 549         { 29, wxDateTime::May, 1976, 18, 30, 00 },
 550         { 31, wxDateTime::Dec, 1999, 23, 30, 00 },
 551 #if 0
 552         // this test can't work for other centuries because it uses two digit
 553         // years in formats, so don't even try it
 554         { 29, wxDateTime::May, 2076, 18, 30, 00 },
 555         { 29, wxDateTime::Feb, 2400, 02, 15, 25 },
 556         { 01, wxDateTime::Jan,  -52, 03, 16, 47 },
 557 #endif
 558     };
 559
 560     for ( size_t d = 0; d < WXSIZEOF(formatTestDates) + 1; d++ )
 561     {
 562         wxDateTime dt = d == 0 ? wxDateTime::Now() : formatTestDates[d - 1].DT();
 563         for ( size_t n = 0; n < WXSIZEOF(formatTestFormats); n++ )
 564         {
 565             wxString s = dt.Format(formatTestFormats[n].format);
 566
 567             // what can we recover?
 568             int kind = formatTestFormats[n].compareKind;
 569
 570             // convert back
 571             wxDateTime dt2;
 572             const wxChar *result = dt2.ParseFormat(s, formatTestFormats[n].format);
 573             if ( !result )
 574             {
 575                 // converion failed - should it have?
 576                 CPPUNIT_ASSERT( kind == CompareNone );
 577             }
 578             else // conversion succeeded
 579             {
 580                 // should have parsed the entire string
 581                 CPPUNIT_ASSERT( !*result );
 582
 583                 switch ( kind )
 584                 {
 585                     case CompareBoth:
 586                         CPPUNIT_ASSERT( dt2 == dt );
 587                         break;
 588
 589                     case CompareDate:
 590                         CPPUNIT_ASSERT( dt.IsSameDate(dt2) );
 591                         break;
 592
 593                     case CompareTime:
 594                         CPPUNIT_ASSERT( dt.IsSameTime(dt2) );
 595                         break;
 596                 }
 597             }
 598         }
 599     }
 600 }
 601
 602 void DateTimeTestCase::TestTimeTicks()
 603 {
 604     for ( size_t n = 0; n < WXSIZEOF(testDates); n++ )
 605     {
 606         const Date& d = testDates[n];
 607         if ( d.ticks == -1 )
 608             continue;
 609
 610         wxDateTime dt = d.DT();
 611         long ticks = (dt.GetValue() / 1000).ToLong();
 612         CPPUNIT_ASSERT( ticks == d.ticks );
 613
 614         dt = d.DT().ToTimezone(wxDateTime::GMT0);
 615         ticks = (dt.GetValue() / 1000).ToLong();
 616         CPPUNIT_ASSERT( ticks == d.gmticks );
 617     }
 618 }
 619
 620 // test text -> wxDateTime conversion
 621 void DateTimeTestCase::TestTimeParse()
 622 {
 623     static const struct ParseTestData
 624     {
 625         const wxChar *format;
 626         Date date;
 627         bool good;
 628     } parseTestDates[] =
 629     {
 630         { _T("Sat, 18 Dec 1999 00:46:40 +0100"), { 18, wxDateTime::Dec, 1999, 00, 46, 40 }, true },
 631         { _T("Wed, 1 Dec 1999 05:17:20 +0300"),  {  1, wxDateTime::Dec, 1999, 03, 17, 20 }, true },
 632     };
 633
 634     for ( size_t n = 0; n < WXSIZEOF(parseTestDates); n++ )
 635     {
 636         const wxChar *format = parseTestDates[n].format;
 637
 638         wxDateTime dt;
 639         if ( dt.ParseRfc822Date(format) )
 640         {
 641             CPPUNIT_ASSERT( parseTestDates[n].good );
 642
 643             wxDateTime dtReal = parseTestDates[n].date.DT();
 644             CPPUNIT_ASSERT( dt == dtReal );
 645         }
 646         else // failed to parse
 647         {
 648             CPPUNIT_ASSERT( !parseTestDates[n].good );
 649         }
 650     }
 651 }
 652
 653 void DateTimeTestCase::TestTimeArithmetics()
 654 {
 655     static const wxDateSpan testArithmData[] =
 656     {
 657         wxDateSpan::Day(),
 658         wxDateSpan::Week(),
 659         wxDateSpan::Month(),
 660         wxDateSpan::Year(),
 661     };
 662
 663     // the test will *not* work with arbitrary date!
 664     wxDateTime dt(2, wxDateTime::Dec, 1999),
 665                dt1,
 666                dt2;
 667
 668     for ( size_t n = 0; n < WXSIZEOF(testArithmData); n++ )
 669     {
 670         const wxDateSpan& span = testArithmData[n];
 671         dt1 = dt + span;
 672         dt2 = dt - span;
 673
 674         CPPUNIT_ASSERT( dt1 - span == dt );
 675         CPPUNIT_ASSERT( dt2 + span == dt );
 676         CPPUNIT_ASSERT( dt2 + 2*span == dt1 );
 677     }
 678 }
 679