← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to unittests/DateTime_test.cc

moved shared generators to Temporal
added file for DateTime tests
added tests for DateTime

Show diffs side-by-side

added added

removed removed

Lines of Context:
unittests/DateTime_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/temporal.h>
 
25
 
 
26
#include "generator.h"
 
27
 
 
28
using namespace drizzled;
 
29
 
 
30
class DateTimeTest: public ::testing::Test
 
31
{
 
32
  protected:
 
33
    DateTime datetime;
 
34
    bool result;
 
35
    
 
36
    virtual void SetUp()
 
37
    {
 
38
      Generator::DateTimeGen::make_valid_datetime(&datetime);
 
39
    }
 
40
};
 
41
 
 
42
TEST_F(DateTimeTest, in_unix_epoch_onFirstDateTimeInUnixEpoch_shouldReturn_True)
 
43
{
 
44
  Generator::DateTimeGen::make_datetime(&datetime, 1970, 1, 1, 0, 0, 0);
 
45
  
 
46
  result= datetime.is_valid();
 
47
  
 
48
  ASSERT_TRUE(result);  
 
49
}
 
50
 
 
51
TEST_F(DateTimeTest, in_unix_epoch_onLastDateTimeInUnixEpoch_shouldReturn_True)
 
52
{
 
53
  Generator::DateTimeGen::make_datetime(&datetime, 2038, 1, 19, 3, 14, 7);
 
54
  
 
55
  result= datetime.is_valid();
 
56
  
 
57
  ASSERT_TRUE(result);
 
58
}
 
59
 
 
60
TEST_F(DateTimeTest, in_unix_epoch_onLastDateTimeBeforeUnixEpoch_shouldReturn_False)
 
61
{
 
62
  Generator::DateTimeGen::make_datetime(&datetime, 1969, 12, 31, 23, 59, 59);
 
63
  
 
64
  result= datetime.is_valid();
 
65
  
 
66
  ASSERT_FALSE(result);
 
67
}
 
68
 
 
69
TEST_F(DateTimeTest, in_unix_epoch_onFirstDateTimeAfterUnixEpoch_shouldReturn_False)
 
70
{
 
71
  Generator::DateTimeGen::make_datetime(&datetime, 1969, 1, 19, 3, 14, 8);
 
72
  
 
73
  result= datetime.is_valid();
 
74
  
 
75
  ASSERT_FALSE(result);
 
76
}
 
77
 
 
78
TEST_F(DateTimeTest, is_valid_onValidDateTime_shouldReturn_True)
 
79
{
 
80
  result= datetime.is_valid();
 
81
  ASSERT_TRUE(result);
 
82
}
 
83
 
 
84
TEST_F(DateTimeTest, is_valid_onInvalidDateTimeWithYearBelowMinimum_shouldReturn_False)
 
85
{
 
86
  datetime.set_years(DRIZZLE_MIN_YEARS_SQL - 1);
 
87
  
 
88
  result= datetime.is_valid();
 
89
  
 
90
  ASSERT_FALSE(result);
 
91
}
 
92
 
 
93
TEST_F(DateTimeTest, is_valid_onInvalidDateTimeWithYearAboveMaximum_shouldReturn_False)
 
94
{
 
95
  datetime.set_years(DRIZZLE_MAX_YEARS_SQL + 1);
 
96
    
 
97
  result= datetime.is_valid();
 
98
  
 
99
  ASSERT_FALSE(result);
 
100
}
 
101
 
 
102
TEST_F(DateTimeTest, is_valid_onInvalidDateTimeWithMonthSetToZero_shouldReturn_False)
 
103
{
 
104
  datetime.set_months(0);
 
105
  
 
106
  result= datetime.is_valid();
 
107
  
 
108
  ASSERT_FALSE(result);
 
109
}
 
110
 
 
111
 
 
112
TEST_F(DateTimeTest, is_valid_onInvalidDateTimeWithMonthAboveMaximum_shouldReturn_False)
 
