← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to unittests/date_time_test.cc

  • Committer: Stewart Smith
  • Date: 2011-01-14 05:18:23 UTC
  • mto: (2086.1.3 build)
  • mto: This revision was merged to the branch mainline in revision 2087.
  • Revision ID: stewart@flamingspork.com-20110114051823-14fyn2kvg8pc5a15
\r and trailing whitespace removed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
unittests/date_time_test.cc
 
1
/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 
2
*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 
3
*
 
4
*  Copyright (C) 2010 Pawel Blokus
 
5
*
 
6
*  This program is free software; you can redistribute it and/or modify
 
7
*  it under the terms of the GNU General Public License as published by
 
8
*  the Free Software Foundation; either version 2 of the License, or
 
9
*  (at your option) any later version.
 
10
*
 
11
*  This program is distributed in the hope that it will be useful,
 
12
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
*  GNU General Public License for more details.
 
15
*
 
16
*  You should have received a copy of the GNU General Public License
 
17
*  along with this program; if not, write to the Free Software
 
18
*  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
19
*/
 
20
 
 
21
#include "config.h"
 
22
 
 
23
#include <gtest/gtest.h>
 
24
#include <drizzled/type/decimal.h>
 
25
#include <drizzled/temporal.h>
 
26
#include <drizzled/temporal_format.h>
 
27
 
 
28
#include "temporal_generator.h"
 
29
 
 
30
using namespace drizzled;
 
31
 
 
32
class DateTimeTest: public ::testing::Test
 
33
{
 
34
  protected:
 
35
    DateTime datetime;
 
36
    bool result;
 
37
    uint32_t years, months, days;
 
38
    uint32_t hours, minutes, seconds;
 
39
    
 
40
    virtual void SetUp()
 
41
    {
 
42
      TemporalGenerator::DateTimeGen::make_valid_datetime(&datetime);
 
43
    }
 
44
 
 
45
    void assignDateTimeValues()
 
46
    {
 
47
      years= datetime.years();
 
48
      months= datetime.months();
 
49
      days= datetime.days();
 
50
      hours= datetime.hours();
 
51
      minutes= datetime.minutes();
 
52
      seconds= datetime.seconds();
 
53
    }
 
54
};
 
55
 
 
56
TEST_F(DateTimeTest, is_valid_onValidDateTime_shouldReturn_True)
 
57
{
 
58
  result= datetime.is_valid();
 
59
  ASSERT_TRUE(result);
 
60
}
 
61
 
 
62
TEST_F(DateTimeTest, is_valid_onInvalidDateTimeWithYearBelowMinimum_shouldReturn_False)
 
63
{
 
64
  datetime.set_years(DRIZZLE_MIN_YEARS_SQL - 1);
 
65
  
 
66
  result= datetime.is_valid();
 
67
  
 
68
  ASSERT_FALSE(result);
 
69
}
 
70
 
 
71
TEST_F(DateTimeTest, is_valid_onInvalidDateTimeWithYearAboveMaximum_shouldReturn_False)
 
72
{
 
73
  datetime.set_years(DRIZZLE_MAX_YEARS_SQL + 1);
 
74
    
 
75
  result= datetime.is_valid();
 
76
  
 
77
  ASSERT_FALSE(result);
 
78
}
 
79
 
 
80
TEST_F(DateTimeTest, is_valid_onInvalidDateTimeWithMonthSetToZero_shouldReturn_False)
 
81
{
 
82
  datetime.set_months(0);
 
83
  
 
84
  result= datetime.is_valid();
 
85
  
 
86
  ASSERT_FALSE(result);
 
87
}
 
88
 
 
89
 
 
90
TEST_F(DateTimeTest, is_valid_onInvalidDateTimeWithMonthAboveMaximum_shouldReturn_False)
 
91
{
 
92
  datetime.set_months(13);
 
93
  
 
94
  result= datetime.is_valid();
 
95
  
 
96
  ASSERT_FALSE(result);
 
97
}
 
