← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to unittests/temporal_format_test.cc

  • Committer: Andrew Hutchings
  • Date: 2011-01-23 21:32:31 UTC
  • mto: (2108.1.1 build)
  • mto: This revision was merged to the branch mainline in revision 2109.
  • Revision ID: andrew@linuxjedi.co.uk-20110123213231-dp2r4enepa9k4g36
https://launchpad.net/bugs/667162
Convert all unit tests to boost::test
Add pandora support for boost::test
Remove pandora support for gtest

Show diffs side-by-side

added added

removed removed

Lines of Context:
unittests/temporal_format_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 <drizzled/temporal.h>
 
24
#include <drizzled/temporal_format.h>
 
25
 
 
26
#define BOOST_TEST_DYN_LINK
 
27
#include <boost/test/unit_test.hpp>
 
28
 
 
29
#include <vector>
 
30
 
 
31
#include "temporal_generator.h"
 
32
 
 
33
using namespace drizzled;
 
34
 
 
35
class TemporalFormatTest
 
36
{
 
37
  protected:
 
38
    TemporalFormat *tf;
 
39
    Temporal *temporal;
 
40
    bool result;
 
41
 
 
42
  TemporalFormatTest()
 
43
  {
 
44
    tf= NULL;
 
45
    temporal= NULL;
 
46
  }
 
47
 
 
48
  ~TemporalFormatTest()
 
49
  {
 
50
    if (tf != NULL)
 
51
      delete tf;
 
52
    if (temporal != NULL)
 
53
      delete temporal;
 
54
  }
 
55
};
 
56
 
 
57
BOOST_FIXTURE_TEST_SUITE(TemporalFormatTestSuite, TemporalFormatTest)
 
58
BOOST_AUTO_TEST_CASE(constructor_WithValidRegExp_shouldCompile)
 
59
{
 
60
  tf= new TemporalFormat("^(\\d{4})[-/.]$");
 
61
  
 
62
  result= tf->is_valid();
 
63
 
 
64
  BOOST_REQUIRE(result);
 
65
}
 
66
 
 
67
BOOST_AUTO_TEST_CASE(constructor_WithInvalidRegExp_shouldNotCompile)
 
68
{
 
69
  tf= new TemporalFormat("^\\d{4)[-/.]$");
 
70
 
 
71
  result= tf->is_valid();
 
72
  
 
73
  BOOST_REQUIRE(not result);
 
74
}
 
75
 
 
76
BOOST_AUTO_TEST_CASE(matches_OnNotMatchingString_shouldReturn_False)
 
77
{
 
78
  tf= new TemporalFormat("^(\\d{4})[-/.]$");
 
79
  char matched[] ="1234/ABC";
 
80
 
 
81
  result= tf->matches(matched, sizeof(matched) - sizeof(char), NULL);
 
82
  
 
83
  BOOST_REQUIRE(not result);
 
84
}
 
85
 
 
86
BOOST_AUTO_TEST_CASE(matches_OnMatchingString_FormatWithIndexesSet_shouldPopulateTemporal)
 
87
{
 
88
  char regexp[]= "^(\\d{4})[-/.](\\d{1,2})[-/.](\\d{1,2})[T|\\s+](\\d{2}):(\\d{2}):(\\d{2})$";
 
89
  char matched[]= "1999/9/14T23:29:05";
 
90
  tf= TemporalGenerator::TemporalFormatGen::make_temporal_format(regexp, 1, 2, 3, 4, 5, 6, 0, 0);
 
91
  temporal= new DateTime();
 
92
 
 
93
  
 
94
  result= tf->matches(matched, sizeof(matched) - sizeof(char), temporal);
 
95
  BOOST_REQUIRE(result);
 
96
  
 
97
  BOOST_REQUIRE_EQUAL(1999, temporal->years());
 
98
  BOOST_REQUIRE_EQUAL(9, temporal->months());
 
99
  BOOST_REQUIRE_EQUAL(14, temporal->days());
 
100
  BOOST_REQUIRE_EQUAL(23, temporal->hours());
 
101
  BOOST_REQUIRE_EQUAL(29, temporal->minutes());
 
102
  BOOST_REQUIRE_EQUAL(5, temporal->seconds());
 
103
}
 
104
 
 
105
BOOST_AUTO_TEST_CASE(matches_FormatWithMicroSecondIndexSet_shouldAddTrailingZeros)
 
106
{
 
107
  tf= TemporalGenerator::TemporalFormatGen::make_temporal_format("^(\\d{1,6})$", 0, 0, 0, 0, 0, 0, 1, 0);
 
108
  char matched[]= "560";
 
109
  temporal= new Time();
 
110
  
 
111
  tf->matches(matched, sizeof(matched) - sizeof(char), temporal);
 
112
  
 
113
  BOOST_REQUIRE_EQUAL(560000, temporal->useconds());
 
114
}
 
115
 
 
116
BOOST_AUTO_TEST_CASE(matches_FormatWithNanoSecondIndexSet_shouldAddTrailingZeros)
 
117
{
 
118
  tf= TemporalGenerator::TemporalFormatGen::make_temporal_format("^(\\d{1,9})$", 0, 0, 0, 0, 0, 0, 0, 1);
 
119
  char matched[]= "4321";
 
120
  temporal= new Time();
 
121
  
 
122
  tf->matches(matched, sizeof(matched) - sizeof(char), temporal);
 
123
  
 
124
  BOOST_REQUIRE_EQUAL(432100000, temporal->nseconds());
 
125
}
 
126
BOOST_AUTO_TEST_SUITE_END()
 
127
 
 
128
namespace drizzled
 
129
{
 
130
extern std::vector<TemporalFormat *> known_datetime_formats;
 
131
extern std::vector<TemporalFormat *> known_date_formats;
 
132
extern std::vector<TemporalFormat *> known_time_formats;
 
133
extern std::vector<TemporalFormat *> all_temporal_formats;
 
134
}
 
135
 
 
136
BOOST_AUTO_TEST_SUITE(TemporalFormatTestSuite)
 
137
BOOST_AUTO_TEST_CASE(init_temporal_formats_vectorsWithKnownFormats_shouldHaveExpectedLengths)
 
138
{
 
139
  init_temporal_formats();
 
140
 
 
141
  BOOST_REQUIRE_EQUAL(13, known_datetime_formats.size());       
 
142
  BOOST_REQUIRE_EQUAL(8, known_date_formats.size());
 
143
  BOOST_REQUIRE_EQUAL(11, known_time_formats.size());
 
144
  BOOST_REQUIRE_EQUAL(19, all_temporal_formats.size());
 
145
}
 
146
 
 
147
BOOST_AUTO_TEST_CASE(deinit_temporal_formats_vectorsWithKnownFormats_shouldHaveZeroLengths)
 
148
{
 
149
  init_temporal_formats();
 
150
  deinit_temporal_formats();
 
151
  
 
152
  BOOST_REQUIRE_EQUAL(0, known_datetime_formats.size());
 
153
  BOOST_REQUIRE_EQUAL(0, known_date_formats.size());
 
154
  BOOST_REQUIRE_EQUAL(0, known_time_formats.size());
 
155
  BOOST_REQUIRE_EQUAL(0, all_temporal_formats.size());
 
156
}
 
157
BOOST_AUTO_TEST_SUITE_END()