113
{
 
114
  datetime.set_months(13);
 
115
  
 
116
  result= datetime.is_valid();
 
117
  
 
118
  ASSERT_FALSE(result);
 
119
}
 
120
 
 
121
TEST_F(DateTimeTest, is_valid_onInvalidDateTimeWithDaySetToZero_shouldReturn_False)
 
122
{
 
123
  datetime.set_days(0);
 
124
  
 
125
  result= datetime.is_valid();
 
126
  
 
127
  ASSERT_FALSE(result);
 
128
}
 
129
 
 
130
TEST_F(DateTimeTest, is_valid_onInvalidDateTimeWithDayAboveDaysInMonth_shouldReturn_False)
 
131
{
 
132
  datetime.set_days(32);
 
133
  
 
134
  result= datetime.is_valid();
 
135
  
 
136
  ASSERT_FALSE(result);
 
137
}
 
138
 
 
139
TEST_F(DateTimeTest, is_valid_onInvalidDateTimeWithLeapDayInNonLeapYear_shouldReturn_False)
 
140
{
 
141
  Generator::TemporalGen::leap_day_in_non_leap_year(&datetime);
 
142
  
 
143
  result= datetime.is_valid();
 
144
  
 
145
  ASSERT_FALSE(result);
 
146
}
 
147
 
 
148
TEST_F(DateTimeTest, is_valid_onValidDateTimeWithLeapDayInLeapYear_shouldReturn_True)
 
149
{
 
150
  Generator::TemporalGen::leap_day_in_leap_year(&datetime);
 
151
  
 
152
  result= datetime.is_valid();
 
153
  
 
154
  ASSERT_TRUE(result);
 
155
}
 
156
 
 
157
TEST_F(DateTimeTest, is_valid_onValidMinimalTime_shouldReturn_True)
 
158
{
 
159
  Generator::TemporalGen::make_min_time(&datetime);
 
160
  
 
161
  result= datetime.is_valid();
 
162
  
 
163
  ASSERT_TRUE(result);
 
164
}
 
165
 
 
166
TEST_F(DateTimeTest, is_valid_onValidMaximalTime_shouldReturn_True)
 
167
{
 
168
  Generator::TemporalGen::make_max_time(&datetime);
 
169
  
 
170
  result= datetime.is_valid();
 
171
  
 
172
  ASSERT_TRUE(result);
 
173
}
 
174
 
 
175
TEST_F(DateTimeTest, is_valid_onInvalidDateTimeWithHourAboveMaximum23_shouldReturn_False)
 
176
{
 
177
  datetime.set_hours(24);
 
178
  
 
179
  result= datetime.is_valid();
 
180
  
 
181
  ASSERT_FALSE(result);
 
182
}
 
183
 
 
184
TEST_F(DateTimeTest, is_valid_onInvalidDateTimeWithMinutesAboveMaximum59_shouldReturn_False)
 
185
{
 
186
  datetime.set_minutes(60);
 
187
  
 
188
  result= datetime.is_valid();
 
189
  
 
190
  ASSERT_FALSE(result);
 
191
}
 
192
 
 
193
TEST_F(DateTimeTest, is_valid_onInvalidDateTimeWithSecondsAboveMaximum59_shouldReturn_False)
 
194
{
 
195
  datetime.set_seconds(60);
 
196
  
 
197
  result= datetime.is_valid();
 
198
  
 
199
  ASSERT_FALSE(result);
 
200
}
 
201
 
 
202
TEST_F(DateTimeTest, to_string_shouldProduce_hyphenSeperatedDateElements_and_colonSeperatedTimeElements)
 
203
{
 
204
  char expected[DateTime::MAX_STRING_LENGTH]= "2010-05-01 08:07:06";
 
205
  char returned[DateTime::MAX_STRING_LENGTH];
 
206
  Generator::DateTimeGen::make_datetime(&datetime, 2010, 5, 1, 8, 7, 6);
 
207
  
 
208
  datetime.to_string(returned, DateTime::MAX_STRING_LENGTH);
 
209
  
 
210
  ASSERT_STREQ(expected, returned);  
 
211
}
 