98
 
 
99
TEST_F(DateTimeTest, is_valid_onInvalidDateTimeWithDaySetToZero_shouldReturn_False)
 
100
{
 
101
  datetime.set_days(0);
 
102
  
 
103
  result= datetime.is_valid();
 
104
  
 
105
  ASSERT_FALSE(result);
 
106
}
 
107
 
 
108
TEST_F(DateTimeTest, is_valid_onInvalidDateTimeWithDayAboveDaysInMonth_shouldReturn_False)
 
109
{
 
110
  datetime.set_days(32);
 
111
  
 
112
  result= datetime.is_valid();
 
113
  
 
114
  ASSERT_FALSE(result);
 
115
}
 
116
 
 
117
TEST_F(DateTimeTest, is_valid_onInvalidDateTimeWithLeapDayInNonLeapYear_shouldReturn_False)
 
118
{
 
119
  TemporalGenerator::TemporalGen::leap_day_in_non_leap_year(&datetime);
 
120
  
 
121
  result= datetime.is_valid();
 
122
  
 
123
  ASSERT_FALSE(result);
 
124
}
 
125
 
 
126
TEST_F(DateTimeTest, is_valid_onValidDateTimeWithLeapDayInLeapYear_shouldReturn_True)
 
127
{
 
128
  TemporalGenerator::TemporalGen::leap_day_in_leap_year(&datetime);
 
129
  
 
130
  result= datetime.is_valid();
 
131
  
 
132
  ASSERT_TRUE(result);
 
133
}
 
134
 
 
135
TEST_F(DateTimeTest, is_valid_onValidMinimalTime_shouldReturn_True)
 
136
{
 
137
  TemporalGenerator::TemporalGen::make_min_time(&datetime);
 
138
  
 
139
  result= datetime.is_valid();
 
140
  
 
141
  ASSERT_TRUE(result);
 
142
}
 
143
 
 
144
TEST_F(DateTimeTest, is_valid_onValidMaximalTime_shouldReturn_True)
 
145
{
 
146
  TemporalGenerator::TemporalGen::make_max_time(&datetime);
 
147
  
 
148
  result= datetime.is_valid();
 
149
  
 
150
  ASSERT_TRUE(result);
 
151
}
 
152
 
 
153
TEST_F(DateTimeTest, is_valid_onInvalidDateTimeWithHourAboveMaximum23_shouldReturn_False)
 
154
{
 
155
  datetime.set_hours(24);
 
156
  
 
157
  result= datetime.is_valid();
 
158
  
 
159
  ASSERT_FALSE(result);
 
160
}
 
161
 
 
162
TEST_F(DateTimeTest, is_valid_onInvalidDateTimeWithMinutesAboveMaximum59_shouldReturn_False)
 
163
{
 
164
  datetime.set_minutes(60);
 
165
  
 
166
  result= datetime.is_valid();
 
167
  
 
168
  ASSERT_FALSE(result);
 
169
}
 
170
 
 
171
TEST_F(DateTimeTest, is_valid_onInvalidDateTimeWithSecondsAboveMaximum61_shouldReturn_False)
 
172
{
 
173
  datetime.set_seconds(62);
 
174
  
 
175
  result= datetime.is_valid();
 
176
  
 
177
  ASSERT_FALSE(result);
 
178
}
 
179
 
 
180
TEST_F(DateTimeTest, to_string_shouldProduce_hyphenSeperatedDateElements_and_colonSeperatedTimeElements)
 
181
{
 
182
  char expected[DateTime::MAX_STRING_LENGTH]= "2010-05-01 08:07:06.123456";
 
183
  char returned[DateTime::MAX_STRING_LENGTH];
 
184
  TemporalGenerator::DateTimeGen::make_datetime(&datetime, 2010, 5, 1, 8, 7, 6, 123456);
 
185
  
 
186
  datetime.to_string(returned, DateTime::MAX_STRING_LENGTH);
 
187
  
 
188
  ASSERT_STREQ(expected, returned);
 
189
}
 
