← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to unittests/temporal_test.cc

removed all the repeated tests for different temporal descendants by making a typed test

Show diffs side-by-side

added added

removed removed

Lines of Context:
unittests/temporal_test.cc
27
27
 
28
28
using namespace drizzled;
29
29
 
30
 
class DateTest : public ::testing::Test {
 
30
template <typename TemporalType>
 
31
class DateTest : public ::testing::Test
 
32
{
31
33
 protected:
32
 
  Date sample_date, date_identical_with_sample_date;
33
 
  Date date_before_sample_date, date_after_sample_date;
34
 
  
35
 
  DateTime datetime_identical_with_sample_date;
36
 
  DateTime datetime_before_sample_date, datetime_after_sample_date;
37
 
  
38
 
  Timestamp timestamp_identical_with_sample_date;
39
 
  Timestamp timestamp_before_sample_date, timestamp_after_sample_date;
40
 
  
 
34
  Date sample_date;
 
35
  
 
36
  TemporalType identical_with_sample_date, before_sample_date, after_sample_date;
 
37
  
 
38
  void initBeforeIdenticalAfter();
 
39
 
41
40
  virtual void SetUp()
42
41
  {
43
42
    Generator::DateGen::make_date(&sample_date, 2010, 9, 8);
44
 
 
45
 
    Generator::DateGen::make_date(&date_before_sample_date, 1980, 1, 1);
46
 
    Generator::DateGen::make_date(&date_identical_with_sample_date, 2010, 9, 8);
47
 
    Generator::DateGen::make_date(&date_after_sample_date, 2019, 5, 30);
48
 
 
49
 
    Generator::DateTimeGen::make_datetime(&datetime_before_sample_date, 1990, 12, 31, 12, 12, 30, 1000);
50
 
    Generator::DateTimeGen::make_datetime(&datetime_identical_with_sample_date, 2010, 9, 8, 0, 0, 0, 0);
51
 
    Generator::DateTimeGen::make_datetime(&datetime_after_sample_date, 2020, 4, 4, 4, 4, 4, 4000);
52
 
    
53
 
    Generator::TimestampGen::make_timestamp(&timestamp_before_sample_date, 1980, 1, 1);
54
 
    Generator::TimestampGen::make_timestamp(&timestamp_identical_with_sample_date, 2010, 9, 8);
55
 
    Generator::TimestampGen::make_timestamp(&timestamp_after_sample_date, 2019, 5, 30);
56
 
 
 
43
    initBeforeIdenticalAfter();
57
44
  }
58
45
};
59
46
 
60
 
 
61
 
TEST_F(DateTest, operatorEqual_ComparingWithIdencticalDate_ShouldReturn_True)
62
 
{
63
 
  bool result= (sample_date == date_identical_with_sample_date);
64
 
  
65
 
  ASSERT_EQ(true, result);
66
 
}
67
 
 
68
 
TEST_F(DateTest, operatorEqual_ComparingWithDifferentDate_ShouldReturn_False)
69
 
{
70
 
  bool result= (sample_date == date_before_sample_date);
71
 
  
72
 
  ASSERT_EQ(false, result);
73
 
}
74
 
 
75
 
TEST_F(DateTest, operatorNotEqual_ComparingWithIdencticalDate_ShouldReturn_False)
76
 
{ 
77
 
  bool result= (sample_date != date_identical_with_sample_date);
78
 
  
79
 
  ASSERT_EQ(false, result);
80
 
}
81
 
 
82
 
TEST_F(DateTest, operatorNotEqual_ComparingWithDifferentDate_ShouldReturn_True)
83
 
{
84
 
  bool result= (sample_date != date_before_sample_date);
85
 
  
86
 
  ASSERT_EQ(true, result);
87
 
}
88
 
 
89
 
TEST_F(DateTest, operatorGreaterThan_ComparingWithIdenticalDate_ShouldReturn_False)
90
 
{
91
 
  bool result= (sample_date > date_identical_with_sample_date);
92
 
  
93
 
  ASSERT_EQ(false, result);
94
 
}
95
 
 
96
 
TEST_F(DateTest, operatorGreaterThan_ComparingWithLaterDate_ShouldReturn_False)
97
 
{
98
 
  bool result= (sample_date > date_after_sample_date);
99
 
  
100
 
  ASSERT_EQ(false, result);
101
 
}
102
 
 
103
 
TEST_F(DateTest, operatorGreaterThan_ComparingWithEarlierDate_ShouldReturn_True)
104
 
{
105
 
  bool result= (sample_date > date_before_sample_date);
106
 
  
107
 
  ASSERT_EQ(true, result);
108
 
}
109
 
 
110
 
TEST_F(DateTest, operatorGreaterThanOrEqual_ComparingWithIdenticalDate_ShouldReturn_True)
111
 
{
112
 
  bool result= (sample_date >= date_identical_with_sample_date);
113
 
  
114
 
  ASSERT_EQ(true, result);
115
 
}
116
 
 
117
 
TEST_F(DateTest, operatorGreaterThanOrEqual_ComparingWithLaterDate_ShouldReturn_False)
118
 
{
119
 
  bool result= (sample_date >= date_after_sample_date);
120
 
  
121
 
  ASSERT_EQ(false, result);
122
 
}
123
 
 
124
 
TEST_F(DateTest, operatorGreaterThanOrEqual_ComparingWithEarlierDate_ShouldReturn_True)
125
 
{
126
 
  bool result= (sample_date >= date_before_sample_date);
127
 
  
128
 
  ASSERT_EQ(true, result);
129
 
}
130
 
 
131
 
TEST_F(DateTest, operatorLessThan_ComparingWithIdenticalDate_ShouldReturn_False)
132
 
{
133
 
  bool result= (sample_date < date_identical_with_sample_date);
134
 
  
135
 
  ASSERT_EQ(false, result);
136
 
}
137
 
 
138
 
TEST_F(DateTest, operatorLessThan_ComparingWithLaterDate_ShouldReturn_True)
139
 
{
140
 
  bool result= (sample_date < date_after_sample_date);
141
 
  
142
 
  ASSERT_EQ(true, result);
143
 
}
144
 
 
145
 
TEST_F(DateTest, operatorLessThan_ComparingWithEarlierDate_ShouldReturn_False)
146
 
{
147
 
  bool result= (sample_date < date_before_sample_date);
148
 
  
149
 
  ASSERT_EQ(false, result);
150
 
}
151
 
 
152
 
TEST_F(DateTest, operatorLessThanOrEqual_ComparingWithIdenticalDate_ShouldReturn_True)
153
 
{
154
 
  bool result= (sample_date < date_identical_with_sample_date);
155
 
  
156
 
  ASSERT_EQ(true, result);
157
 
}
158
 
 
159
 
TEST_F(DateTest, operatorLessThanOrEqual_ComparingWithLaterDate_ShouldReturn_True)
160
 
{
161
 
  bool result= (sample_date < date_after_sample_date);
162
 
  
163
 
  ASSERT_EQ(true, result);
164
 
}
165
 
 
166
 
TEST_F(DateTest, operatorLessThanOrEqual_ComparingWithEarlierDate_ShouldReturn_False)
167
 
{
168
 
  bool result= (sample_date < date_before_sample_date);
169
 
  
170
 
  ASSERT_EQ(false, result);
171
 
}
172
 
 
173
 
/* Date operators for comparing with DateTime */
174
 
TEST_F(DateTest, operatorEqual_ComparingWithIdencticalDateTime_ShouldReturn_True)
175
 
{
176
 
  bool result= (sample_date == datetime_identical_with_sample_date);
177
 
  
178
 
  ASSERT_EQ(true, result);
179
 
}
180
 
 
181
 
TEST_F(DateTest, operatorEqual_ComparingWithDifferentDateTime_ShouldReturn_False)
182
 
{
183
 
  bool result= (sample_date == datetime_before_sample_date);
184
 
  
185
 
  ASSERT_EQ(false, result);
186
 
}
187
 
 
188
 
TEST_F(DateTest, operatorNotEqual_ComparingWithIdencticalDateTime_ShouldReturn_False)
189
 
{ 
190
 
  bool result= (sample_date != datetime_identical_with_sample_date);
191
 
  
192
 
  ASSERT_EQ(false, result);
193
 
}
194
 
 
195
 
TEST_F(DateTest, operatorNotEqual_ComparingWithDifferentDateTime_ShouldReturn_True)
196
 
{
197
 
  bool result= (sample_date != datetime_before_sample_date);
198
 
  
199
 
  ASSERT_EQ(true, result);
200
 
}
201
 
 
202
 
TEST_F(DateTest, operatorGreaterThan_ComparingWithIdenticalDateTime_ShouldReturn_False)
203
 
{
204
 
  bool result= (sample_date > datetime_identical_with_sample_date);
205
 
  
206
 
  ASSERT_EQ(false, result);
207
 
}
208
 
 
209
 
TEST_F(DateTest, operatorGreaterThan_ComparingWithLaterDateTime_ShouldReturn_False)
210
 
{
211
 
  bool result= (sample_date > datetime_after_sample_date);
212
 
  
213
 
  ASSERT_EQ(false, result);
214
 
}
215
 
 
216
 
TEST_F(DateTest, operatorGreaterThan_ComparingWithEarlierDateTime_ShouldReturn_True)
217
 
{
218
 
  bool result= (sample_date > datetime_before_sample_date);
219
 
  
220
 
  ASSERT_EQ(true, result);
221
 
}
222
 
 
223
 
TEST_F(DateTest, operatorGreaterThanOrEqual_ComparingWithIdenticalDateTime_ShouldReturn_True)
224
 
{
225
 
  bool result= (sample_date >= datetime_identical_with_sample_date);
226
 
  
227
 
  ASSERT_EQ(true, result);
228
 
}
229
 
 
230
 
TEST_F(DateTest, operatorGreaterThanOrEqual_ComparingWithLaterDateTime_ShouldReturn_False)
231
 
{
232
 
  bool result= (sample_date >= datetime_after_sample_date);
233
 
  
234
 
  ASSERT_EQ(false, result);
235
 
}
236
 
 
237
 
TEST_F(DateTest, operatorGreaterThanOrEqual_ComparingWithEarlierDateTime_ShouldReturn_True)
238
 
{
239
 
  bool result= (sample_date >= datetime_before_sample_date);
240
 
  
241
 
  ASSERT_EQ(true, result);
242
 
}
243
 
 
244
 
TEST_F(DateTest, operatorLessThan_ComparingWithIdenticalDateTime_ShouldReturn_False)
245
 
{
246
 
  bool result= (sample_date < datetime_identical_with_sample_date);
247
 
  
248
 
  ASSERT_EQ(false, result);
249
 
}
250
 
 
251
 
TEST_F(DateTest, operatorLessThan_ComparingWithLaterDateTime_ShouldReturn_True)
252
 
{
253
 
  bool result= (sample_date < datetime_after_sample_date);
254
 
  
255
 
  ASSERT_EQ(true, result);
256
 
}
257
 
 
258
 
TEST_F(DateTest, operatorLessThan_ComparingWithEarlierDateTime_ShouldReturn_False)
259
 
{
260
 
  bool result= (sample_date < datetime_before_sample_date);
261
 
  
262
 
  ASSERT_EQ(false, result);
263
 
}
264
 
 
265
 
TEST_F(DateTest, operatorLessThanOrEqual_ComparingWithIdenticalDateTime_ShouldReturn_True)
266
 
{
267
 
  bool result= (sample_date < datetime_identical_with_sample_date);
268
 
  
269
 
  ASSERT_EQ(true, result);
270
 
}
271
 
 
272
 
TEST_F(DateTest, operatorLessThanOrEqual_ComparingWithLaterDateTime_ShouldReturn_True)
273
 
{
274
 
  bool result= (sample_date < datetime_after_sample_date);
275
 
  
276
 
  ASSERT_EQ(true, result);
277
 
}
278
 
 
279
 
TEST_F(DateTest, operatorLessThanOrEqual_ComparingWithEarlierDateTime_ShouldReturn_False)
280
 
{
281
 
  bool result= (sample_date < datetime_before_sample_date);
282
 
  
283
 
  ASSERT_EQ(false, result);
284
 
}
285
 
 
286
 
 
287
 
/* Date operators for comparing with Timestamp */
288
 
TEST_F(DateTest, operatorEqual_ComparingWithIdencticalTimestamp_ShouldReturn_True)
289
 
{
290
 
  bool result= (sample_date == timestamp_identical_with_sample_date);
291
 
  
292
 
  ASSERT_EQ(true, result);
293
 
}
294
 
 
295
 
TEST_F(DateTest, operatorEqual_ComparingWithDifferentTimestamp_ShouldReturn_False)
296
 
{
297
 
  bool result= (sample_date == timestamp_before_sample_date);
298
 
  
299
 
  ASSERT_EQ(false, result);
300
 
}
301
 
 
302
 
TEST_F(DateTest, operatorNotEqual_ComparingWithIdencticalTimestamp_ShouldReturn_False)
303
 
{ 
304
 
  bool result= (sample_date != timestamp_identical_with_sample_date);
305
 
  
306
 
  ASSERT_EQ(false, result);
307
 
}
308
 
 
309
 
TEST_F(DateTest, operatorNotEqual_ComparingWithDifferentTimestamp_ShouldReturn_True)
310
 
{
311
 
  bool result= (sample_date != timestamp_before_sample_date);
312
 
  
313
 
  ASSERT_EQ(true, result);
314
 
}
315
 
 
316
 
TEST_F(DateTest, operatorGreaterThan_ComparingWithIdenticalTimestamp_ShouldReturn_False)
317
 
{
318
 
  bool result= (sample_date > timestamp_identical_with_sample_date);
319
 
  
320
 
  ASSERT_EQ(false, result);
321
 
}
322
 
 
323
 
TEST_F(DateTest, operatorGreaterThan_ComparingWithLaterTimestamp_ShouldReturn_False)
324
 
{
325
 
  bool result= (sample_date > timestamp_after_sample_date);
326
 
  
327
 
  ASSERT_EQ(false, result);
328
 
}
329
 
 
330
 
TEST_F(DateTest, operatorGreaterThan_ComparingWithEarlierTimestamp_ShouldReturn_True)
331
 
{
332
 
  bool result= (sample_date > timestamp_before_sample_date);
333
 
  
334
 
  ASSERT_EQ(true, result);
335
 
}
336
 
 
337
 
TEST_F(DateTest, operatorGreaterThanOrEqual_ComparingWithIdenticalTimestamp_ShouldReturn_True)
338
 
{
339
 
  bool result= (sample_date >= timestamp_identical_with_sample_date);
340
 
  
341
 
  ASSERT_EQ(true, result);
342
 
}
343
 
 
344
 
TEST_F(DateTest, operatorGreaterThanOrEqual_ComparingWithLaterTimestamp_ShouldReturn_False)
345
 
{
346
 
  bool result= (sample_date >= timestamp_after_sample_date);
347
 
  
348
 
  ASSERT_EQ(false, result);
349
 
}
350
 
 
351
 
TEST_F(DateTest, operatorGreaterThanOrEqual_ComparingWithEarlierTimestamp_ShouldReturn_True)
352
 
{
353
 
  bool result= (sample_date >= timestamp_before_sample_date);
354
 
  
355
 
  ASSERT_EQ(true, result);
356
 
}
357
 
 
358
 
TEST_F(DateTest, operatorLessThan_ComparingWithIdenticalTimestamp_ShouldReturn_False)
359
 
{
360
 
  bool result= (sample_date < timestamp_identical_with_sample_date);
361
 
  
362
 
  ASSERT_EQ(false, result);
363
 
}
364
 
 
365
 
TEST_F(DateTest, operatorLessThan_ComparingWithLaterTimestamp_ShouldReturn_True)
366
 
{
367
 
  bool result= (sample_date < timestamp_after_sample_date);
368
 
  
369
 
  ASSERT_EQ(true, result);
370
 
}
371
 
 
372
 
TEST_F(DateTest, operatorLessThan_ComparingWithEarlierTimestamp_ShouldReturn_False)
373
 
{
374
 
  bool result= (sample_date < timestamp_before_sample_date);
375
 
  
376
 
  ASSERT_EQ(false, result);
377
 
}
378
 
 
379
 
TEST_F(DateTest, operatorLessThanOrEqual_ComparingWithIdenticalTimestamp_ShouldReturn_True)
380
 
{
381
 
  bool result= (sample_date < timestamp_identical_with_sample_date);
382
 
  
383
 
  ASSERT_EQ(true, result);
384
 
}
385
 
 
386
 
TEST_F(DateTest, operatorLessThanOrEqual_ComparingWithLaterTimestamp_ShouldReturn_True)
387
 
{
388
 
  bool result= (sample_date < timestamp_after_sample_date);
389
 
  
390
 
  ASSERT_EQ(true, result);
391
 
}
392
 
 
393
 
TEST_F(DateTest, operatorLessThanOrEqual_ComparingWithEarlierTimestamp_ShouldReturn_False)
394
 
{
395
 
  bool result= (sample_date < timestamp_before_sample_date);
396
 
  
397
 
  ASSERT_EQ(false, result);
398
 
}
 
 
b'\\ No newline at end of file'
 
47
template<> void DateTest<Date>::initBeforeIdenticalAfter()
 
48
{
 
49
  Generator::DateGen::make_date(&before_sample_date, 1980, 1, 1);
 
50
  Generator::DateGen::make_date(&identical_with_sample_date, 2010, 9, 8);
 
51
  Generator::DateGen::make_date(&after_sample_date, 2019, 5, 30);
 
52
}
 
53
 
 
54
template<> void DateTest<DateTime>::initBeforeIdenticalAfter()
 
55
{
 
56
  Generator::DateTimeGen::make_datetime(&before_sample_date, 1990, 12, 31, 12, 12, 30, 1000);
 
57
  Generator::DateTimeGen::make_datetime(&identical_with_sample_date, 2010, 9, 8, 0, 0, 0, 0);
 
58
  Generator::DateTimeGen::make_datetime(&after_sample_date, 2020, 4, 4, 4, 4, 4, 4000);
 
59
}
 
60
 
 
61
template<> void DateTest<Timestamp>::initBeforeIdenticalAfter()
 
62
{
 
63
  Generator::TimestampGen::make_timestamp(&before_sample_date, 1980, 1, 1);
 
64
  Generator::TimestampGen::make_timestamp(&identical_with_sample_date, 2010, 9, 8);
 
65
  Generator::TimestampGen::make_timestamp(&after_sample_date, 2019, 5, 30);
 
66
}
 
67
 
 
68
typedef ::testing::Types<Date, DateTime, Timestamp> typesForDateTest;
 
69
TYPED_TEST_CASE(DateTest, typesForDateTest);
 
70
 
 
71
TYPED_TEST(DateTest, operatorEqual_ComparingWithIdencticalTemporal_ShouldReturn_True)
 
72
{
 
73
  bool result= (this->sample_date == this->identical_with_sample_date);
 
74
  
 
75
  ASSERT_EQ(true, result);
 
76
}
 
77
 
 
78
TYPED_TEST(DateTest, operatorEqual_ComparingWithDifferentTemporal_ShouldReturn_False)
 
79
{
 
80
  bool result= (this->sample_date == this->before_sample_date);
 
81
  
 
82
  ASSERT_EQ(false, result);
 
83
}
 
84
 
 
85
TYPED_TEST(DateTest, operatorNotEqual_ComparingWithIdencticalTemporal_ShouldReturn_False)
 
86
{ 
 
87
  bool result= (this->sample_date != this->identical_with_sample_date);
 
88
  
 
89
  ASSERT_EQ(false, result);
 
90
}
 
91
 
 
92
TYPED_TEST(DateTest, operatorNotEqual_ComparingWithDifferentTemporal_ShouldReturn_True)
 
93
{
 
94
  bool result= (this->sample_date != this->before_sample_date);
 
95
  
 
96
  ASSERT_EQ(true, result);
 
97
}
 
98
 
 
99
TYPED_TEST(DateTest, operatorGreaterThan_ComparingWithIdenticalTemporal_ShouldReturn_False)
 
100
{
 
101
  bool result= (this->sample_date > this->identical_with_sample_date);
 
102
  
 
103
  ASSERT_EQ(false, result);
 
104
}
 
105
 
 
106
TYPED_TEST(DateTest, operatorGreaterThan_ComparingWithLaterTemporal_ShouldReturn_False)
 
107
{
 
108
  bool result= (this->sample_date > this->after_sample_date);
 
109
  
 
110
  ASSERT_EQ(false, result);
 
111
}
 
112
 
 
113
TYPED_TEST(DateTest, operatorGreaterThan_ComparingWithEarlierTemporal_ShouldReturn_True)
 
114
{
 
115
  bool result= (this->sample_date > this->before_sample_date);
 
116
  
 
117
  ASSERT_EQ(true, result);
 
118
}
 
119
 
 
120
TYPED_TEST(DateTest, operatorGreaterThanOrEqual_ComparingWithIdenticalTemporal_ShouldReturn_True)
 
121
{
 
122
  bool result= (this->sample_date >= this->identical_with_sample_date);
 
123
  
 
124
  ASSERT_EQ(true, result);
 
125
}
 
126
 
 
127
TYPED_TEST(DateTest, operatorGreaterThanOrEqual_ComparingWithLaterTemporal_ShouldReturn_False)
 
128
{
 
129
  bool result= (this->sample_date >= this->after_sample_date);
 
130
  
 
131
  ASSERT_EQ(false, result);
 
132
}
 
133
 
 
134
TYPED_TEST(DateTest, operatorGreaterThanOrEqual_ComparingWithEarlierTemporal_ShouldReturn_True)
 
135
{
 
136
  bool result= (this->sample_date >= this->before_sample_date);
 
137
  
 
138
  ASSERT_EQ(true, result);
 
139
}
 
140
 
 
141
TYPED_TEST(DateTest, operatorLessThan_ComparingWithIdenticalTemporal_ShouldReturn_False)
 
142
{
 
143
  bool result= (this->sample_date < this->identical_with_sample_date);
 
144
  
 
145
  ASSERT_EQ(false, result);
 
146
}
 
147
 
 
148
TYPED_TEST(DateTest, operatorLessThan_ComparingWithLaterTemporal_ShouldReturn_True)
 
149
{
 
150
  bool result= (this->sample_date < this->after_sample_date);
 
151
  
 
152
  ASSERT_EQ(true, result);
 
153
}
 
154
 
 
155
TYPED_TEST(DateTest, operatorLessThan_ComparingWithEarlierTemporal_ShouldReturn_False)
 
156
{
 
157
  bool result= (this->sample_date < this->before_sample_date);
 
158
  
 
159
  ASSERT_EQ(false, result);
 
160
}
 
161
 
 
162
TYPED_TEST(DateTest, operatorLessThanOrEqual_ComparingWithIdenticalTemporal_ShouldReturn_True)
 
163
{
 
164
  bool result= (this->sample_date < this->identical_with_sample_date);
 
165
  
 
166
  ASSERT_EQ(true, result);
 
167
}
 
168
 
 
169
TYPED_TEST(DateTest, operatorLessThanOrEqual_ComparingWithLaterTemporal_ShouldReturn_True)
 
170
{
 
171
  bool result= (this->sample_date < this->after_sample_date);
 
172
  
 
173
  ASSERT_EQ(true, result);
 
174
}
 
175
 
 
176
TYPED_TEST(DateTest, operatorLessThanOrEqual_ComparingWithEarlierTemporal_ShouldReturn_False)
 
177
{
 
178
  bool result= (this->sample_date < this->before_sample_date);
 
179
  
 
180
  ASSERT_EQ(false, result);
 
181
}