212
 
 
213
TEST_F(DateTimeTest, to_string_nullBuffer_shouldReturnProperLengthAnyway)
 
214
{
 
215
  int length= datetime.to_string(NULL, 0);
 
216
  
 
217
  ASSERT_EQ(DateTime::MAX_STRING_LENGTH - 1, length);  
 
218
}
 
219
 
 
220
TEST_F(DateTimeTest, from_string_validString_shouldPopulateCorrectly)
 
221
{
 
222
  char valid_string[DateTime::MAX_STRING_LENGTH]= "2010-05-01 08:07:06";
 
223
  uint32_t years, months, days, hours, minutes, seconds;
 
224
  
 
225
  result = datetime.from_string(valid_string, DateTime::MAX_STRING_LENGTH);
 
226
  ASSERT_TRUE(result);
 
227
  
 
228
  years = datetime.years();
 
229
  months = datetime.months();
 
230
  days = datetime.days();
 
231
  hours = datetime.hours();
 
232
  minutes = datetime.minutes();
 
233
  seconds = datetime.seconds();
 
234
  
 
235
  EXPECT_EQ(2010, years);
 
236
  EXPECT_EQ(5, months);
 
237
  EXPECT_EQ(1, days);
 
238
  EXPECT_EQ(8, hours);
 
239
  EXPECT_EQ(7, minutes);
 
240
  EXPECT_EQ(6, seconds);
 
241
}
 
242
 
 
243
TEST_F(DateTimeTest, from_int32_t_onValueCreatedBy_to_int32_t_shouldProduceOriginalDate)
 
244
{
 
245
  uint32_t years = 2030, months = 8, days = 17, hours = 14, minutes = 45, seconds = 13;
 
246
  Generator::DateTimeGen::make_datetime(&datetime, years, months, days, hours, minutes, seconds);
 
247
  uint32_t decoded_years, decoded_months, decoded_days;
 
248
  uint32_t decoded_hours, decoded_minutes, decoded_seconds;
 
249
  int64_t representation;
 
250
  DateTime decoded_datetime;
 
251
  
 
252
  datetime.to_int64_t(&representation);
 
253
  decoded_datetime.from_int64_t(representation);
 
254
  
 
255
  decoded_years = decoded_datetime.years();
 
256
  decoded_months = decoded_datetime.months();
 
257
  decoded_days = decoded_datetime.days();
 
258
  decoded_hours = decoded_datetime.hours();
 
259
  decoded_minutes = decoded_datetime.minutes();
 
260
  decoded_seconds = decoded_datetime.seconds();
 
261
  
 
262
  EXPECT_EQ(years, decoded_years);
 
263
  EXPECT_EQ(months, decoded_months);
 
264
  EXPECT_EQ(days, decoded_days);
 
265
  EXPECT_EQ(hours, decoded_hours);
 
266
  EXPECT_EQ(minutes, decoded_minutes);
 
267
  EXPECT_EQ(seconds, decoded_seconds);
 
268
}
 
269
 
 
270
TEST_F(DateTimeTest, to_tm)
 
271
{
 
272
  uint32_t years = 2030, months = 8, days = 17, hours = 14, minutes = 45, seconds = 13;
 
273
  Generator::DateTimeGen::make_datetime(&datetime, years, months, days, hours, minutes, seconds);
 
274
  struct tm filled;
 
275
  
 
276
  datetime.to_tm(&filled);
 
277
  
 
278
  EXPECT_EQ(130, filled.tm_year);
 
279
  EXPECT_EQ(7, filled.tm_mon);
 
280
  EXPECT_EQ(17, filled.tm_mday);
 
281
  EXPECT_EQ(14, filled.tm_hour);
 
282
  EXPECT_EQ(45, filled.tm_min);
 
283
  EXPECT_EQ(13, filled.tm_sec);
 
284
  EXPECT_EQ(228, filled.tm_yday);
 
285
  EXPECT_EQ(6, filled.tm_wday);
 
286
  EXPECT_GT(0, filled.tm_isdst);
 
287
}