190
 
 
191
TEST_F(DateTimeTest, to_string_nullBuffer_noMicroSeconds_shouldReturnProperLengthAnyway)
 
192
{
 
193
  int length= datetime.to_string(NULL, 0);
 
194
  
 
195
  ASSERT_EQ(DateTime::MAX_STRING_LENGTH - 1 - 7, length);  
 
196
}
 
197
 
 
198
TEST_F(DateTimeTest, to_int64_t)
 
199
{
 
200
  TemporalGenerator::DateTimeGen::make_datetime(&datetime, 2030, 8, 7, 14, 5, 13);
 
201
  int64_t representation;
 
202
 
 
203
  datetime.to_int64_t(&representation);
 
204
 
 
205
  ASSERT_EQ(20300807140513LL, representation);
 
206
}
 
207
 
 
208
TEST_F(DateTimeTest, from_int64_t_no_conversion_format_YYYYMMDDHHMMSSshouldPopulateDateTimeCorrectly)
 
209
{
 
210
  datetime.from_int64_t(20300807140513LL, false);
 
211
  
 
212
  assignDateTimeValues();
 
213
  
 
214
  EXPECT_EQ(2030, years);
 
215
  EXPECT_EQ(8, months);
 
216
  EXPECT_EQ(7, days);
 
217
  EXPECT_EQ(14, hours);
 
218
  EXPECT_EQ(5, minutes);
 
219
  EXPECT_EQ(13, seconds);
 
220
}
 
221
 
 
222
TEST_F(DateTimeTest, from_int64_t_with_conversion_format_YYYYMMDDHHMMSS_yearOver2000)
 
223
{
 
224
  datetime.from_int64_t(20300807140513LL, true);
 
225
  
 
226
  assignDateTimeValues();
 
227
  
 
228
  EXPECT_EQ(2030, years);
 
229
  EXPECT_EQ(8, months);
 
230
  EXPECT_EQ(7, days);
 
231
  EXPECT_EQ(14, hours);
 
232
  EXPECT_EQ(5, minutes);
 
233
  EXPECT_EQ(13, seconds);
 
234
}
 
235
 
 
236
TEST_F(DateTimeTest, from_int64_t_with_conversion_format_YYYYMMDDHHMMSS_yearBelow2000)
 
237
{
 
238
  datetime.from_int64_t(19900807140513LL, true);
 
239
  
 
240
  assignDateTimeValues();
 
241
  
 
242
  EXPECT_EQ(1990, years);
 
243
  EXPECT_EQ(8, months);
 
244
  EXPECT_EQ(7, days);
 
245
  EXPECT_EQ(14, hours);
 
246
  EXPECT_EQ(5, minutes);
 
247
  EXPECT_EQ(13, seconds);
 
248
}
 
249
 
 
250
TEST_F(DateTimeTest, from_int64_t_with_conversion_format_YYMMDDHHMMSS_yearOver2000)
 
251
{
 
252
  datetime.from_int64_t(300807140513LL, true);
 
253
  
 
254
  assignDateTimeValues();
 
255
  
 
256
  EXPECT_EQ(2030, years);
 
257
  EXPECT_EQ(8, months);
 
258
  EXPECT_EQ(7, days);
 
259
  EXPECT_EQ(14, hours);
 
260
  EXPECT_EQ(5, minutes);
 
261
  EXPECT_EQ(13, seconds);
 
262
}
 
263
 
 
264
TEST_F(DateTimeTest, from_int64_t_with_conversion_format_YYMMDDHHMMSS_yearBelow2000)
 
265
{
 
266
  datetime.from_int64_t(900807140513LL, true);
 
267
  
 
268
  assignDateTimeValues();
 
269
  
 
270
  EXPECT_EQ(1990, years);
 
271
  EXPECT_EQ(8, months);
 
272
  EXPECT_EQ(7, days);
 
273
  EXPECT_EQ(14, hours);
 
274
  EXPECT_EQ(5, minutes);
 
275
  EXPECT_EQ(13, seconds);
 
276
}
 
277
 
 
278
TEST_F(DateTimeTest, DISABLED_to_tm)
 
279
{
 
280
  years= 2030, months= 8, days= 17, hours= 14, minutes= 45, seconds= 13;
 
281
  TemporalGenerator::DateTimeGen::make_datetime(&datetime, years, months, days, hours, minutes, seconds);
 
282
  struct tm filled;
 
283
  
 
284
  datetime.to_tm(&filled);
 
285
  
 
286
  EXPECT_EQ(2030 - 1900, filled.tm_year);
 
287
  EXPECT_EQ(8 - 1, filled.tm_mon);
 
288
  EXPECT_EQ(17, filled.tm_mday);
 
289
  EXPECT_EQ(14, filled.tm_hour);
 
290
  EXPECT_EQ(45, filled.tm_min);
 
291
  EXPECT_EQ(13, filled.tm_sec);
 
292
 
 
293
  /* TODO:these fail, shouldn't they also be set properly? */
 
294
  EXPECT_EQ(228, filled.tm_yday);
 
295
  EXPECT_EQ(6, filled.tm_wday);
 
296
  EXPECT_EQ(-1, filled.tm_isdst);
 
297
}
 
298
 
 
299
TEST_F(DateTimeTest, to_decimal)
 
300
{
 
301
  drizzled::type::Decimal to;
 
302
  TemporalGenerator::DateTimeGen::make_datetime(&datetime, 1987, 6, 13, 5, 10, 13, 456);
 
303
 
 
304
  datetime.to_decimal(&to);
 
305
  
 
306
  EXPECT_EQ(19870,to.buf[0]);
 
307
  EXPECT_EQ(613051013,to.buf[1]);
 
308
  EXPECT_EQ(456000,to.buf[2]);
 
309
}
 
310
 
 
311
 
 
312
 
 
313
class DateTimeFromStringTest
 
314
{
 
315
  protected:
 
316
    DateTime datetime;
 
317
    bool result;
 
318
    uint32_t years, months, days;
 
319
    uint32_t hours, minutes, seconds;
 
320
 
 
321
    void init()
 
322
    {
 
323
      init_temporal_formats();
 
324
    }
 
325
 
 
326
    void deinit()
 
327
    {
 
328
      deinit_temporal_formats();
 
329
    }
 
330
 
 
331
    void assignDateTimeValues()
 
332
    {
 
333
      years= datetime.years();
 
334
      months= datetime.months();
 
335
      days= datetime.days();
 
336
      hours= datetime.hours();
 
337
      minutes= datetime.minutes();
 
338
      seconds= datetime.seconds();
 
339
    }
 
340
};
 
341
 
 
342
class DateTimeFromStringFullFormatTest: public ::testing::TestWithParam<const char*>, public DateTimeFromStringTest
 
343
{
 
344
  virtual void SetUp()
 
345
  {
 
346
    init();
 
347
  }
 
348
  
 
349
  virtual void TearDown()
 
350
  {
 
351
    deinit();
 
352
  }  
 
353
};
 
354
 
 
355
class DateTimeFromStringNoSecondFormatTest: public ::testing::TestWithParam<const char*>, public DateTimeFromStringTest
 
356
{
 
357
  virtual void SetUp()
 
358
  {
 
359
    init();
 
360
  }
 
361
  
 
362
  virtual void TearDown()
 
363
  {
 
364
    deinit();
 
365
  }
 
366
};
 
367
 
 
368
class DateTimeFromStringDateOnlyTest: public ::testing::TestWithParam<const char*>, public DateTimeFromStringTest
 
369
{
 
370
  virtual void SetUp()
 
371
  {
 
372
    init();
 
373
  }
 
374
  
 
375
  virtual void TearDown()
 
376
  {
 
377
    deinit();
 
378
  }
 
379
};
 
380
 
 
381
TEST_P(DateTimeFromStringFullFormatTest, from_string_validString)
 
382
{
 
383
  const char *valid_string= GetParam();
 
384
 
 
385
  result= datetime.from_string(valid_string, strlen(valid_string));
 
386
  ASSERT_TRUE(result);
 
387
 
 
388
  assignDateTimeValues();
 
389
 
 
390
  EXPECT_EQ(2010, years);
 
391
  EXPECT_EQ(5, months);
 
392
  EXPECT_EQ(1, days);
 
393
  EXPECT_EQ(8, hours);
 
394
  EXPECT_EQ(7, minutes);
 
395
  EXPECT_EQ(6, seconds);
 
396
}
 
397
/* TODO:for some reason this was not declared by the macro, needs clarification*/
 
398
testing::internal::ParamGenerator<const char*> gtest_ValidStringDateTimeFromStringFullFormatTest_EvalGenerator_();
 
399
INSTANTIATE_TEST_CASE_P(ValidString, DateTimeFromStringFullFormatTest,
 
400
                        ::testing::Values("20100501080706",
 
401
                                          "2010-05-01 08:07:06",
 
402
                                          "2010/05/01T08:07:06",
 
403
                                          "2010.5.1 08:07:06",
 
404
                                          "10-05-01 08:07:06",
 
405
                                          "10/5/1 08:07:06",
 
406
                                          "10.5.1 08:07:06"));
 
407
 
 
408
                                          
 
409
TEST_P(DateTimeFromStringNoSecondFormatTest, from_string_validString)
 
410
{
 
411
  const char *valid_string= GetParam();
 
412
 
 
413
  result= datetime.from_string(valid_string, strlen(valid_string));
 
414
  ASSERT_TRUE(result);
 
415
 
 
416
  assignDateTimeValues();
 
417
 
 
418
  EXPECT_EQ(2010, years);
 
419
  EXPECT_EQ(5, months);
 
420
  EXPECT_EQ(1, days);
 
421
  EXPECT_EQ(8, hours);
 
422
  EXPECT_EQ(7, minutes);
 
423
}
 
424
 
 
425
/* TODO:for some reason this was not declared by the macro, needs clarification*/
 
426
testing::internal::ParamGenerator<const char*> gtest_ValidStringDateTimeFromStringNoSecondFormatTest_EvalGenerator_();
 
427
INSTANTIATE_TEST_CASE_P(ValidString, DateTimeFromStringNoSecondFormatTest,
 
428
                        ::testing::Values("2010-05-01 08:07",
 
429
                                          "2010/05/01 08:07",
 
430
                                          "2010.5.1 08:07",
 
431
                                          "10-05-01 08:07",
 
432
                                          "10/5/1 08:07",
 
433
                                          "10.5.1 08:07"));
 
434
 
 
435
 
 
436
 
 
437
TEST_P(DateTimeFromStringDateOnlyTest, from_string_validString)
 
438
{
 
439
  const char *valid_string= GetParam();
 
440
 
 
441
  result= datetime.from_string(valid_string, strlen(valid_string));
 
442
  ASSERT_TRUE(result);
 
443
 
 
444
  assignDateTimeValues();
 
445
 
 
446
  EXPECT_EQ(2010, years);
 
447
  EXPECT_EQ(6, months);
 
448
  EXPECT_EQ(7, days);
 
449
}
 
450
 
 
451
/* TODO:for some reason this was not declared by the macro, needs clarification*/
 
452
testing::internal::ParamGenerator<const char*> gtest_ValidStringDateTimeFromStringDateOnlyTest_EvalGenerator_();
 
453
INSTANTIATE_TEST_CASE_P(ValidString, DateTimeFromStringDateOnlyTest,
 
454
                        ::testing::Values("20100607", /* YYYYMMDD */
 
455
                                          "06/07/2010",/* MM[-/.]DD[-/.]YYYY (US common format)*/
 
456
                                          "10.06.07",/* YY[-/.]MM[-/.]DD */
 
457
                                          "10/6/7",/* YY[-/.][M]M[-/.][D]D */
 
458
                                          "2010-6-7"/* YYYY[-/.][M]M[-/.][D]D */));
 
459
 
 
460