Merge lp:~linuxjedi/drizzle/trunk-unittests into lp:drizzle/7.0

[Andrew Hutchings]

Fix or remove disabled unit tests
Port unit tests to boost::test and remove gtest dependency

[lp:~linuxjedi/drizzle/trunk-unittests]

2103. By Andrew Hutchings on 2011-01-24

Merge trunk into branch

2104. By Andrew Hutchings on 2011-01-24

Remove gtest dependency from docs

2105. By Andrew Hutchings on 2011-01-24

And add boost::test to the doc

=== modified file 'configure.ac'
--- configure.ac	2010-12-19 16:20:13 +0000
+++ configure.ac	2011-01-24 09:18:02 +0000
@@ -83,7 +83,7 @@
 AC_DEFINE([BUILDING_DRIZZLED],[1],
           [Define indicating we are building and not consuming drizzle.])
 
-PANDORA_HAVE_LIBGTEST
+PANDORA_HAVE_BOOST_TEST
 PANDORA_HAVE_LIBSQLITE3
 
 AC_CHECK_FUNC(inet_ntoa, [], [AC_CHECK_LIB(nsl, inet_ntoa)])
 
=== modified file 'docs/installing/from_source.rst'
--- docs/installing/from_source.rst	2011-01-21 13:56:53 +0000
+++ docs/installing/from_source.rst	2011-01-24 09:18:02 +0000
@@ -22,8 +22,8 @@
  * libboost-iostreams-dev
  * libboost-program-options-dev
  * libboost-regex-dev
+ * libboost-test-dev
  * libboost-thread-dev
- * libgtest (1.5.0)
  * libpcre3-dev
  * libreadline5-dev | libreadline-dev
  * libtool
 
=== modified file 'docs/installing/requirements.rst'
--- docs/installing/requirements.rst	2011-01-21 13:56:53 +0000
+++ docs/installing/requirements.rst	2011-01-24 09:18:02 +0000
@@ -18,7 +18,8 @@
  * Apple OSX 10.6.4
 
 We recommend using these platforms with Drizzle, older version may have various
-unforseen difficulties when compiling and/or installing.
+unforseen difficulties when compiling and/or installing.  Drizzle is tested on
+both 32bit and 64bit platforms but we recommend using a 64bit platform.
 
 Software Requirements
 ---------------------
 
=== added file 'm4/pandora_have_libboost_test.m4'
--- m4/pandora_have_libboost_test.m4	1970-01-01 00:00:00 +0000
+++ m4/pandora_have_libboost_test.m4	2011-01-24 09:18:02 +0000
@@ -0,0 +1,45 @@
+dnl Copyright (C) 2011 Andrew Hutchings
+dnl This file is free software; Andrew Hutchings
+dnl gives unlimited permission to copy and/or distribute it,
+dnl with or without modifications, as long as this notice is preserved.
+
+AC_DEFUN([_PANDORA_SEARCH_BOOST_TEST],[
+  AC_REQUIRE([AC_LIB_PREFIX])
+
+  dnl --------------------------------------------------------------------
+  dnl  Check for boost::test
+  dnl --------------------------------------------------------------------
+
+  AC_LANG_PUSH(C++)
+  AC_LIB_HAVE_LINKFLAGS(boost_unit_test_framework-mt,,[
+    #include <boost/test/unit_test.hpp>
+  ],[
+    boost::unit_test::unit_test_log.set_threshold_level(boost::unit_test::log_messages);
+  ])
+  AS_IF([test "x${ac_cv_libboost_test_framework_mt}" = "xno"],[
+    AC_LIB_HAVE_LINKFLAGS(boost_unit_test_framework,,[
+      #include <boost/test/unit_test.hpp>
+    ],[
+      boost::unit_test::unit_test_log.set_threshold_level(boost::unit_test::log_messages);
+    ])
+  ])
+  AC_LANG_POP()
+  
+  AM_CONDITIONAL(HAVE_BOOST_TEST,
+    [test "x${ac_cv_libboost_test_framework}" = "xyes" -o "x${ac_cv_libboost_test_framework_mt}" = "xyes"])
+  BOOST_LIBS="${BOOST_LIBS} ${LTLIBBOOST_TEST_MT} ${LTLIBBOOST_TEST}"
+  AC_SUBST(BOOST_LIBS) 
+])
+
+AC_DEFUN([PANDORA_HAVE_BOOST_TEST],[
+  PANDORA_HAVE_BOOST($1)
+  _PANDORA_SEARCH_BOOST_TEST($1)
+])
+
+AC_DEFUN([PANDORA_REQUIRE_BOOST_TEST],[
+  PANDORA_REQUIRE_BOOST($1)
+  _PANDORA_SEARCH_BOOST_TEST($1)
+  AS_IF([test "x${ac_cv_libboost_test_framework}" = "xno" -a "x${ac_cv_libboost_test_framework_mt}" = "xno"],
+      AC_MSG_ERROR([boost::test is required for ${PACKAGE}]))
+])
+
 
=== removed file 'm4/pandora_have_libgtest.m4'
--- m4/pandora_have_libgtest.m4	2010-09-19 18:03:28 +0000
+++ m4/pandora_have_libgtest.m4	1970-01-01 00:00:00 +0000
@@ -1,47 +0,0 @@
-dnl Copyright (C) 2010 Monty Taylor
-dnl This file is free software; Monty Taylor
-dnl gives unlimited permission to copy and/or distribute it,
-dnl with or without modifications, as long as this notice is preserved.
-
-AC_DEFUN([_PANDORA_SEARCH_LIBGTEST],[
-  AC_REQUIRE([AC_LIB_PREFIX])
-
-  dnl --------------------------------------------------------------------
-  dnl  Check for libgtest
-  dnl --------------------------------------------------------------------
-
-  AC_ARG_ENABLE([libgtest],
-    [AS_HELP_STRING([--disable-libgtest],
-      [Build with libgtest support @<:@default=on@:>@])],
-    [ac_enable_libgtest="$enableval"],
-    [ac_enable_libgtest="yes"])
-
-  AS_IF([test "x$ac_enable_libgtest" = "xyes"],[
-    AC_LANG_PUSH(C++)
-    save_CXXFLAGS="${CXXFLAGS}"
-    CXXFLAGS="${AM_CXXFLAGS} ${CXXFLAGS}"
-    AC_LIB_HAVE_LINKFLAGS(gtest,,[
-      #include <gtest/gtest.h>
-TEST(pandora_test_libgtest, PandoraTest)
-{
-  ASSERT_EQ(1, 1);
-}
-    ],[])
-    CXXFLAGS="${save_CXXFLAGS}"
-    AC_LANG_POP()
-  ],[
-    ac_cv_libgtest="no"
-  ])
-
-  AM_CONDITIONAL(HAVE_LIBGTEST, [test "x${ac_cv_libgtest}" = "xyes"])
-])
-
-AC_DEFUN([PANDORA_HAVE_LIBGTEST],[
-  AC_REQUIRE([_PANDORA_SEARCH_LIBGTEST])
-])
-
-AC_DEFUN([PANDORA_REQUIRE_LIBGTEST],[
-  AC_REQUIRE([_PANDORA_SEARCH_LIBGTEST])
-  AS_IF([test "x${ac_cv_libgtest}" = "xno"],
-    AC_MSG_ERROR([libgtest is required for ${PACKAGE}]))
-])
 
=== modified file 'unittests/atomics_test.cc'
--- unittests/atomics_test.cc	2010-10-20 09:32:35 +0000
+++ unittests/atomics_test.cc	2011-01-24 09:18:02 +0000
@@ -19,101 +19,87 @@
  */
 
 #include "config.h"
-
-#include <gtest/gtest.h>
+#define BOOST_TEST_DYN_LINK
+#include <boost/test/unit_test.hpp>
 
 #include <drizzled/atomics.h>
 
 using namespace drizzled;
 
-TEST(atomic_operations, fetch_and_store)
-{
-  atomic<uint32_t> u235;
-
-  EXPECT_EQ(0, u235.fetch_and_store(1));
-
-  u235.fetch_and_store(15);
-
-  EXPECT_EQ(15, u235.fetch_and_store(100));
-  EXPECT_EQ(100, u235);
-}
-
-TEST(atomic_operations, fetch_and_increment)
-{
-  atomic<uint32_t> u235;
-
-  EXPECT_EQ(0, u235.fetch_and_increment());
-  EXPECT_EQ(1, u235);
-}
-
-TEST(atomic_operations, fetch_and_add)
-{
-  atomic<uint32_t> u235;
-
-  EXPECT_EQ(0, u235.fetch_and_add(2));
-  EXPECT_EQ(2, u235);
-}
-
-TEST(atomic_operations, add_and_fetch)
-{
-  atomic<uint32_t> u235;
-
-  EXPECT_EQ(10, u235.add_and_fetch(10));
-  EXPECT_EQ(10, u235);
-}
-
-TEST(atomic_operations, fetch_and_decrement)
-{
-  atomic<uint32_t> u235;
-
-  u235.fetch_and_store(15);
-
-  EXPECT_EQ(15, u235.fetch_and_decrement());
-  EXPECT_EQ(14, u235);
-}
-
-TEST(atomic_operations, compare_and_swap)
+BOOST_AUTO_TEST_SUITE(AtomicOperations)
+BOOST_AUTO_TEST_CASE(fetch_and_store)
+{
+  atomic<uint32_t> u235;
+
+  BOOST_REQUIRE_EQUAL(0, u235.fetch_and_store(1));
+
+  u235.fetch_and_store(15);
+
+  BOOST_REQUIRE_EQUAL(15, u235.fetch_and_store(100));
+  BOOST_REQUIRE_EQUAL(100, u235);
+}
+
+BOOST_AUTO_TEST_CASE(fetch_and_increment)
+{
+  atomic<uint32_t> u235;
+
+  BOOST_REQUIRE_EQUAL(0, u235.fetch_and_increment());
+  BOOST_REQUIRE_EQUAL(1, u235);
+}
+
+BOOST_AUTO_TEST_CASE(fetch_and_add)
+{
+  atomic<uint32_t> u235;
+
+  BOOST_REQUIRE_EQUAL(0, u235.fetch_and_add(2));
+  BOOST_REQUIRE_EQUAL(2, u235);
+}
+
+BOOST_AUTO_TEST_CASE(add_and_fetch)
+{
+  atomic<uint32_t> u235;
+
+  BOOST_REQUIRE_EQUAL(10, u235.add_and_fetch(10));
+  BOOST_REQUIRE_EQUAL(10, u235);
+}
+
+BOOST_AUTO_TEST_CASE(fetch_and_decrement)
+{
+  atomic<uint32_t> u235;
+
+  u235.fetch_and_store(15);
+
+  BOOST_REQUIRE_EQUAL(15, u235.fetch_and_decrement());
+  BOOST_REQUIRE_EQUAL(14, u235);
+}
+
+BOOST_AUTO_TEST_CASE(compare_and_swap)
 {
   atomic<uint32_t> u235;
 
   u235.fetch_and_store(100);
 
-  ASSERT_FALSE(u235.compare_and_swap(42, 200));
-  ASSERT_TRUE(u235.compare_and_swap(200, 100));
-  EXPECT_EQ(200, u235);
-}
-
-TEST(atomic_operations, increment)
-{
-  atomic<uint32_t> u235;
-  u235.fetch_and_store(200);
-  EXPECT_EQ(201, u235.increment());
-}
-
-TEST(atomic_operations, decrement)
-{
-  atomic<uint32_t> u235;
-  u235.fetch_and_store(200);
-
-  EXPECT_EQ(199, u235.decrement());
-}
-
-/*
-TEST(atomic_operations, increment_assign)
-{
-  atomic<uint32_t> u235;
-  u235.fetch_and_store(200);
-
-  EXPECT_EQ(242, u235+=42);
-}
-
-TEST(atomic_operations, decrement_assign)
-{
-  atomic<uint32_t> u235;
-  u235.fetch_and_store(200);
-
-  EXPECT_EQ(158, u235-=42);
-}
-*/
-
+  BOOST_REQUIRE(not u235.compare_and_swap(42, 200));
+  BOOST_REQUIRE(u235.compare_and_swap(200, 100));
+  BOOST_REQUIRE_EQUAL(200, u235);
+}
+
+BOOST_AUTO_TEST_CASE(increment)
+{
+  atomic<uint32_t> u235;
+  u235.fetch_and_store(200);
+  BOOST_REQUIRE_EQUAL(201, u235.increment());
+}
+
+BOOST_AUTO_TEST_CASE(decrement)
+{
+  atomic<uint32_t> u235;
+  u235.fetch_and_store(200);
+
+  BOOST_REQUIRE_EQUAL(199, u235.decrement());
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+/* TODO: add tests for += and -= when supported */
 
 
=== modified file 'unittests/calendar_test.cc'
--- unittests/calendar_test.cc	2011-01-20 07:24:29 +0000
+++ unittests/calendar_test.cc	2011-01-24 09:18:02 +0000
@@ -19,113 +19,113 @@
  */
 
 #include "config.h"
-
-#include <gtest/gtest.h>
+#define BOOST_TEST_DYN_LINK
+#include <boost/test/unit_test.hpp>
 
 #include <drizzled/calendar.h>
 
 using namespace drizzled;
-
-TEST(calendar_julian_day_number_from_gregorian_date_test, CalculationTest)
+BOOST_AUTO_TEST_SUITE(CalculationTest)
+BOOST_AUTO_TEST_CASE(calendar_julian_day_number_from_gregorian_date_test)
 {
   uint32_t year, month, day;
 
   year= 2010; month= 4; day= 2;
-  EXPECT_EQ(2455289, julian_day_number_from_gregorian_date(year, month, day));
+  BOOST_REQUIRE_EQUAL(2455289, julian_day_number_from_gregorian_date(year, month, day));
   
   year= 1976; month= 12; day= 21;
-  EXPECT_EQ(2443134, julian_day_number_from_gregorian_date(year, month, day));
+  BOOST_REQUIRE_EQUAL(2443134, julian_day_number_from_gregorian_date(year, month, day));
   
   year= 2050; month= 6; day= 15;
-  EXPECT_EQ(2469973, julian_day_number_from_gregorian_date(year, month, day));
+  BOOST_REQUIRE_EQUAL(2469973, julian_day_number_from_gregorian_date(year, month, day));
   
   year= 1999; month= 12; day= 31;
-  EXPECT_EQ(2451544, julian_day_number_from_gregorian_date(year, month, day));
+  BOOST_REQUIRE_EQUAL(2451544, julian_day_number_from_gregorian_date(year, month, day));
   
   year= 2008; month= 2; day= 29;
-  EXPECT_EQ(2454526, julian_day_number_from_gregorian_date(year, month, day));
+  BOOST_REQUIRE_EQUAL(2454526, julian_day_number_from_gregorian_date(year, month, day));
 }
 
-TEST(calendar_gregorian_date_from_julian_day_number_test, CalculationTest)
+BOOST_AUTO_TEST_CASE(calendar_gregorian_date_from_julian_day_number_test)
 {
   int64_t julian_day;
   uint32_t year_out, month_out, day_out;
   
   julian_day= 2455289;
   gregorian_date_from_julian_day_number(julian_day, &year_out, &month_out, &day_out);
-  EXPECT_TRUE((year_out == 2010) && (month_out == 4) && (day_out == 2));
+  BOOST_REQUIRE((year_out == 2010) && (month_out == 4) && (day_out == 2));
   
   julian_day= 2443134;
   gregorian_date_from_julian_day_number(julian_day, &year_out, &month_out, &day_out);
-  EXPECT_TRUE((year_out == 1976) && (month_out == 12) && (day_out == 21));
+  BOOST_REQUIRE((year_out == 1976) && (month_out == 12) && (day_out == 21));
   
   julian_day= 2469973;
   gregorian_date_from_julian_day_number(julian_day, &year_out, &month_out, &day_out);
-  EXPECT_TRUE((year_out == 2050) && (month_out == 6) && (day_out == 15));
+  BOOST_REQUIRE((year_out == 2050) && (month_out == 6) && (day_out == 15));
   
   julian_day= 2451544;
   gregorian_date_from_julian_day_number(julian_day, &year_out, &month_out, &day_out);
-  EXPECT_TRUE((year_out == 1999) && (month_out == 12) && (day_out == 31));
+  BOOST_REQUIRE((year_out == 1999) && (month_out == 12) && (day_out == 31));
   
   julian_day= 2454526;
   gregorian_date_from_julian_day_number(julian_day, &year_out, &month_out, &day_out);
-  EXPECT_TRUE((year_out == 2008) && (month_out == 2) && (day_out == 29));
-}
-
-
-
-
-TEST(calendar_day_of_week_test, MondayFirst)
-{
-  /* Friday 2010 IV 2 */
-  ASSERT_EQ(4, day_of_week(2455289, false));
-}
-
-TEST(calendar_day_of_week_test, SundayFirst)
-{
-  /* Friday 2010 IV 2 */
-  ASSERT_EQ(5, day_of_week(2455289, true));
-}
-
-
-
-
-TEST(calendar_in_unix_epoch_range_test, MinOfRange)
+  BOOST_REQUIRE((year_out == 2008) && (month_out == 2) && (day_out == 29));
+}
+BOOST_AUTO_TEST_SUITE_END()
+
+BOOST_AUTO_TEST_SUITE(DayOfWeek)
+BOOST_AUTO_TEST_CASE(MondayFirst)
+{
+  /* Friday 2010 IV 2 */
+  BOOST_REQUIRE_EQUAL(4, day_of_week(2455289, false));
+}
+
+BOOST_AUTO_TEST_CASE(SundayFirst)
+{
+  /* Friday 2010 IV 2 */
+  BOOST_REQUIRE_EQUAL(5, day_of_week(2455289, true));
+}
+BOOST_AUTO_TEST_SUITE_END()
+
+
+BOOST_AUTO_TEST_SUITE(CalendarInUnixEpochRange)
+BOOST_AUTO_TEST_CASE(MinOfRange)
 {
   uint32_t year= 1970, month= 1, day= 1, hour= 0, minute= 0, second= 0;
 
-  ASSERT_TRUE(in_unix_epoch_range(year, month, day, hour, minute, second));
+  BOOST_REQUIRE(in_unix_epoch_range(year, month, day, hour, minute, second));
 }
 
-TEST(calendar_in_unix_epoch_range_test, MaxOfRange)
+BOOST_AUTO_TEST_CASE(MaxOfRange)
 {
   uint32_t year= 2038, month= 1, day= 19, hour= 3, minute= 14, second= 7;
 
-  ASSERT_TRUE(in_unix_epoch_range(year, month, day, hour, minute, second));
+  BOOST_REQUIRE(in_unix_epoch_range(year, month, day, hour, minute, second));
 }
 
-TEST(calendar_in_unix_epoch_range_test, OneSecondBeforeMinOfRange)
+BOOST_AUTO_TEST_CASE(OneSecondBeforeMinOfRange)
 {
   uint32_t year= 1969, month= 12, day= 31, hour= 23, minute= 59, second= 59;
 
-  ASSERT_FALSE(in_unix_epoch_range(year, month, day, hour, minute, second));
+  BOOST_REQUIRE(not in_unix_epoch_range(year, month, day, hour, minute, second));
 }
 
-TEST(calendar_in_unix_epoch_range_test, OneSecondAfterMaxOfRange)
+BOOST_AUTO_TEST_CASE(OneSecondAfterMaxOfRange)
 {
   uint32_t year= 2038, month= 1, day= 19, hour= 3, minute= 14, second= 8;
 
-  ASSERT_FALSE(in_unix_epoch_range(year, month, day, hour, minute, second));
+  BOOST_REQUIRE(not in_unix_epoch_range(year, month, day, hour, minute, second));
 }
 
-TEST(calendar_in_unix_epoch_range_test, InsideRange)
+BOOST_AUTO_TEST_CASE(InsideRange)
 {
   uint32_t year= 1980, month= 11, day= 1, hour= 5, minute= 8, second= 5;
-  EXPECT_TRUE(in_unix_epoch_range(year, month, day, hour, minute, second));
+  BOOST_REQUIRE(in_unix_epoch_range(year, month, day, hour, minute, second));
 
   year= 2010; month= 4; day= 2; hour= 21; minute= 44; second= 0;
-  EXPECT_TRUE(in_unix_epoch_range(year, month, day, hour, minute, second));
+  BOOST_REQUIRE(in_unix_epoch_range(year, month, day, hour, minute, second));
 
   year= 2020; month= 7; day= 13; hour= 16; minute= 56; second= 59;
-  EXPECT_TRUE(in_unix_epoch_range(year, month, day, hour, minute, second));
+  BOOST_REQUIRE(in_unix_epoch_range(year, month, day, hour, minute, second));
 }
+BOOST_AUTO_TEST_SUITE_END()
 
=== removed file 'unittests/client_server.c'
--- unittests/client_server.c	2010-12-04 02:13:38 +0000
+++ unittests/client_server.c	1970-01-01 00:00:00 +0000
@@ -1,567 +0,0 @@
-/*
- * Drizzle Client & Protocol Library
- *
- * Copyright (C) 2008 Eric Day ([e-mail])
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *
- *     * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *     * The names of its contributors may not be used to endorse or
- * promote products derived from this software without specific prior
- * written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-/**
- * @file
- * @brief Tests for drizzle_st Structures
- */
-
-#include "common.h"
-
-#include <assert.h>
-
-#define DRIZZLE_TEST_HOST "127.0.0.1"
-#define DRIZZLE_TEST_PORT 12399
-
-typedef enum
-{
-  SERVER_STATE_START,
-  SERVER_STATE_HANDSHAKE_WRITE,
-  SERVER_STATE_HANDSHAKE_READ,
-  SERVER_STATE_HANDSHAKE_RESULT,
-  SERVER_STATE_COMMAND_BUFFER,
-  SERVER_STATE_RESULT_HEADER,
-  SERVER_STATE_RESULT_COLUMN_1,
-  SERVER_STATE_RESULT_COLUMN_2,
-  SERVER_STATE_RESULT_COLUMN_EOF,
-  SERVER_STATE_RESULT_ROW_1,
-  SERVER_STATE_RESULT_ROW_1_FIELD_1,
-  SERVER_STATE_RESULT_ROW_1_FIELD_2,
-  SERVER_STATE_RESULT_ROW_EOF,
-  SERVER_STATE_DONE
-} server_state_t;
-
-typedef struct
-{
-  server_state_t state;
-  drizzle_result_st result;
-  drizzle_column_st column;
-  drizzle_command_t command;
-  char *data;
-  size_t total;
-} server_state_st;
-
-typedef enum
-{
-  CLIENT_STATE_START,
-  CLIENT_STATE_RESULT,
-  CLIENT_STATE_DONE
-} client_state_t;
-
-typedef struct
-{
-  client_state_t state;
-  drizzle_result_st result;
-} client_state_st;
-
-static void _server(drizzle_con_st *con, server_state_st *state);
-static void _client(drizzle_con_st *con, client_state_st *state);
-
-int main(void)
-{
-  drizzle_st drizzle;
-  drizzle_con_st listen_con;
-  drizzle_con_st client;
-  drizzle_con_st server;
-  drizzle_return_t ret;
-  bool server_accepted = false;
-  server_state_st server_state;
-  client_state_st client_state;
-
-  drizzle_test("drizzle_create");
-  if (drizzle_create(&drizzle) == NULL)
-    drizzle_test_error("returned NULL");
-
-  drizzle_test("drizzle_con_add_tcp_listen");
-  if (drizzle_con_add_tcp_listen(&drizzle, &listen_con, DRIZZLE_TEST_HOST,
-                                 DRIZZLE_TEST_PORT, 1,
-                                 DRIZZLE_CON_NONE) == NULL)
-  {
-    drizzle_test_error("returned NULL");
-  }
-
-  drizzle_test("drizzle_con_listen");
-  ret= drizzle_con_listen(&listen_con);
-  if (ret != DRIZZLE_RETURN_OK)
-    drizzle_test_error("returned %s (%d)", drizzle_error(&drizzle), ret);
-
-  drizzle_test("drizzle_con_add_tcp");
-  if (drizzle_con_add_tcp(&drizzle, &client, DRIZZLE_TEST_HOST,
-                          DRIZZLE_TEST_PORT, NULL, NULL, NULL,
-                          DRIZZLE_CON_NONE) == NULL)
-  {
-    drizzle_test_error("returned NULL");
-  }
-
-  drizzle_test("drizzle_add_options");
-  drizzle_add_options(&drizzle, DRIZZLE_NON_BLOCKING);
-
-  server_state.state= SERVER_STATE_START;
-  client_state.state= CLIENT_STATE_START;
-
-  while (true)
-  {
-    if (!server_accepted)
-    {
-      drizzle_test("drizzle_con_accept");
-      (void)drizzle_con_accept(&drizzle, &server, &ret);
-      if (ret == DRIZZLE_RETURN_OK)
-        server_accepted = true;
-      else if (ret != DRIZZLE_RETURN_IO_WAIT)
-        drizzle_test_error("returned %s (%d)", drizzle_error(&drizzle), ret);
-    }
-
-    if (server_accepted)
-      _server(&server, &server_state);
-
-    _client(&client, &client_state);
-
-    if (server_state.state == SERVER_STATE_DONE &&
-        client_state.state == CLIENT_STATE_DONE)
-    {
-      break;
-    }
-
-    drizzle_test("drizzle_con_wait");
-    ret= drizzle_con_wait(&drizzle);
-    if (ret != DRIZZLE_RETURN_OK)
-      drizzle_test_error("returned %s (%d)", drizzle_error(&drizzle), ret);
-  }
-
-  if (server_accepted)
-  {
-    drizzle_test("drizzle_con_free");
-    drizzle_con_free(&server);
-  }
-
-  drizzle_test("drizzle_con_free");
-  drizzle_con_free(&client);
-
-  drizzle_test("drizzle_con_free");
-  drizzle_con_free(&listen_con);
-
-  drizzle_test("drizzle_free");
-  drizzle_free(&drizzle);
-
-  return 0;
-}
-
-static void _server(drizzle_con_st *con, server_state_st *state)
-{
-  drizzle_return_t ret;
-  const drizzle_field_t const fields[2]=
-  {
-    (const drizzle_field_t)"test_field_1",
-    (const drizzle_field_t)"test_field_2"
-  };
-  const size_t field_sizes[2]= { 12, 12 };
-
-  switch(state->state)
-  {
-  case SERVER_STATE_START:
-    drizzle_con_set_protocol_version(con, 10);
-    drizzle_con_set_server_version(con, "test_version");
-    drizzle_con_set_thread_id(con, 1);
-    drizzle_con_set_scramble(con, (const uint8_t *)"ABCDEFGHIJKLMNOPQRST");
-    drizzle_con_set_capabilities(con, DRIZZLE_CAPABILITIES_NONE);
-    drizzle_con_set_charset(con, 8);
-    drizzle_con_set_status(con, DRIZZLE_CON_STATUS_NONE);
-    drizzle_con_set_max_packet_size(con, DRIZZLE_MAX_PACKET_SIZE);
-
-  case SERVER_STATE_HANDSHAKE_WRITE:
-    drizzle_test("drizzle_handshake_server_write");
-    ret= drizzle_handshake_server_write(con);
-    if (ret == DRIZZLE_RETURN_IO_WAIT)
-    {
-      state->state = SERVER_STATE_HANDSHAKE_WRITE;
-      return;
-    }
-    else if (ret != DRIZZLE_RETURN_OK)
-      drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
-
-  case SERVER_STATE_HANDSHAKE_READ:
-    drizzle_test("drizzle_handshake_client_read");
-    ret= drizzle_handshake_client_read(con);
-    if (ret == DRIZZLE_RETURN_IO_WAIT)
-    {
-      state->state = SERVER_STATE_HANDSHAKE_READ;
-      return;
-    }
-    else if (ret != DRIZZLE_RETURN_OK)
-      drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
-
-    drizzle_test("drizzle_result_create");
-    if (drizzle_result_create(con, &state->result) == NULL)
-      drizzle_test_error("returned %s", drizzle_con_error(con));
-
-  case SERVER_STATE_HANDSHAKE_RESULT:
-    drizzle_test("drizzle_handshake_result_write");
-    ret= drizzle_result_write(con, &state->result, true);
-    if (ret == DRIZZLE_RETURN_IO_WAIT)
-    {
-      state->state = SERVER_STATE_HANDSHAKE_RESULT;
-      return;
-    }
-    else if (ret != DRIZZLE_RETURN_OK)
-      drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
-
-    drizzle_result_free(&state->result);
-
-  case SERVER_STATE_COMMAND_BUFFER:
-    drizzle_test("drizzle_con_command_buffer");
-    state->data= drizzle_con_command_buffer(con, &state->command, &state->total,
-                                            &ret);
-    if (ret == DRIZZLE_RETURN_IO_WAIT)
-    {
-      state->state = SERVER_STATE_COMMAND_BUFFER;
-      return;
-    }
-    else if (ret != DRIZZLE_RETURN_OK)
-      drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
-
-    if (state->command != DRIZZLE_COMMAND_QUERY)
-      drizzle_test_error("command was not a query");
-
-    if (state->total != 6 && !memcmp(state->data, "SELECT", 6))
-      drizzle_test_error("query doesn't match");
-
-    if (state->data != NULL)
-    {
-      free(state->data);
-      state->data= NULL;
-    }
-
-    drizzle_test("drizzle_result_create");
-    if (drizzle_result_create(con, &state->result) == NULL)
-      drizzle_test_error("returned %s", drizzle_con_error(con));
-
-    drizzle_result_set_column_count(&state->result, 2);
-
-  case SERVER_STATE_RESULT_HEADER:
-    drizzle_test("drizzle_handshake_result_write");
-    ret= drizzle_result_write(con, &state->result, false);
-    if (ret == DRIZZLE_RETURN_IO_WAIT)
-    {
-      state->state = SERVER_STATE_RESULT_HEADER;
-      return;
-    }
-    else if (ret != DRIZZLE_RETURN_OK)
-      drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
-
-    drizzle_test("drizzle_column_create");
-    if (drizzle_column_create(&state->result, &state->column) == NULL)
-      drizzle_test_error("returned %s", drizzle_con_error(con));
-
-    drizzle_column_set_catalog(&state->column, "test_catalog");
-    drizzle_column_set_db(&state->column, "test_db");
-    drizzle_column_set_table(&state->column, "test_table");
-    drizzle_column_set_orig_table(&state->column, "test_orig_table");
-    drizzle_column_set_name(&state->column, "test_column_1");
-    drizzle_column_set_orig_name(&state->column, "test_orig_column_1");
-    drizzle_column_set_charset(&state->column, 8);
-    drizzle_column_set_size(&state->column, 32);
-    drizzle_column_set_type(&state->column, DRIZZLE_COLUMN_TYPE_VARCHAR);
-    drizzle_column_set_flags(&state->column, DRIZZLE_COLUMN_FLAGS_NONE);
-
-  case SERVER_STATE_RESULT_COLUMN_1:
-    drizzle_test("drizzle_column_write");
-    ret= drizzle_column_write(&state->result, &state->column);
-    if (ret == DRIZZLE_RETURN_IO_WAIT)
-    {
-      state->state = SERVER_STATE_RESULT_COLUMN_1;
-      return;
-    }
-    else if (ret != DRIZZLE_RETURN_OK)
-      drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
-
-    drizzle_column_set_name(&state->column, "test_column_2");
-    drizzle_column_set_orig_name(&state->column, "test_orig_column_2");
-
-  case SERVER_STATE_RESULT_COLUMN_2:
-    drizzle_test("drizzle_column_write");
-    ret= drizzle_column_write(&state->result, &state->column);
-    if (ret == DRIZZLE_RETURN_IO_WAIT)
-    {
-      state->state = SERVER_STATE_RESULT_COLUMN_2;
-      return;
-    }
-    else if (ret != DRIZZLE_RETURN_OK)
-      drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
-
-    drizzle_test("drizzle_column_free");
-    drizzle_column_free(&state->column);
-
-    drizzle_result_set_eof(&state->result, true);
-
-  case SERVER_STATE_RESULT_COLUMN_EOF:
-    drizzle_test("drizzle_handshake_result_write");
-    ret= drizzle_result_write(con, &state->result, false);
-    if (ret == DRIZZLE_RETURN_IO_WAIT)
-    {
-      state->state = SERVER_STATE_RESULT_COLUMN_EOF;
-      return;
-    }
-    else if (ret != DRIZZLE_RETURN_OK)
-      drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
-
-    drizzle_result_calc_row_size(&state->result, fields, field_sizes);
-
-  case SERVER_STATE_RESULT_ROW_1:
-    ret= drizzle_row_write(&state->result);
-
-  case SERVER_STATE_RESULT_ROW_1_FIELD_1:
-    ret= drizzle_field_write(&state->result, fields[0], field_sizes[0],
-                             field_sizes[0]);
-
-  case SERVER_STATE_RESULT_ROW_1_FIELD_2:
-    ret= drizzle_field_write(&state->result, fields[1], field_sizes[1],
-                             field_sizes[1]);
-
-  case SERVER_STATE_RESULT_ROW_EOF:
-    drizzle_test("drizzle_handshake_result_write");
-    ret= drizzle_result_write(con, &state->result, true);
-    if (ret == DRIZZLE_RETURN_IO_WAIT)
-    {
-      state->state = SERVER_STATE_RESULT_ROW_EOF;
-      return;
-    }
-    else if (ret != DRIZZLE_RETURN_OK)
-      drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
-
-    drizzle_result_free(&state->result);
-
-    state->state = SERVER_STATE_DONE;
-
-  case SERVER_STATE_DONE:
-    return;
-
-  default:
-    drizzle_test_error("invalid server state");
-  }
-}
-
-static void _client(drizzle_con_st *con, client_state_st *state)
-{
-  drizzle_return_t ret;
-  drizzle_column_st *column;
-  drizzle_row_t row;
-  size_t *field_sizes;
-
-  switch(state->state)
-  {
-  case CLIENT_STATE_START:
-    drizzle_test("drizzle_query_str");
-    (void)drizzle_query_str(con, &state->result, "SELECT", &ret);
-    if (ret == DRIZZLE_RETURN_IO_WAIT)
-    {
-      state->state = CLIENT_STATE_START;
-      return;
-    }
-    else if (ret != DRIZZLE_RETURN_OK)
-      drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
-
-  case CLIENT_STATE_RESULT:
-    drizzle_test("drizzle_result_buffer");
-    ret = drizzle_result_buffer(&state->result);
-    if (ret == DRIZZLE_RETURN_IO_WAIT)
-    {
-      state->state = CLIENT_STATE_RESULT;
-      return;
-    }
-    else if (ret != DRIZZLE_RETURN_OK)
-      drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
-
-    drizzle_test("drizzle_con_protocol_version");
-    if (drizzle_con_protocol_version(con) != 10)
-      drizzle_test_error("no match");
-
-    drizzle_test("drizzle_con_server_version");
-    if (strcmp(drizzle_con_server_version(con), "test_version"))
-      drizzle_test_error("no match");
-
-    drizzle_test("drizzle_con_thread_id");
-    if (drizzle_con_thread_id(con) != 1)
-      drizzle_test_error("no match");
-
-    drizzle_test("drizzle_con_scramble");
-    if (memcmp(drizzle_con_scramble(con), "ABCDEFGHIJKLMNOPQRST",
-               DRIZZLE_MAX_SCRAMBLE_SIZE))
-    {
-      drizzle_test_error("no match");
-    }
-
-    /* We default to MySQL protocol right now, which sets this flag. */
-    drizzle_test("drizzle_con_capabilities");
-    if (drizzle_con_capabilities(con) != DRIZZLE_CAPABILITIES_PROTOCOL_41)
-      drizzle_test_error("no match");
-
-    drizzle_test("drizzle_con_charset");
-    if (drizzle_con_charset(con) != 8)
-      drizzle_test_error("no match");
-
-    drizzle_test("drizzle_con_status");
-    if (drizzle_con_status(con) != DRIZZLE_CON_STATUS_NONE)
-      drizzle_test_error("no match");
-
-    drizzle_test("drizzle_con_packet_size");
-    if (drizzle_con_max_packet_size(con) != DRIZZLE_MAX_PACKET_SIZE)
-      drizzle_test_error("no match");
-
-    drizzle_test("drizzle_column_next");
-    column= drizzle_column_next(&state->result);
-    if (column == NULL)
-      drizzle_test_error("column not found");
-
-    drizzle_test("drizzle_column_drizzle_result");
-    if (drizzle_column_drizzle_result(column) != &state->result)
-      drizzle_test_error("no match");
-
-    drizzle_test("drizzle_column_catalog");
-    if (strcmp(drizzle_column_catalog(column), "test_catalog"))
-      drizzle_test_error("no match");
-
-    drizzle_test("drizzle_column_db");
-    if (strcmp(drizzle_column_db(column), "test_db"))
-      drizzle_test_error("no match");
-
-    drizzle_test("drizzle_column_table");
-    if (strcmp(drizzle_column_table(column), "test_table"))
-      drizzle_test_error("no match");
-
-    drizzle_test("drizzle_column_orig_table");
-    if (strcmp(drizzle_column_orig_table(column), "test_orig_table"))
-      drizzle_test_error("no match");
-
-    drizzle_test("drizzle_column_name");
-    if (strcmp(drizzle_column_name(column), "test_column_1"))
-      drizzle_test_error("no match");
-
-    drizzle_test("drizzle_column_orig_name");
-    if (strcmp(drizzle_column_orig_name(column), "test_orig_column_1"))
-      drizzle_test_error("no match");
-
-    drizzle_test("drizzle_column_charset");
-    if (drizzle_column_charset(column) != 8)
-      drizzle_test_error("no match");
-
-    drizzle_test("drizzle_column_size");
-    if (drizzle_column_size(column) != 32)
-      drizzle_test_error("no match");
-
-    drizzle_test("drizzle_column_max_size");
-    if (drizzle_column_max_size(column) != 12)
-      drizzle_test_error("no match");
-
-    drizzle_test("drizzle_column_type_drizzle");
-    if (drizzle_column_type_drizzle(column) != DRIZZLE_COLUMN_TYPE_DRIZZLE_VARCHAR)
-      drizzle_test_error("no match");
-
-    drizzle_test("drizzle_column_flags");
-    if (drizzle_column_flags(column) != DRIZZLE_COLUMN_FLAGS_NONE)
-      drizzle_test_error("no match");
-
-    drizzle_test("drizzle_column_next");
-    column= drizzle_column_next(&state->result);
-    if (column == NULL)
-      drizzle_test_error("column not found");
-
-    drizzle_test("drizzle_column_name");
-    if (strcmp(drizzle_column_name(column), "test_column_2"))
-      drizzle_test_error("no match");
-
-    drizzle_test("drizzle_column_next");
-    column= drizzle_column_next(&state->result);
-    if (column != NULL)
-      drizzle_test_error("column found");
-
-    drizzle_test("drizzle_column_prev");
-    column= drizzle_column_prev(&state->result);
-    if (column == NULL)
-      drizzle_test_error("column not found");
-
-    drizzle_test("drizzle_column_name");
-    if (strcmp(drizzle_column_name(column), "test_column_2"))
-      drizzle_test_error("no match");
-
-    drizzle_test("drizzle_row_next");
-    row= drizzle_row_next(&state->result);
-    if (row == NULL)
-      drizzle_test_error("row not found");
-
-    if (strcmp(row[0], "test_field_1") || strcmp(row[1], "test_field_2"))
-      drizzle_test_error("no match");
-
-    drizzle_test("drizzle_row_field_sizes");
-    field_sizes= drizzle_row_field_sizes(&state->result);
-    if (field_sizes[0] != 12 || field_sizes[1] != 12)
-      drizzle_test_error("no match");
-
-    drizzle_test("drizzle_row_prev");
-    row = drizzle_row_prev(&state->result);
-    if (row == NULL)
-      drizzle_test_error("row not found");
-
-    if (strcmp(row[0], "test_field_1") || strcmp(row[1], "test_field_2"))
-      drizzle_test_error("no match");
-
-    drizzle_test("drizzle_row_next");
-    row = drizzle_row_next(&state->result);
-
-    drizzle_test("drizzle_row_index");
-    row = drizzle_row_index(&state->result, 0);
-    if (row == NULL)
-      drizzle_test_error("row not found");
-
-    if (strcmp(row[0], "test_field_1") || strcmp(row[1], "test_field_2"))
-      drizzle_test_error("no match");
-
-    drizzle_test("drizzle_row_index");
-    row = drizzle_row_index(&state->result, 1);
-    if (row != NULL)
-      drizzle_test_error("row found");
-
-    drizzle_test("drizzle_result_free");
-    drizzle_result_free(&state->result);
-
-    state->state = CLIENT_STATE_DONE;
-
-  case CLIENT_STATE_DONE:
-    return;
-
-  default:
-    drizzle_test_error("invalid client state");
-  }
-}
 
=== added file 'unittests/constrained_value.cc'
--- unittests/constrained_value.cc	1970-01-01 00:00:00 +0000
+++ unittests/constrained_value.cc	2011-01-24 09:18:02 +0000
@@ -0,0 +1,58 @@
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+ *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ *  Copyright (C) 2010 Monty Taylor
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "config.h"
+
+#include <string>
+
+#define BOOST_TEST_DYN_LINK
+#include <boost/test/unit_test.hpp>
+
+#include <drizzled/constrained_value.h>
+#include <boost/lexical_cast.hpp>
+
+using namespace drizzled;
+
+namespace po= boost::program_options;
+
+BOOST_AUTO_TEST_SUITE(ConstrainedValue)
+BOOST_AUTO_TEST_CASE(raw_usage)
+{
+  constrained_check<uint64_t,1024,1,10> val(1);
+
+  BOOST_REQUIRE_EQUAL(UINT64_C(1), (uint64_t)val);
+
+  BOOST_REQUIRE_THROW(val= 1025 , po::validation_error);
+  BOOST_REQUIRE_THROW(val= 0 , po::validation_error);
+
+  val= 25;
+
+  BOOST_REQUIRE_EQUAL(20, (uint64_t)val);
+}
+
+BOOST_AUTO_TEST_CASE(lexical_cast_usage)
+{
+  constrained_check<uint64_t,1024,1,10> val(1);
+
+  std::string string_val= boost::lexical_cast<std::string>(val);
+
+  BOOST_REQUIRE_EQUAL(std::string("1"), string_val);
+}
+BOOST_AUTO_TEST_SUITE_END()
 
=== removed file 'unittests/constrained_value.cc'
--- unittests/constrained_value.cc	2010-10-19 21:51:42 +0000
+++ unittests/constrained_value.cc	1970-01-01 00:00:00 +0000
@@ -1,57 +0,0 @@
-/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
- *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
- *
- *  Copyright (C) 2010 Monty Taylor
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- */
-
-#include "config.h"
-
-#include <string>
-
-#include <gtest/gtest.h>
-
-#include <drizzled/constrained_value.h>
-#include <boost/lexical_cast.hpp>
-
-using namespace drizzled;
-
-namespace po= boost::program_options;
-
-TEST(constrained_value, raw_usage)
-{
-  constrained_check<uint64_t,1024,1,10> val(1);
-
-  EXPECT_EQ(UINT64_C(1), (uint64_t)val);
-
-  ASSERT_THROW(val= 1025 , po::validation_error);
-  ASSERT_THROW(val= 0 , po::validation_error);
-
-  val= 25;
-
-  EXPECT_EQ(20, (uint64_t)val);
-}
-
-TEST(constrained_value, lexical_cast_usage)
-{
-  constrained_check<uint64_t,1024,1,10> val(1);
-
-  std::string string_val= boost::lexical_cast<std::string>(val);
-
-  EXPECT_EQ(std::string("1"), string_val);
-}
-
-
 
=== added file 'unittests/date_test.cc'
--- unittests/date_test.cc	1970-01-01 00:00:00 +0000
+++ unittests/date_test.cc	2011-01-24 09:18:02 +0000
@@ -0,0 +1,562 @@
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+ *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ *  Copyright (C) 2010 Pawel Blokus
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "config.h"
+
+#define BOOST_TEST_DYN_LINK
+#include <boost/test/unit_test.hpp>
+
+#include <drizzled/type/decimal.h>
+#include <drizzled/temporal.h>
+#include <drizzled/temporal_format.h>
+
+#include "temporal_generator.h"
+
+using namespace drizzled;
+
+class DateTestCompareOperators
+{
+ protected:
+  Date sample_date;
+  bool result;
+  
+  Date identical_with_sample_date, before_sample_date, after_sample_date;
+  
+  DateTestCompareOperators()
+  {
+    TemporalGenerator::DateGen::make_date(&sample_date, 2010, 9, 8);
+    TemporalGenerator::DateGen::make_date(&before_sample_date, 1980, 1, 1);
+    TemporalGenerator::DateGen::make_date(&identical_with_sample_date, 2010, 9, 8);
+    TemporalGenerator::DateGen::make_date(&after_sample_date, 2019, 5, 30);
+  }
+};
+
+class DateTimeTestCompareOperators
+{
+ protected:
+  Date sample_date;
+  bool result;
+  
+  DateTime identical_with_sample_date, before_sample_date, after_sample_date;
+  
+  DateTimeTestCompareOperators()
+  {
+    TemporalGenerator::DateGen::make_date(&sample_date, 2010, 9, 8);
+    TemporalGenerator::DateTimeGen::make_datetime(&before_sample_date, 1990, 12, 31, 12, 12, 30);
+    TemporalGenerator::DateTimeGen::make_datetime(&identical_with_sample_date, 2010, 9, 8, 0, 0, 0);
+    TemporalGenerator::DateTimeGen::make_datetime(&after_sample_date, 2020, 4, 4, 4, 4, 4);
+  }
+};
+
+class TimestampTestCompareOperators
+{
+ protected:
+  Date sample_date;
+  bool result;
+  
+  Timestamp identical_with_sample_date, before_sample_date, after_sample_date;
+  
+  TimestampTestCompareOperators()
+  {
+    TemporalGenerator::DateGen::make_date(&sample_date, 2010, 9, 8);
+    TemporalGenerator::TimestampGen::make_timestamp(&before_sample_date, 1980, 1, 1, 13, 56, 41);
+    TemporalGenerator::TimestampGen::make_timestamp(&identical_with_sample_date, 2010, 9, 8, 0, 0, 0);
+    TemporalGenerator::TimestampGen::make_timestamp(&after_sample_date, 2019, 5, 30, 9, 10, 13);
+  }
+};
+
+BOOST_AUTO_TEST_SUITE(DateTestCompare)
+BOOST_FIXTURE_TEST_CASE(operatorComparingDate, DateTestCompareOperators)
+{
+  result= (sample_date == identical_with_sample_date);
+  BOOST_REQUIRE(result);
+
+  result= (sample_date == before_sample_date);  
+  BOOST_REQUIRE(not result);
+
+  result= (sample_date != identical_with_sample_date);
+  BOOST_REQUIRE(not result);
+
+  result= (sample_date != before_sample_date);  
+  BOOST_REQUIRE(result);
+
+  result= (sample_date > identical_with_sample_date);
+  BOOST_REQUIRE(not this->result);
+
+  result= (sample_date > after_sample_date);
+  BOOST_REQUIRE(not result);
+
+  result= (sample_date > before_sample_date);
+  BOOST_REQUIRE(result);
+
+  result= (sample_date >= identical_with_sample_date);
+  BOOST_REQUIRE(result);
+
+  result= (sample_date >= after_sample_date);
+  BOOST_REQUIRE(not result);
+
+  result= (sample_date >= before_sample_date);
+  BOOST_REQUIRE(result);
+
+  result= (sample_date < identical_with_sample_date);
+  
+  BOOST_REQUIRE(not result);
+
+  result= (sample_date < after_sample_date);
+  BOOST_REQUIRE(result);
+
+  result= (sample_date < before_sample_date);
+  BOOST_REQUIRE(not result);
+
+  result= (sample_date <= identical_with_sample_date);
+  BOOST_REQUIRE(result);
+
+  result= (sample_date <= after_sample_date);
+  
+  BOOST_REQUIRE(result);
+
+  result= (sample_date <= before_sample_date);
+  BOOST_REQUIRE(not result);
+}
+
+BOOST_FIXTURE_TEST_CASE(operatorComparingDateTime, DateTimeTestCompareOperators)
+{
+  result= (sample_date == identical_with_sample_date);
+  BOOST_REQUIRE(result);
+
+  result= (sample_date == before_sample_date);  
+  BOOST_REQUIRE(not result);
+
+  result= (sample_date != identical_with_sample_date);
+  BOOST_REQUIRE(not result);
+
+  result= (sample_date != before_sample_date);  
+  BOOST_REQUIRE(result);
+
+  result= (sample_date > identical_with_sample_date);
+  BOOST_REQUIRE(not this->result);
+
+  result= (sample_date > after_sample_date);
+  BOOST_REQUIRE(not result);
+
+  result= (sample_date > before_sample_date);
+  BOOST_REQUIRE(result);
+
+  result= (sample_date >= identical_with_sample_date);
+  BOOST_REQUIRE(result);
+
+  result= (sample_date >= after_sample_date);
+  BOOST_REQUIRE(not result);
+
+  result= (sample_date >= before_sample_date);
+  BOOST_REQUIRE(result);
+
+  result= (sample_date < identical_with_sample_date);
+  
+  BOOST_REQUIRE(not result);
+
+  result= (sample_date < after_sample_date);
+  BOOST_REQUIRE(result);
+
+  result= (sample_date < before_sample_date);
+  BOOST_REQUIRE(not result);
+
+  result= (sample_date <= identical_with_sample_date);
+  BOOST_REQUIRE(result);
+
+  result= (sample_date <= after_sample_date);
+  
+  BOOST_REQUIRE(result);
+
+  result= (sample_date <= before_sample_date);
+  BOOST_REQUIRE(not result);
+}
+
+
+BOOST_FIXTURE_TEST_CASE(operatorComparingTimestamp, TimestampTestCompareOperators)
+{
+  result= (sample_date == identical_with_sample_date);
+  BOOST_REQUIRE(result);
+
+  result= (sample_date == before_sample_date);  
+  BOOST_REQUIRE(not result);
+
+  result= (sample_date != identical_with_sample_date);
+  BOOST_REQUIRE(not result);
+
+  result= (sample_date != before_sample_date);  
+  BOOST_REQUIRE(result);
+
+  result= (sample_date > identical_with_sample_date);
+  BOOST_REQUIRE(not this->result);
+
+  result= (sample_date > after_sample_date);
+  BOOST_REQUIRE(not result);
+
+  result= (sample_date > before_sample_date);
+  BOOST_REQUIRE(result);
+
+  result= (sample_date >= identical_with_sample_date);
+  BOOST_REQUIRE(result);
+
+  result= (sample_date >= after_sample_date);
+  BOOST_REQUIRE(not result);
+
+  result= (sample_date >= before_sample_date);
+  BOOST_REQUIRE(result);
+
+  result= (sample_date < identical_with_sample_date);
+  
+  BOOST_REQUIRE(not result);
+
+  result= (sample_date < after_sample_date);
+  BOOST_REQUIRE(result);
+
+  result= (sample_date < before_sample_date);
+  BOOST_REQUIRE(not result);
+
+  result= (sample_date <= identical_with_sample_date);
+  BOOST_REQUIRE(result);
+
+  result= (sample_date <= after_sample_date);
+  
+  BOOST_REQUIRE(result);
+
+  result= (sample_date <= before_sample_date);
+  BOOST_REQUIRE(not result);
+}
+BOOST_AUTO_TEST_SUITE_END()
+
+
+class DateTest
+{
+  protected:
+    Date date;
+    bool result;
+    
+    DateTest()
+    {
+      TemporalGenerator::DateGen::make_valid_date(&date);
+    }
+};
+
+BOOST_AUTO_TEST_SUITE(CurrentDateValidationTest)
+BOOST_FIXTURE_TEST_CASE(operatorAssign_shouldCopyDateRelatadComponents, DateTest)
+{
+  Date copy= date;
+
+  BOOST_REQUIRE_EQUAL(date.years(), copy.years());
+  BOOST_REQUIRE_EQUAL(date.months(), copy.months());
+  BOOST_REQUIRE_EQUAL(date.days(), copy.days());
+}
+
+BOOST_FIXTURE_TEST_CASE(is_valid_onValidDate_shouldReturn_True, DateTest)
+{
+  result= date.is_valid();
+  BOOST_REQUIRE(result);
+}
+
+BOOST_FIXTURE_TEST_CASE(is_valid_onInvalidDateWithYearBelowMinimum_shouldReturn_False, DateTest)
+{
+  date.set_years(DRIZZLE_MIN_YEARS_SQL - 1);
+  
+  result= date.is_valid();
+  
+  BOOST_REQUIRE(not result);
+}
+
+BOOST_FIXTURE_TEST_CASE(is_valid_onInvalidDateWithYearAboveMaximum_shouldReturn_False, DateTest)
+{
+  date.set_years(DRIZZLE_MAX_YEARS_SQL + 1);
+    
+  result= date.is_valid();
+  
+  BOOST_REQUIRE(not result);
+}
+
+BOOST_FIXTURE_TEST_CASE(is_valid_onInvalidDateWithMonthSetToZero_shouldReturn_False, DateTest)
+{
+  date.set_months(0);
+  
+  result= date.is_valid();
+  
+  BOOST_REQUIRE(not result);
+}
+
+
+BOOST_FIXTURE_TEST_CASE(is_valid_onInvalidDateWithMonthAboveMaximum_shouldReturn_False, DateTest)
+{
+  date.set_months(13);
+  
+  result= date.is_valid();
+  
+  BOOST_REQUIRE(not result);
+}
+
+BOOST_FIXTURE_TEST_CASE(is_valid_onInvalidDateWithDaySetToZero_shouldReturn_False, DateTest)
+{
+  date.set_days(0);
+  
+  result= date.is_valid();
+  
+  BOOST_REQUIRE(not result);
+}
+
+BOOST_FIXTURE_TEST_CASE(is_valid_onInvalidDateWithDayAboveDaysInMonth_shouldReturn_False, DateTest)
+{
+  date.set_days(32);
+  
+  result= date.is_valid();
+  
+  BOOST_REQUIRE(not result);
+}
+
+BOOST_FIXTURE_TEST_CASE(is_valid_onInvalidDateWithLeapDayInNonLeapYear_shouldReturn_False, DateTest)
+{
+  TemporalGenerator::TemporalGen::leap_day_in_non_leap_year(&date);
+  
+  result= date.is_valid();
+  
+  BOOST_REQUIRE(not result);
+}
+
+BOOST_FIXTURE_TEST_CASE(is_valid_onValidDateWithLeapDayInLeapYear_shouldReturn_True, DateTest)
+{
+  TemporalGenerator::TemporalGen::leap_day_in_leap_year(&date);
+  
+  result= date.is_valid();
+  
+  BOOST_REQUIRE(result);
+}
+
+BOOST_FIXTURE_TEST_CASE(to_string_shouldProduce_hyphenSeperatedDateElements, DateTest)
+{
+  char expected[Date::MAX_STRING_LENGTH]= "2010-05-01";
+  char returned[Date::MAX_STRING_LENGTH];
+  TemporalGenerator::DateGen::make_date(&date, 2010, 5, 1);
+  
+  date.to_string(returned, Date::MAX_STRING_LENGTH);
+  
+  BOOST_REQUIRE_EQUAL(expected, returned);
+}
+
+BOOST_FIXTURE_TEST_CASE(to_string_nullBuffer_shouldReturnProperLengthAnyway, DateTest)
+{
+  int length= date.to_string(NULL, 0);
+  
+  BOOST_REQUIRE_EQUAL(Date::MAX_STRING_LENGTH - 1, length);  
+}
+
+BOOST_FIXTURE_TEST_CASE(from_string_validString_shouldPopulateCorrectly, DateTest)
+{
+  char valid_string[Date::MAX_STRING_LENGTH]= "2010-05-01";
+  uint32_t years, months, days;
+
+  init_temporal_formats();
+  
+  result= date.from_string(valid_string, Date::MAX_STRING_LENGTH - 1);
+  BOOST_REQUIRE(result);
+  
+  years= date.years();
+  months= date.months();
+  days= date.days();
+
+  deinit_temporal_formats();
+  
+  BOOST_REQUIRE_EQUAL(2010, years);
+  BOOST_REQUIRE_EQUAL(5, months);
+  BOOST_REQUIRE_EQUAL(1, days);
+}
+
+BOOST_FIXTURE_TEST_CASE(from_string_invalidString_shouldReturn_False, DateTest)
+{
+  char valid_string[Date::MAX_STRING_LENGTH]= "2x10-05-01";
+
+  init_temporal_formats();
+  result= date.from_string(valid_string, Date::MAX_STRING_LENGTH - 1);
+  deinit_temporal_formats();
+  
+  BOOST_REQUIRE(not result);
+}
+
+BOOST_FIXTURE_TEST_CASE(to_int64_t, DateTest)
+{
+  TemporalGenerator::DateGen::make_date(&date, 2030, 8, 17);
+  int64_t representation;
+  
+  date.to_int64_t(&representation);
+  
+  BOOST_REQUIRE_EQUAL(20300817, representation);
+}
+
+BOOST_FIXTURE_TEST_CASE(to_int32_t, DateTest)
+{
+  TemporalGenerator::DateGen::make_date(&date, 2030, 8, 17);
+  int32_t representation;
+
+  date.to_int32_t(&representation);
+
+  BOOST_REQUIRE_EQUAL(20300817, representation);
+}
+
+BOOST_FIXTURE_TEST_CASE(from_int32_t_shouldPopulateDateCorrectly, DateTest)
+{
+  uint32_t decoded_years, decoded_months, decoded_days;
+
+  date.from_int32_t(20300817);
+  
+  decoded_years= date.years();
+  decoded_months= date.months();
+  decoded_days= date.days();
+  
+  BOOST_REQUIRE_EQUAL(2030, decoded_years);
+  BOOST_REQUIRE_EQUAL(8, decoded_months);
+  BOOST_REQUIRE_EQUAL(17, decoded_days);
+}
+
+BOOST_FIXTURE_TEST_CASE(to_julian_day_number, DateTest)
+{
+  int64_t julian_day;
+  TemporalGenerator::DateGen::make_date(&date, 1999, 12, 31);
+  
+  date.to_julian_day_number(&julian_day);
+  
+  BOOST_REQUIRE_EQUAL(2451544, julian_day);
+}
+
+BOOST_FIXTURE_TEST_CASE(from_julian_day_number, DateTest)
+{
+  int64_t julian_day= 2451544;
+  uint32_t years, months, days;
+   
+  date.from_julian_day_number(julian_day);
+  
+  years= date.years();
+  months= date.months();
+  days= date.days();
+    
+  BOOST_REQUIRE_EQUAL(1999, years);
+  BOOST_REQUIRE_EQUAL(12, months);
+  BOOST_REQUIRE_EQUAL(31, days);
+}
+
+BOOST_FIXTURE_TEST_CASE(to_tm, DateTest)
+{
+  uint32_t years= 2030, months= 8, days= 17;
+  TemporalGenerator::DateGen::make_date(&date, years, months, days);
+  struct tm filled;
+  
+  date.to_tm(&filled);
+  
+  BOOST_REQUIRE_EQUAL(130, filled.tm_year);
+  BOOST_REQUIRE_EQUAL(7, filled.tm_mon);
+  BOOST_REQUIRE_EQUAL(17, filled.tm_mday);
+  BOOST_REQUIRE_EQUAL(0, filled.tm_hour);
+  BOOST_REQUIRE_EQUAL(0, filled.tm_min);
+  BOOST_REQUIRE_EQUAL(0, filled.tm_sec);
+
+  /* TODO: these fail, shouldn't they also be set properly? */
+  /* From Andrew: These fail because Temporal::to_tm doesn't populate them.
+     Does it need to or would we be wasting cycles doing it? */
+
+  BOOST_WARN_EQUAL(228, filled.tm_yday);
+  BOOST_WARN_EQUAL(6, filled.tm_wday);
+  BOOST_WARN_EQUAL(-1, filled.tm_isdst);
+}
+
+BOOST_FIXTURE_TEST_CASE(from_tm, DateTest)
+{
+  uint32_t years, months, days;
+  struct tm from;
+  from.tm_year= 1956 - 1900;
+  from.tm_mon= 2;
+  from.tm_mday= 30;
+  
+  date.from_tm(&from);
+  
+  years= date.years();
+  months= date.months();
+  days= date.days();
+  
+  BOOST_REQUIRE_EQUAL(1956, years);  
+  BOOST_REQUIRE_EQUAL(3, months);
+  BOOST_REQUIRE_EQUAL(30, days);
+}
+
+BOOST_FIXTURE_TEST_CASE(to_time_t, DateTest)
+{
+  time_t time;
+  TemporalGenerator::DateGen::make_date(&date, 1990, 9, 9);
+  
+  date.to_time_t(time);
+  
+  BOOST_REQUIRE_EQUAL(652838400, time);
+}
+
+BOOST_FIXTURE_TEST_CASE(from_time_t, DateTest)
+{
+  uint32_t years, months, days;
+  
+  date.from_time_t(652838400);
+  
+  years= date.years();
+  months= date.months();
+  days= date.days();
+  
+  BOOST_REQUIRE_EQUAL(1990, years);  
+  BOOST_REQUIRE_EQUAL(9, months);
+  BOOST_REQUIRE_EQUAL(9, days);
+}
+
+BOOST_FIXTURE_TEST_CASE(to_decimal, DateTest)
+{
+  drizzled::type::Decimal to;
+  TemporalGenerator::DateGen::make_date(&date, 1987, 5, 6);
+
+  date.to_decimal(&to);
+
+  BOOST_REQUIRE_EQUAL(19870506, to.buf[0]);
+}
+BOOST_AUTO_TEST_SUITE_END()
+
+BOOST_AUTO_TEST_SUITE(DateStringTest)
+BOOST_AUTO_TEST_CASE(DateFromStringTest)
+{
+  Date date;
+  const char *valid_strings[]= {"20100607", /* YYYYMMDD */
+                               "06/07/2010",/* MM[-/.]DD[-/.]YYYY (US common format)*/
+                               "10.06.07",/* YY[-/.]MM[-/.]DD */
+                               "10/6/7",/* YY[-/.][M]M[-/.][D]D */
+                               "2010-6-7"/* YYYY[-/.][M]M[-/.][D]D */};
+
+  init_temporal_formats();
+  for (int it= 0; it < 5; it++)
+  {
+    const char *valid_string= valid_strings[it];
+    bool result= date.from_string(valid_string, strlen(valid_string));
+    BOOST_REQUIRE(result);
+    
+    BOOST_REQUIRE_EQUAL(2010, date.years());
+    BOOST_REQUIRE_EQUAL(6, date.months());
+    BOOST_REQUIRE_EQUAL(7, date.days());
+  }
+  deinit_temporal_formats();
+}
+BOOST_AUTO_TEST_SUITE_END()
 
=== removed file 'unittests/date_test.cc'
--- unittests/date_test.cc	2010-12-26 00:07:57 +0000
+++ unittests/date_test.cc	1970-01-01 00:00:00 +0000
@@ -1,522 +0,0 @@
-/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
- *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
- *
- *  Copyright (C) 2010 Pawel Blokus
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- */
-
-#include "config.h"
-
-#include <gtest/gtest.h>
-#include <drizzled/type/decimal.h>
-#include <drizzled/temporal.h>
-#include <drizzled/temporal_format.h>
-
-#include "temporal_generator.h"
-
-using namespace drizzled;
-
-template <typename TemporalType>
-class DateTestCompareOperators : public ::testing::Test
-{
- protected:
-  Date sample_date;
-  bool result;
-  
-  TemporalType identical_with_sample_date, before_sample_date, after_sample_date;
-  
-  void initBeforeIdenticalAfter();
-
-  virtual void SetUp()
-  {
-    TemporalGenerator::DateGen::make_date(&sample_date, 2010, 9, 8);
-    initBeforeIdenticalAfter();
-  }
-};
-
-template<> void DateTestCompareOperators<Date>::initBeforeIdenticalAfter()
-{
-  TemporalGenerator::DateGen::make_date(&before_sample_date, 1980, 1, 1);
-  TemporalGenerator::DateGen::make_date(&identical_with_sample_date, 2010, 9, 8);
-  TemporalGenerator::DateGen::make_date(&after_sample_date, 2019, 5, 30);
-}
-
-template<> void DateTestCompareOperators<DateTime>::initBeforeIdenticalAfter()
-{
-  TemporalGenerator::DateTimeGen::make_datetime(&before_sample_date, 1990, 12, 31, 12, 12, 30);
-  TemporalGenerator::DateTimeGen::make_datetime(&identical_with_sample_date, 2010, 9, 8, 0, 0, 0);
-  TemporalGenerator::DateTimeGen::make_datetime(&after_sample_date, 2020, 4, 4, 4, 4, 4);
-}
-
-template<> void DateTestCompareOperators<Timestamp>::initBeforeIdenticalAfter()
-{
-  TemporalGenerator::TimestampGen::make_timestamp(&before_sample_date, 1980, 1, 1, 13, 56, 41);
-  TemporalGenerator::TimestampGen::make_timestamp(&identical_with_sample_date, 2010, 9, 8, 0, 0, 0);
-  TemporalGenerator::TimestampGen::make_timestamp(&after_sample_date, 2019, 5, 30, 9, 10, 13);
-}
-
-typedef ::testing::Types<Date, DateTime, Timestamp> typesForDateTestCompareOperators;
-TYPED_TEST_CASE(DateTestCompareOperators, typesForDateTestCompareOperators);
-
-TYPED_TEST(DateTestCompareOperators, operatorEqual_ComparingWithIdencticalTemporal_ShouldReturn_True)
-{
-  this->result= (this->sample_date == this->identical_with_sample_date);
-  
-  ASSERT_TRUE(this->result);
-}
-
-TYPED_TEST(DateTestCompareOperators, operatorEqual_ComparingWithDifferentTemporal_ShouldReturn_False)
-{
-  this->result= (this->sample_date == this->before_sample_date);
-  
-  ASSERT_FALSE(this->result);
-}
-
-TYPED_TEST(DateTestCompareOperators, operatorNotEqual_ComparingWithIdencticalTemporal_ShouldReturn_False)
-{ 
-  this->result= (this->sample_date != this->identical_with_sample_date);
-  
-  ASSERT_FALSE(this->result);
-}
-
-TYPED_TEST(DateTestCompareOperators, operatorNotEqual_ComparingWithDifferentTemporal_ShouldReturn_True)
-{
-  this->result= (this->sample_date != this->before_sample_date);
-  
-  ASSERT_TRUE(this->result);
-}
-
-TYPED_TEST(DateTestCompareOperators, operatorGreaterThan_ComparingWithIdenticalTemporal_ShouldReturn_False)
-{
-  this->result= (this->sample_date > this->identical_with_sample_date);
-  
-  ASSERT_FALSE(this->result);
-}
-
-TYPED_TEST(DateTestCompareOperators, operatorGreaterThan_ComparingWithLaterTemporal_ShouldReturn_False)
-{
-  this->result= (this->sample_date > this->after_sample_date);
-  
-  ASSERT_FALSE(this->result);
-}
-
-TYPED_TEST(DateTestCompareOperators, operatorGreaterThan_ComparingWithEarlierTemporal_ShouldReturn_True)
-{
-  this->result= (this->sample_date > this->before_sample_date);
-  
-  ASSERT_TRUE(this->result);
-}
-
-TYPED_TEST(DateTestCompareOperators, operatorGreaterThanOrEqual_ComparingWithIdenticalTemporal_ShouldReturn_True)
-{
-  this->result= (this->sample_date >= this->identical_with_sample_date);
-  
-  ASSERT_TRUE(this->result);
-}
-
-TYPED_TEST(DateTestCompareOperators, operatorGreaterThanOrEqual_ComparingWithLaterTemporal_ShouldReturn_False)
-{
-  this->result= (this->sample_date >= this->after_sample_date);
-  
-  ASSERT_FALSE(this->result);
-}
-
-TYPED_TEST(DateTestCompareOperators, operatorGreaterThanOrEqual_ComparingWithEarlierTemporal_ShouldReturn_True)
-{
-  this->result= (this->sample_date >= this->before_sample_date);
-  
-  ASSERT_TRUE(this->result);
-}
-
-TYPED_TEST(DateTestCompareOperators, operatorLessThan_ComparingWithIdenticalTemporal_ShouldReturn_False)
-{
-  this->result= (this->sample_date < this->identical_with_sample_date);
-  
-  ASSERT_FALSE(this->result);
-}
-
-TYPED_TEST(DateTestCompareOperators, operatorLessThan_ComparingWithLaterTemporal_ShouldReturn_True)
-{
-  this->result= (this->sample_date < this->after_sample_date);
-  
-  ASSERT_TRUE(this->result);
-}
-
-TYPED_TEST(DateTestCompareOperators, operatorLessThan_ComparingWithEarlierTemporal_ShouldReturn_False)
-{
-  this->result= (this->sample_date < this->before_sample_date);
-  
-  ASSERT_FALSE(this->result);
-}
-
-TYPED_TEST(DateTestCompareOperators, operatorLessThanOrEqual_ComparingWithIdenticalTemporal_ShouldReturn_True)
-{
-  this->result= (this->sample_date <= this->identical_with_sample_date);
-  
-  ASSERT_TRUE(this->result);
-}
-
-TYPED_TEST(DateTestCompareOperators, operatorLessThanOrEqual_ComparingWithLaterTemporal_ShouldReturn_True)
-{
-  this->result= (this->sample_date <= this->after_sample_date);
-  
-  ASSERT_TRUE(this->result);
-}
-
-TYPED_TEST(DateTestCompareOperators, operatorLessThanOrEqual_ComparingWithEarlierTemporal_ShouldReturn_False)
-{
-  this->result= (this->sample_date <= this->before_sample_date);
-  
-  ASSERT_FALSE(this->result);
-}
-
-class DateTest : public ::testing::Test
-{
-  protected:
-    Date date;
-    bool result;
-    
-    virtual void SetUp()
-    {
-      TemporalGenerator::DateGen::make_valid_date(&date);
-    }
-};
-
-TEST_F(DateTest, operatorAssign_shouldCopyDateRelatadComponents)
-{
-  Date copy= date;
-
-  EXPECT_EQ(date.years(), copy.years());
-  EXPECT_EQ(date.months(), copy.months());
-  EXPECT_EQ(date.days(), copy.days());
-}
-
-TEST_F(DateTest, is_valid_onValidDate_shouldReturn_True)
-{
-  result= date.is_valid();
-  ASSERT_TRUE(result);
-}
-
-TEST_F(DateTest, is_valid_onInvalidDateWithYearBelowMinimum_shouldReturn_False)
-{
-  date.set_years(DRIZZLE_MIN_YEARS_SQL - 1);
-  
-  result= date.is_valid();
-  
-  ASSERT_FALSE(result);
-}
-
-TEST_F(DateTest, is_valid_onInvalidDateWithYearAboveMaximum_shouldReturn_False)
-{
-  date.set_years(DRIZZLE_MAX_YEARS_SQL + 1);
-    
-  result= date.is_valid();
-  
-  ASSERT_FALSE(result);
-}
-
-TEST_F(DateTest, is_valid_onInvalidDateWithMonthSetToZero_shouldReturn_False)
-{
-  date.set_months(0);
-  
-  result= date.is_valid();
-  
-  ASSERT_FALSE(result);
-}
-
-
-TEST_F(DateTest, is_valid_onInvalidDateWithMonthAboveMaximum_shouldReturn_False)
-{
-  date.set_months(13);
-  
-  result= date.is_valid();
-  
-  ASSERT_FALSE(result);
-}
-
-TEST_F(DateTest, is_valid_onInvalidDateWithDaySetToZero_shouldReturn_False)
-{
-  date.set_days(0);
-  
-  result= date.is_valid();
-  
-  ASSERT_FALSE(result);
-}
-
-TEST_F(DateTest, is_valid_onInvalidDateWithDayAboveDaysInMonth_shouldReturn_False)
-{
-  date.set_days(32);
-  
-  result= date.is_valid();
-  
-  ASSERT_FALSE(result);
-}
-
-TEST_F(DateTest, is_valid_onInvalidDateWithLeapDayInNonLeapYear_shouldReturn_False)
-{
-  TemporalGenerator::TemporalGen::leap_day_in_non_leap_year(&date);
-  
-  result= date.is_valid();
-  
-  ASSERT_FALSE(result);
-}
-
-TEST_F(DateTest, is_valid_onValidDateWithLeapDayInLeapYear_shouldReturn_True)
-{
-  TemporalGenerator::TemporalGen::leap_day_in_leap_year(&date);
-  
-  result= date.is_valid();
-  
-  ASSERT_TRUE(result);
-}
-
-TEST_F(DateTest, to_string_shouldProduce_hyphenSeperatedDateElements)
-{
-  char expected[Date::MAX_STRING_LENGTH]= "2010-05-01";
-  char returned[Date::MAX_STRING_LENGTH];
-  TemporalGenerator::DateGen::make_date(&date, 2010, 5, 1);
-  
-  date.to_string(returned, Date::MAX_STRING_LENGTH);
-  
-  ASSERT_STREQ(expected, returned);  
-}
-
-TEST_F(DateTest, to_string_nullBuffer_shouldReturnProperLengthAnyway)
-{
-  int length= date.to_string(NULL, 0);
-  
-  ASSERT_EQ(Date::MAX_STRING_LENGTH - 1, length);  
-}
-
-TEST_F(DateTest, from_string_validString_shouldPopulateCorrectly)
-{
-  char valid_string[Date::MAX_STRING_LENGTH]= "2010-05-01";
-  uint32_t years, months, days;
-
-  init_temporal_formats();
-  
-  result= date.from_string(valid_string, Date::MAX_STRING_LENGTH - 1);
-  ASSERT_TRUE(result);
-  
-  years= date.years();
-  months= date.months();
-  days= date.days();
-
-  deinit_temporal_formats();
-  
-  EXPECT_EQ(2010, years);
-  EXPECT_EQ(5, months);
-  EXPECT_EQ(1, days);
-}
-
-TEST_F(DateTest, from_string_invalidString_shouldReturn_False)
-{
-  char valid_string[Date::MAX_STRING_LENGTH]= "2x10-05-01";
-
-  init_temporal_formats();
-  result= date.from_string(valid_string, Date::MAX_STRING_LENGTH - 1);
-  deinit_temporal_formats();
-  
-  ASSERT_FALSE(result);
-}
-
-TEST_F(DateTest, to_int64_t)
-{
-  TemporalGenerator::DateGen::make_date(&date, 2030, 8, 17);
-  int64_t representation;
-  
-  date.to_int64_t(&representation);
-  
-  ASSERT_EQ(20300817, representation);
-}
-
-TEST_F(DateTest, to_int32_t)
-{
-  TemporalGenerator::DateGen::make_date(&date, 2030, 8, 17);
-  int32_t representation;
-
-  date.to_int32_t(&representation);
-
-  ASSERT_EQ(20300817, representation);
-}
-
-TEST_F(DateTest, from_int32_t_shouldPopulateDateCorrectly)
-{
-  uint32_t decoded_years, decoded_months, decoded_days;
-
-  date.from_int32_t(20300817);
-  
-  decoded_years= date.years();
-  decoded_months= date.months();
-  decoded_days= date.days();
-  
-  EXPECT_EQ(2030, decoded_years);
-  EXPECT_EQ(8, decoded_months);
-  EXPECT_EQ(17, decoded_days);
-}
-
-TEST_F(DateTest, to_julian_day_number)
-{
-  int64_t julian_day;
-  TemporalGenerator::DateGen::make_date(&date, 1999, 12, 31);
-  
-  date.to_julian_day_number(&julian_day);
-  
-  ASSERT_EQ(2451544, julian_day);
-}
-
-TEST_F(DateTest, from_julian_day_number)
-{
-  int64_t julian_day= 2451544;
-  uint32_t years, months, days;
-   
-  date.from_julian_day_number(julian_day);
-  
-  years= date.years();
-  months= date.months();
-  days= date.days();
-    
-  EXPECT_EQ(1999, years);
-  EXPECT_EQ(12, months);
-  EXPECT_EQ(31, days);
-}
-
-TEST_F(DateTest, DISABLED_to_tm)
-{
-  uint32_t years= 2030, months= 8, days= 17;
-  TemporalGenerator::DateGen::make_date(&date, years, months, days);
-  struct tm filled;
-  
-  date.to_tm(&filled);
-  
-  EXPECT_EQ(130, filled.tm_year);
-  EXPECT_EQ(7, filled.tm_mon);
-  EXPECT_EQ(17, filled.tm_mday);
-  EXPECT_EQ(0, filled.tm_hour);
-  EXPECT_EQ(0, filled.tm_min);
-  EXPECT_EQ(0, filled.tm_sec);
-
-  /* TODO:these fail, shouldn't they also be set properly? */
-  EXPECT_EQ(228, filled.tm_yday);
-  EXPECT_EQ(6, filled.tm_wday);
-  EXPECT_EQ(-1, filled.tm_isdst);
-}
-
-TEST_F(DateTest, from_tm)
-{
-  uint32_t years, months, days;
-  struct tm from;
-  from.tm_year= 1956 - 1900;
-  from.tm_mon= 2;
-  from.tm_mday= 30;
-  
-  date.from_tm(&from);
-  
-  years= date.years();
-  months= date.months();
-  days= date.days();
-  
-  EXPECT_EQ(1956, years);  
-  EXPECT_EQ(3, months);
-  EXPECT_EQ(30, days);
-}
-
-TEST_F(DateTest, to_time_t)
-{
-  time_t time;
-  TemporalGenerator::DateGen::make_date(&date, 1990, 9, 9);
-  
-  date.to_time_t(time);
-  
-  ASSERT_EQ(652838400, time);
-}
-
-TEST_F(DateTest, from_time_t)
-{
-  uint32_t years, months, days;
-  
-  date.from_time_t(652838400);
-  
-  years= date.years();
-  months= date.months();
-  days= date.days();
-  
-  EXPECT_EQ(1990, years);  
-  EXPECT_EQ(9, months);
-  EXPECT_EQ(9, days);
-}
-
-TEST_F(DateTest, to_decimal)
-{
-  drizzled::type::Decimal to;
-  TemporalGenerator::DateGen::make_date(&date, 1987, 5, 6);
-
-  date.to_decimal(&to);
-
-  ASSERT_EQ(19870506, to.buf[0]);
-}
-
-class DateFromStringTest: public ::testing::TestWithParam<const char*>
-{
-  protected:
-    Date date;
-    bool result;
-    uint32_t years, months, days;
-    
-    virtual void SetUp()
-    {
-      init_temporal_formats();
-    }
-    
-    virtual void TearDown()
-    {
-      deinit_temporal_formats();
-    }
-    
-    void assign_date_values()
-    {
-      years= date.years();
-      months= date.months();
-      days= date.days();
-    }
-};
-
-TEST_P(DateFromStringTest, from_string)
-{
-  const char *valid_string= GetParam();
-  
-  result= date.from_string(valid_string, strlen(valid_string));
-  ASSERT_TRUE(result);
-  
-  assign_date_values();
-  
-  EXPECT_EQ(2010, years);
-  EXPECT_EQ(6, months);
-  EXPECT_EQ(7, days);
-}
-
-/* TODO:for some reason this was not declared by the macro, needs clarification*/
-testing::internal::ParamGenerator<const char*> gtest_ValidStringDateFromStringTest_EvalGenerator_();
-
-INSTANTIATE_TEST_CASE_P(ValidString, DateFromStringTest,
-                        ::testing::Values("20100607", /* YYYYMMDD */
-                                          "06/07/2010",/* MM[-/.]DD[-/.]YYYY (US common format)*/
-                                          "10.06.07",/* YY[-/.]MM[-/.]DD */
-                                          "10/6/7",/* YY[-/.][M]M[-/.][D]D */
-                                          "2010-6-7"/* YYYY[-/.][M]M[-/.][D]D */));
-                                          
-
-                                          
 
=== added file 'unittests/date_time_test.cc'
--- unittests/date_time_test.cc	1970-01-01 00:00:00 +0000
+++ unittests/date_time_test.cc	2011-01-24 09:18:02 +0000
@@ -0,0 +1,478 @@
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+*
+*  Copyright (C) 2010 Pawel Blokus
+*
+*  This program is free software; you can redistribute it and/or modify
+*  it under the terms of the GNU General Public License as published by
+*  the Free Software Foundation; either version 2 of the License, or
+*  (at your option) any later version.
+*
+*  This program is distributed in the hope that it will be useful,
+*  but WITHOUT ANY WARRANTY; without even the implied warranty of
+*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+*  GNU General Public License for more details.
+*
+*  You should have received a copy of the GNU General Public License
+*  along with this program; if not, write to the Free Software
+*  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#include "config.h"
+
+#define BOOST_TEST_DYN_LINK
+#include <boost/test/unit_test.hpp>
+
+#include <drizzled/type/decimal.h>
+#include <drizzled/temporal.h>
+#include <drizzled/temporal_format.h>
+
+#include "temporal_generator.h"
+
+using namespace drizzled;
+
+class DateTimeTest
+{
+  protected:
+    DateTime datetime;
+    bool result;
+    uint32_t years, months, days;
+    uint32_t hours, minutes, seconds;
+    
+    DateTimeTest()
+    {
+      TemporalGenerator::DateTimeGen::make_valid_datetime(&datetime);
+    }
+
+    void assignDateTimeValues()
+    {
+      years= datetime.years();
+      months= datetime.months();
+      days= datetime.days();
+      hours= datetime.hours();
+      minutes= datetime.minutes();
+      seconds= datetime.seconds();
+    }
+};
+
+BOOST_FIXTURE_TEST_SUITE(DateTimeTestValidation, DateTimeTest)
+BOOST_AUTO_TEST_CASE(is_valid_onValidDateTime_shouldReturn_True)
+{
+  result= datetime.is_valid();
+  BOOST_REQUIRE(result);
+}
+
+BOOST_AUTO_TEST_CASE(is_valid_onInvalidDateTimeWithYearBelowMinimum_shouldReturn_False)
+{
+  datetime.set_years(DRIZZLE_MIN_YEARS_SQL - 1);
+  
+  result= datetime.is_valid();
+  
+  BOOST_REQUIRE(not result);
+}
+
+BOOST_AUTO_TEST_CASE(is_valid_onInvalidDateTimeWithYearAboveMaximum_shouldReturn_False)
+{
+  datetime.set_years(DRIZZLE_MAX_YEARS_SQL + 1);
+    
+  result= datetime.is_valid();
+  
+  BOOST_REQUIRE(not result);
+}
+
+BOOST_AUTO_TEST_CASE(is_valid_onInvalidDateTimeWithMonthSetToZero_shouldReturn_False)
+{
+  datetime.set_months(0);
+  
+  result= datetime.is_valid();
+  
+  BOOST_REQUIRE(not result);
+}
+
+
+BOOST_AUTO_TEST_CASE(is_valid_onInvalidDateTimeWithMonthAboveMaximum_shouldReturn_False)
+{
+  datetime.set_months(13);
+  
+  result= datetime.is_valid();
+  
+  BOOST_REQUIRE(not result);
+}
+
+BOOST_AUTO_TEST_CASE(is_valid_onInvalidDateTimeWithDaySetToZero_shouldReturn_False)
+{
+  datetime.set_days(0);
+  
+  result= datetime.is_valid();
+  
+  BOOST_REQUIRE(not result);
+}
+
+BOOST_AUTO_TEST_CASE(is_valid_onInvalidDateTimeWithDayAboveDaysInMonth_shouldReturn_False)
+{
+  datetime.set_days(32);
+  
+  result= datetime.is_valid();
+  
+  BOOST_REQUIRE(not result);
+}
+
+BOOST_AUTO_TEST_CASE(is_valid_onInvalidDateTimeWithLeapDayInNonLeapYear_shouldReturn_False)
+{
+  TemporalGenerator::TemporalGen::leap_day_in_non_leap_year(&datetime);
+  
+  result= datetime.is_valid();
+  
+  BOOST_REQUIRE(not result);
+}
+
+BOOST_AUTO_TEST_CASE(is_valid_onValidDateTimeWithLeapDayInLeapYear_shouldReturn_True)
+{
+  TemporalGenerator::TemporalGen::leap_day_in_leap_year(&datetime);
+  
+  result= datetime.is_valid();
+  
+  BOOST_REQUIRE(result);
+}
+
+BOOST_AUTO_TEST_CASE(is_valid_onValidMinimalTime_shouldReturn_True)
+{
+  TemporalGenerator::TemporalGen::make_min_time(&datetime);
+  
+  result= datetime.is_valid();
+  
+  BOOST_REQUIRE(result);
+}
+
+BOOST_AUTO_TEST_CASE(is_valid_onValidMaximalTime_shouldReturn_True)
+{
+  TemporalGenerator::TemporalGen::make_max_time(&datetime);
+  
+  result= datetime.is_valid();
+  
+  BOOST_REQUIRE(result);
+}
+
+BOOST_AUTO_TEST_CASE(is_valid_onInvalidDateTimeWithHourAboveMaximum23_shouldReturn_False)
+{
+  datetime.set_hours(24);
+  
+  result= datetime.is_valid();
+  
+  BOOST_REQUIRE(not result);
+}
+
+BOOST_AUTO_TEST_CASE(is_valid_onInvalidDateTimeWithMinutesAboveMaximum59_shouldReturn_False)
+{
+  datetime.set_minutes(60);
+  
+  result= datetime.is_valid();
+  
+  BOOST_REQUIRE(not result);
+}
+
+BOOST_AUTO_TEST_CASE(is_valid_onInvalidDateTimeWithSecondsAboveMaximum61_shouldReturn_False)
+{
+  datetime.set_seconds(62);
+  
+  result= datetime.is_valid();
+  
+  BOOST_REQUIRE(not result);
+}
+
+BOOST_AUTO_TEST_CASE(to_string_shouldProduce_hyphenSeperatedDateElements_and_colonSeperatedTimeElements)
+{
+  char expected[DateTime::MAX_STRING_LENGTH]= "2010-05-01 08:07:06.123456";
+  char returned[DateTime::MAX_STRING_LENGTH];
+  TemporalGenerator::DateTimeGen::make_datetime(&datetime, 2010, 5, 1, 8, 7, 6, 123456);
+  
+  datetime.to_string(returned, DateTime::MAX_STRING_LENGTH);
+  
+  BOOST_REQUIRE_EQUAL(expected, returned);
+}
+
+BOOST_AUTO_TEST_CASE(to_string_nullBuffer_noMicroSeconds_shouldReturnProperLengthAnyway)
+{
+  int length= datetime.to_string(NULL, 0);
+  
+  BOOST_REQUIRE_EQUAL(DateTime::MAX_STRING_LENGTH - 1 - 7, length);  
+}
+
+BOOST_AUTO_TEST_CASE(to_int64_t)
+{
+  TemporalGenerator::DateTimeGen::make_datetime(&datetime, 2030, 8, 7, 14, 5, 13);
+  int64_t representation;
+
+  datetime.to_int64_t(&representation);
+
+  BOOST_REQUIRE_EQUAL(20300807140513LL, representation);
+}
+
+BOOST_AUTO_TEST_CASE(from_int64_t_no_conversion_format_YYYYMMDDHHMMSSshouldPopulateDateTimeCorrectly)
+{
+  datetime.from_int64_t(20300807140513LL, false);
+  
+  assignDateTimeValues();
+  
+  BOOST_REQUIRE_EQUAL(2030, years);
+  BOOST_REQUIRE_EQUAL(8, months);
+  BOOST_REQUIRE_EQUAL(7, days);
+  BOOST_REQUIRE_EQUAL(14, hours);
+  BOOST_REQUIRE_EQUAL(5, minutes);
+  BOOST_REQUIRE_EQUAL(13, seconds);
+}
+
+BOOST_AUTO_TEST_CASE(from_int64_t_with_conversion_format_YYYYMMDDHHMMSS_yearOver2000)
+{
+  datetime.from_int64_t(20300807140513LL, true);
+  
+  assignDateTimeValues();
+  
+  BOOST_REQUIRE_EQUAL(2030, years);
+  BOOST_REQUIRE_EQUAL(8, months);
+  BOOST_REQUIRE_EQUAL(7, days);
+  BOOST_REQUIRE_EQUAL(14, hours);
+  BOOST_REQUIRE_EQUAL(5, minutes);
+  BOOST_REQUIRE_EQUAL(13, seconds);
+}
+
+BOOST_AUTO_TEST_CASE(from_int64_t_with_conversion_format_YYYYMMDDHHMMSS_yearBelow2000)
+{
+  datetime.from_int64_t(19900807140513LL, true);
+  
+  assignDateTimeValues();
+  
+  BOOST_REQUIRE_EQUAL(1990, years);
+  BOOST_REQUIRE_EQUAL(8, months);
+  BOOST_REQUIRE_EQUAL(7, days);
+  BOOST_REQUIRE_EQUAL(14, hours);
+  BOOST_REQUIRE_EQUAL(5, minutes);
+  BOOST_REQUIRE_EQUAL(13, seconds);
+}
+
+BOOST_AUTO_TEST_CASE(from_int64_t_with_conversion_format_YYMMDDHHMMSS_yearOver2000)
+{
+  datetime.from_int64_t(300807140513LL, true);
+  
+  assignDateTimeValues();
+  
+  BOOST_REQUIRE_EQUAL(2030, years);
+  BOOST_REQUIRE_EQUAL(8, months);
+  BOOST_REQUIRE_EQUAL(7, days);
+  BOOST_REQUIRE_EQUAL(14, hours);
+  BOOST_REQUIRE_EQUAL(5, minutes);
+  BOOST_REQUIRE_EQUAL(13, seconds);
+}
+
+BOOST_AUTO_TEST_CASE(from_int64_t_with_conversion_format_YYMMDDHHMMSS_yearBelow2000)
+{
+  datetime.from_int64_t(900807140513LL, true);
+  
+  assignDateTimeValues();
+  
+  BOOST_REQUIRE_EQUAL(1990, years);
+  BOOST_REQUIRE_EQUAL(8, months);
+  BOOST_REQUIRE_EQUAL(7, days);
+  BOOST_REQUIRE_EQUAL(14, hours);
+  BOOST_REQUIRE_EQUAL(5, minutes);
+  BOOST_REQUIRE_EQUAL(13, seconds);
+}
+
+BOOST_AUTO_TEST_CASE(to_tm)
+{
+  years= 2030, months= 8, days= 17, hours= 14, minutes= 45, seconds= 13;
+  TemporalGenerator::DateTimeGen::make_datetime(&datetime, years, months, days, hours, minutes, seconds);
+  struct tm filled;
+  
+  datetime.to_tm(&filled);
+  
+  BOOST_REQUIRE_EQUAL(2030 - 1900, filled.tm_year);
+  BOOST_REQUIRE_EQUAL(8 - 1, filled.tm_mon);
+  BOOST_REQUIRE_EQUAL(17, filled.tm_mday);
+  BOOST_REQUIRE_EQUAL(14, filled.tm_hour);
+  BOOST_REQUIRE_EQUAL(45, filled.tm_min);
+  BOOST_REQUIRE_EQUAL(13, filled.tm_sec);
+
+  /* TODO:these fail, shouldn't they also be set properly? */
+  BOOST_WARN_EQUAL(228, filled.tm_yday);
+  BOOST_WARN_EQUAL(6, filled.tm_wday);
+  BOOST_WARN_EQUAL(-1, filled.tm_isdst);
+}
+
+BOOST_AUTO_TEST_CASE(to_decimal)
+{
+  drizzled::type::Decimal to;
+  TemporalGenerator::DateTimeGen::make_datetime(&datetime, 1987, 6, 13, 5, 10, 13, 456);
+
+  datetime.to_decimal(&to);
+  
+  BOOST_REQUIRE_EQUAL(19870,to.buf[0]);
+  BOOST_REQUIRE_EQUAL(613051013,to.buf[1]);
+  BOOST_REQUIRE_EQUAL(456000,to.buf[2]);
+}
+BOOST_AUTO_TEST_SUITE_END()
+
+
+class DateTimeFromStringTest
+{
+  protected:
+    static const char* allStrings[];
+    DateTime datetime;
+    bool result;
+    uint32_t years, months, days;
+    uint32_t hours, minutes, seconds;
+
+    DateTimeFromStringTest()
+    {
+      init_temporal_formats();
+    }
+
+    virtual ~DateTimeFromStringTest()
+    {
+      deinit_temporal_formats();
+    }
+
+    virtual int stringCount() { return 0; }
+    virtual const char** strings() { return NULL; }
+
+    void assignDateTimeValues()
+    {
+      years= datetime.years();
+      months= datetime.months();
+      days= datetime.days();
+      hours= datetime.hours();
+      minutes= datetime.minutes();
+      seconds= datetime.seconds();
+    }
+};
+
+const char* DateTimeFromStringTest::allStrings[]= {"NULL"};
+
+
+class DateTimeFromStringFullFormatTest : public DateTimeFromStringTest
+{
+ protected:
+  static const char* allStrings[];
+
+  const char** strings()
+  {
+    return allStrings;
+  }
+  
+  int stringCount()
+  {
+    return 7;
+  }  
+};
+
+const char* DateTimeFromStringFullFormatTest::allStrings[]= {"20100501080706",
+            "2010-05-01 08:07:06",
+            "2010/05/01T08:07:06",
+            "2010.5.1 08:07:06",
+            "10-05-01 08:07:06",
+            "10/5/1 08:07:06",
+            "10.5.1 08:07:06"};
+
+class DateTimeFromStringNoSecondFormatTest : public DateTimeFromStringTest
+{
+ protected:
+  static const char* allStrings[];
+
+  const char** strings()
+  {
+    return allStrings;
+  }
+  
+  int stringCount()
+  {
+    return 6;
+  }
+};
+
+const char* DateTimeFromStringNoSecondFormatTest::allStrings[]= {"2010-05-01 08:07",
+            "2010/05/01 08:07",
+            "2010.5.1 08:07",
+            "10-05-01 08:07",
+            "10/5/1 08:07",
+            "10.5.1 08:07"};
+
+class DateTimeFromStringDateOnlyTest: public DateTimeFromStringTest
+{
+ protected:
+  static const char* allStrings[];
+
+  const char** strings()
+  {
+    return allStrings;
+  }
+  
+  int stringCount()
+  {
+    return 5;
+  }
+};
+
+const char* DateTimeFromStringDateOnlyTest::allStrings[]= {"20100607", /* YYYYMMDD */
+            "06/07/2010",/* MM[-/.]DD[-/.]YYYY (US common format)*/
+            "10.06.07",/* YY[-/.]MM[-/.]DD */
+            "10/6/7",/* YY[-/.][M]M[-/.][D]D */
+            "2010-6-7"/* YYYY[-/.][M]M[-/.][D]D */};
+
+BOOST_AUTO_TEST_SUITE(DateTimeFromStringTestSuite)
+BOOST_FIXTURE_TEST_CASE(from_string_validStringFull, DateTimeFromStringFullFormatTest)
+{
+  for (int it= 0; it < stringCount(); it++)
+  {
+    const char *valid_string= strings()[it];
+
+    result= datetime.from_string(valid_string, strlen(valid_string));
+    BOOST_REQUIRE(result);
+
+    assignDateTimeValues();
+
+    BOOST_REQUIRE_EQUAL(2010, years);
+    BOOST_REQUIRE_EQUAL(5, months);
+    BOOST_REQUIRE_EQUAL(1, days);
+    BOOST_REQUIRE_EQUAL(8, hours);
+    BOOST_REQUIRE_EQUAL(7, minutes);
+    BOOST_REQUIRE_EQUAL(6, seconds);
+  }
+}
+                                          
+BOOST_FIXTURE_TEST_CASE(from_string_validStringNoSecond, DateTimeFromStringNoSecondFormatTest)
+{
+  for (int it= 0; it < stringCount(); it++)
+  {
+    const char *valid_string= strings()[it];
+
+    result= datetime.from_string(valid_string, strlen(valid_string));
+    BOOST_REQUIRE(result);
+
+    assignDateTimeValues();
+
+    BOOST_REQUIRE_EQUAL(2010, years);
+    BOOST_REQUIRE_EQUAL(5, months);
+    BOOST_REQUIRE_EQUAL(1, days);
+    BOOST_REQUIRE_EQUAL(8, hours);
+    BOOST_REQUIRE_EQUAL(7, minutes);
+  }
+}
+
+BOOST_FIXTURE_TEST_CASE(from_string_validStringDateOnly, DateTimeFromStringDateOnlyTest)
+{
+  for (int it= 0; it < stringCount(); it++)
+  {
+    const char *valid_string= strings()[it];
+
+    result= datetime.from_string(valid_string, strlen(valid_string));
+    BOOST_REQUIRE(result);
+
+    assignDateTimeValues();
+
+    BOOST_REQUIRE_EQUAL(2010, years);
+    BOOST_REQUIRE_EQUAL(6, months);
+    BOOST_REQUIRE_EQUAL(7, days);
+  }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
 
=== removed file 'unittests/date_time_test.cc'
--- unittests/date_time_test.cc	2010-12-26 00:07:57 +0000
+++ unittests/date_time_test.cc	1970-01-01 00:00:00 +0000
@@ -1,460 +0,0 @@
-/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
-*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
-*
-*  Copyright (C) 2010 Pawel Blokus
-*
-*  This program is free software; you can redistribute it and/or modify
-*  it under the terms of the GNU General Public License as published by
-*  the Free Software Foundation; either version 2 of the License, or
-*  (at your option) any later version.
-*
-*  This program is distributed in the hope that it will be useful,
-*  but WITHOUT ANY WARRANTY; without even the implied warranty of
-*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-*  GNU General Public License for more details.
-*
-*  You should have received a copy of the GNU General Public License
-*  along with this program; if not, write to the Free Software
-*  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-*/
-
-#include "config.h"
-
-#include <gtest/gtest.h>
-#include <drizzled/type/decimal.h>
-#include <drizzled/temporal.h>
-#include <drizzled/temporal_format.h>
-
-#include "temporal_generator.h"
-
-using namespace drizzled;
-
-class DateTimeTest: public ::testing::Test
-{
-  protected:
-    DateTime datetime;
-    bool result;
-    uint32_t years, months, days;
-    uint32_t hours, minutes, seconds;
-    
-    virtual void SetUp()
-    {
-      TemporalGenerator::DateTimeGen::make_valid_datetime(&datetime);
-    }
-
-    void assignDateTimeValues()
-    {
-      years= datetime.years();
-      months= datetime.months();
-      days= datetime.days();
-      hours= datetime.hours();
-      minutes= datetime.minutes();
-      seconds= datetime.seconds();
-    }
-};
-
-TEST_F(DateTimeTest, is_valid_onValidDateTime_shouldReturn_True)
-{
-  result= datetime.is_valid();
-  ASSERT_TRUE(result);
-}
-
-TEST_F(DateTimeTest, is_valid_onInvalidDateTimeWithYearBelowMinimum_shouldReturn_False)
-{
-  datetime.set_years(DRIZZLE_MIN_YEARS_SQL - 1);
-  
-  result= datetime.is_valid();
-  
-  ASSERT_FALSE(result);
-}
-
-TEST_F(DateTimeTest, is_valid_onInvalidDateTimeWithYearAboveMaximum_shouldReturn_False)
-{
-  datetime.set_years(DRIZZLE_MAX_YEARS_SQL + 1);
-    
-  result= datetime.is_valid();
-  
-  ASSERT_FALSE(result);
-}
-
-TEST_F(DateTimeTest, is_valid_onInvalidDateTimeWithMonthSetToZero_shouldReturn_False)
-{
-  datetime.set_months(0);
-  
-  result= datetime.is_valid();
-  
-  ASSERT_FALSE(result);
-}
-
-
-TEST_F(DateTimeTest, is_valid_onInvalidDateTimeWithMonthAboveMaximum_shouldReturn_False)
-{
-  datetime.set_months(13);
-  
-  result= datetime.is_valid();
-  
-  ASSERT_FALSE(result);
-}
-
-TEST_F(DateTimeTest, is_valid_onInvalidDateTimeWithDaySetToZero_shouldReturn_False)
-{
-  datetime.set_days(0);
-  
-  result= datetime.is_valid();
-  
-  ASSERT_FALSE(result);
-}
-
-TEST_F(DateTimeTest, is_valid_onInvalidDateTimeWithDayAboveDaysInMonth_shouldReturn_False)
-{
-  datetime.set_days(32);
-  
-  result= datetime.is_valid();
-  
-  ASSERT_FALSE(result);
-}
-
-TEST_F(DateTimeTest, is_valid_onInvalidDateTimeWithLeapDayInNonLeapYear_shouldReturn_False)
-{
-  TemporalGenerator::TemporalGen::leap_day_in_non_leap_year(&datetime);
-  
-  result= datetime.is_valid();
-  
-  ASSERT_FALSE(result);
-}
-
-TEST_F(DateTimeTest, is_valid_onValidDateTimeWithLeapDayInLeapYear_shouldReturn_True)
-{
-  TemporalGenerator::TemporalGen::leap_day_in_leap_year(&datetime);
-  
-  result= datetime.is_valid();
-  
-  ASSERT_TRUE(result);
-}
-
-TEST_F(DateTimeTest, is_valid_onValidMinimalTime_shouldReturn_True)
-{
-  TemporalGenerator::TemporalGen::make_min_time(&datetime);
-  
-  result= datetime.is_valid();
-  
-  ASSERT_TRUE(result);
-}
-
-TEST_F(DateTimeTest, is_valid_onValidMaximalTime_shouldReturn_True)
-{
-  TemporalGenerator::TemporalGen::make_max_time(&datetime);
-  
-  result= datetime.is_valid();
-  
-  ASSERT_TRUE(result);
-}
-
-TEST_F(DateTimeTest, is_valid_onInvalidDateTimeWithHourAboveMaximum23_shouldReturn_False)
-{
-  datetime.set_hours(24);
-  
-  result= datetime.is_valid();
-  
-  ASSERT_FALSE(result);
-}
-
-TEST_F(DateTimeTest, is_valid_onInvalidDateTimeWithMinutesAboveMaximum59_shouldReturn_False)
-{
-  datetime.set_minutes(60);
-  
-  result= datetime.is_valid();
-  
-  ASSERT_FALSE(result);
-}
-
-TEST_F(DateTimeTest, is_valid_onInvalidDateTimeWithSecondsAboveMaximum61_shouldReturn_False)
-{
-  datetime.set_seconds(62);
-  
-  result= datetime.is_valid();
-  
-  ASSERT_FALSE(result);
-}
-
-TEST_F(DateTimeTest, to_string_shouldProduce_hyphenSeperatedDateElements_and_colonSeperatedTimeElements)
-{
-  char expected[DateTime::MAX_STRING_LENGTH]= "2010-05-01 08:07:06.123456";
-  char returned[DateTime::MAX_STRING_LENGTH];
-  TemporalGenerator::DateTimeGen::make_datetime(&datetime, 2010, 5, 1, 8, 7, 6, 123456);
-  
-  datetime.to_string(returned, DateTime::MAX_STRING_LENGTH);
-  
-  ASSERT_STREQ(expected, returned);
-}
-
-TEST_F(DateTimeTest, to_string_nullBuffer_noMicroSeconds_shouldReturnProperLengthAnyway)
-{
-  int length= datetime.to_string(NULL, 0);
-  
-  ASSERT_EQ(DateTime::MAX_STRING_LENGTH - 1 - 7, length);  
-}
-
-TEST_F(DateTimeTest, to_int64_t)
-{
-  TemporalGenerator::DateTimeGen::make_datetime(&datetime, 2030, 8, 7, 14, 5, 13);
-  int64_t representation;
-
-  datetime.to_int64_t(&representation);
-
-  ASSERT_EQ(20300807140513LL, representation);
-}
-
-TEST_F(DateTimeTest, from_int64_t_no_conversion_format_YYYYMMDDHHMMSSshouldPopulateDateTimeCorrectly)
-{
-  datetime.from_int64_t(20300807140513LL, false);
-  
-  assignDateTimeValues();
-  
-  EXPECT_EQ(2030, years);
-  EXPECT_EQ(8, months);
-  EXPECT_EQ(7, days);
-  EXPECT_EQ(14, hours);
-  EXPECT_EQ(5, minutes);
-  EXPECT_EQ(13, seconds);
-}
-
-TEST_F(DateTimeTest, from_int64_t_with_conversion_format_YYYYMMDDHHMMSS_yearOver2000)
-{
-  datetime.from_int64_t(20300807140513LL, true);
-  
-  assignDateTimeValues();
-  
-  EXPECT_EQ(2030, years);
-  EXPECT_EQ(8, months);
-  EXPECT_EQ(7, days);
-  EXPECT_EQ(14, hours);
-  EXPECT_EQ(5, minutes);
-  EXPECT_EQ(13, seconds);
-}
-
-TEST_F(DateTimeTest, from_int64_t_with_conversion_format_YYYYMMDDHHMMSS_yearBelow2000)
-{
-  datetime.from_int64_t(19900807140513LL, true);
-  
-  assignDateTimeValues();
-  
-  EXPECT_EQ(1990, years);
-  EXPECT_EQ(8, months);
-  EXPECT_EQ(7, days);
-  EXPECT_EQ(14, hours);
-  EXPECT_EQ(5, minutes);
-  EXPECT_EQ(13, seconds);
-}
-
-TEST_F(DateTimeTest, from_int64_t_with_conversion_format_YYMMDDHHMMSS_yearOver2000)
-{
-  datetime.from_int64_t(300807140513LL, true);
-  
-  assignDateTimeValues();
-  
-  EXPECT_EQ(2030, years);
-  EXPECT_EQ(8, months);
-  EXPECT_EQ(7, days);
-  EXPECT_EQ(14, hours);
-  EXPECT_EQ(5, minutes);
-  EXPECT_EQ(13, seconds);
-}
-
-TEST_F(DateTimeTest, from_int64_t_with_conversion_format_YYMMDDHHMMSS_yearBelow2000)
-{
-  datetime.from_int64_t(900807140513LL, true);
-  
-  assignDateTimeValues();
-  
-  EXPECT_EQ(1990, years);
-  EXPECT_EQ(8, months);
-  EXPECT_EQ(7, days);
-  EXPECT_EQ(14, hours);
-  EXPECT_EQ(5, minutes);
-  EXPECT_EQ(13, seconds);
-}
-
-TEST_F(DateTimeTest, DISABLED_to_tm)
-{
-  years= 2030, months= 8, days= 17, hours= 14, minutes= 45, seconds= 13;
-  TemporalGenerator::DateTimeGen::make_datetime(&datetime, years, months, days, hours, minutes, seconds);
-  struct tm filled;
-  
-  datetime.to_tm(&filled);
-  
-  EXPECT_EQ(2030 - 1900, filled.tm_year);
-  EXPECT_EQ(8 - 1, filled.tm_mon);
-  EXPECT_EQ(17, filled.tm_mday);
-  EXPECT_EQ(14, filled.tm_hour);
-  EXPECT_EQ(45, filled.tm_min);
-  EXPECT_EQ(13, filled.tm_sec);
-
-  /* TODO:these fail, shouldn't they also be set properly? */
-  EXPECT_EQ(228, filled.tm_yday);
-  EXPECT_EQ(6, filled.tm_wday);
-  EXPECT_EQ(-1, filled.tm_isdst);
-}
-
-TEST_F(DateTimeTest, to_decimal)
-{
-  drizzled::type::Decimal to;
-  TemporalGenerator::DateTimeGen::make_datetime(&datetime, 1987, 6, 13, 5, 10, 13, 456);
-
-  datetime.to_decimal(&to);
-  
-  EXPECT_EQ(19870,to.buf[0]);
-  EXPECT_EQ(613051013,to.buf[1]);
-  EXPECT_EQ(456000,to.buf[2]);
-}
-
-
-
-class DateTimeFromStringTest
-{
-  protected:
-    DateTime datetime;
-    bool result;
-    uint32_t years, months, days;
-    uint32_t hours, minutes, seconds;
-
-    void init()
-    {
-      init_temporal_formats();
-    }
-
-    void deinit()
-    {
-      deinit_temporal_formats();
-    }
-
-    void assignDateTimeValues()
-    {
-      years= datetime.years();
-      months= datetime.months();
-      days= datetime.days();
-      hours= datetime.hours();
-      minutes= datetime.minutes();
-      seconds= datetime.seconds();
-    }
-};
-
-class DateTimeFromStringFullFormatTest: public ::testing::TestWithParam<const char*>, public DateTimeFromStringTest
-{
-  virtual void SetUp()
-  {
-    init();
-  }
-  
-  virtual void TearDown()
-  {
-    deinit();
-  }  
-};
-
-class DateTimeFromStringNoSecondFormatTest: public ::testing::TestWithParam<const char*>, public DateTimeFromStringTest
-{
-  virtual void SetUp()
-  {
-    init();
-  }
-  
-  virtual void TearDown()
-  {
-    deinit();
-  }
-};
-
-class DateTimeFromStringDateOnlyTest: public ::testing::TestWithParam<const char*>, public DateTimeFromStringTest
-{
-  virtual void SetUp()
-  {
-    init();
-  }
-  
-  virtual void TearDown()
-  {
-    deinit();
-  }
-};
-
-TEST_P(DateTimeFromStringFullFormatTest, from_string_validString)
-{
-  const char *valid_string= GetParam();
-
-  result= datetime.from_string(valid_string, strlen(valid_string));
-  ASSERT_TRUE(result);
-
-  assignDateTimeValues();
-
-  EXPECT_EQ(2010, years);
-  EXPECT_EQ(5, months);
-  EXPECT_EQ(1, days);
-  EXPECT_EQ(8, hours);
-  EXPECT_EQ(7, minutes);
-  EXPECT_EQ(6, seconds);
-}
-/* TODO:for some reason this was not declared by the macro, needs clarification*/
-testing::internal::ParamGenerator<const char*> gtest_ValidStringDateTimeFromStringFullFormatTest_EvalGenerator_();
-INSTANTIATE_TEST_CASE_P(ValidString, DateTimeFromStringFullFormatTest,
-                        ::testing::Values("20100501080706",
-                                          "2010-05-01 08:07:06",
-                                          "2010/05/01T08:07:06",
-                                          "2010.5.1 08:07:06",
-                                          "10-05-01 08:07:06",
-                                          "10/5/1 08:07:06",
-                                          "10.5.1 08:07:06"));
-
-                                          
-TEST_P(DateTimeFromStringNoSecondFormatTest, from_string_validString)
-{
-  const char *valid_string= GetParam();
-
-  result= datetime.from_string(valid_string, strlen(valid_string));
-  ASSERT_TRUE(result);
-
-  assignDateTimeValues();
-
-  EXPECT_EQ(2010, years);
-  EXPECT_EQ(5, months);
-  EXPECT_EQ(1, days);
-  EXPECT_EQ(8, hours);
-  EXPECT_EQ(7, minutes);
-}
-
-/* TODO:for some reason this was not declared by the macro, needs clarification*/
-testing::internal::ParamGenerator<const char*> gtest_ValidStringDateTimeFromStringNoSecondFormatTest_EvalGenerator_();
-INSTANTIATE_TEST_CASE_P(ValidString, DateTimeFromStringNoSecondFormatTest,
-                        ::testing::Values("2010-05-01 08:07",
-                                          "2010/05/01 08:07",
-                                          "2010.5.1 08:07",
-                                          "10-05-01 08:07",
-                                          "10/5/1 08:07",
-                                          "10.5.1 08:07"));
-
-
-
-TEST_P(DateTimeFromStringDateOnlyTest, from_string_validString)
-{
-  const char *valid_string= GetParam();
-
-  result= datetime.from_string(valid_string, strlen(valid_string));
-  ASSERT_TRUE(result);
-
-  assignDateTimeValues();
-
-  EXPECT_EQ(2010, years);
-  EXPECT_EQ(6, months);
-  EXPECT_EQ(7, days);
-}
-
-/* TODO:for some reason this was not declared by the macro, needs clarification*/
-testing::internal::ParamGenerator<const char*> gtest_ValidStringDateTimeFromStringDateOnlyTest_EvalGenerator_();
-INSTANTIATE_TEST_CASE_P(ValidString, DateTimeFromStringDateOnlyTest,
-                        ::testing::Values("20100607", /* YYYYMMDD */
-                                          "06/07/2010",/* MM[-/.]DD[-/.]YYYY (US common format)*/
-                                          "10.06.07",/* YY[-/.]MM[-/.]DD */
-                                          "10/6/7",/* YY[-/.][M]M[-/.][D]D */
-                                          "2010-6-7"/* YYYY[-/.][M]M[-/.][D]D */));
-
-                                          
 
=== removed file 'unittests/generators.cc'
--- unittests/generators.cc	2010-07-09 17:59:07 +0000
+++ unittests/generators.cc	1970-01-01 00:00:00 +0000
@@ -1,72 +0,0 @@
-/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
- *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
- *
- *  Copyright (C) 2010 Brian Aker
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- */
-
-#include "config.h"
-
-#include <gtest/gtest.h>
-
-#include <drizzled/generator.h>
-#include <drizzled/plugin/listen.h>
-
-/*
-  These will not work currently because of init issues for the server.
-*/
-#if 0
-TEST(generator_test, schema)
-{
-  drizzled::Session session(drizzled::plugin::Listen::getNullClient());
-  drizzled::generator::Schema generator(session);
-
-  const drizzled::message::Schema *schema_ptr;
-  if ((schema_ptr= generator))
-    ASSERT_TRUE(0);
-}
-
-TEST(generator_test, table)
-{
-  drizzled::Session session(drizzled::plugin::Listen::getNullClient());
-  drizzled::SchemaIdentifier schema("foo");
-  drizzled::generator::Table generator(session, schema);
-  const drizzled::message::Table *table_ptr;
-
-  if ((table_ptr= generator))
-    ASSERT_TRUE(0);
-}
-
-TEST(generator_test, all_tables)
-{
-  drizzled::Session session(drizzled::plugin::Listen::getNullClient());
-  drizzled::generator::AllTables generator(session);
-  const drizzled::message::Table *table_ptr;
-
-  if ((table_ptr= generator))
-    ASSERT_TRUE(0);
-}
-
-TEST(generator_test, all_fields)
-{
-  drizzled::Session session(drizzled::plugin::Listen::getNullClient());
-  drizzled::generator::AllFields generator(session);
-  const drizzled::message::Table::Field *field_ptr;
-
-  if ((field_ptr= generator))
-    ASSERT_TRUE(0);
-}
-#endif
 
=== added file 'unittests/global_buffer_test.cc'
--- unittests/global_buffer_test.cc	1970-01-01 00:00:00 +0000
+++ unittests/global_buffer_test.cc	2011-01-24 09:18:02 +0000
@@ -0,0 +1,64 @@
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+ *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ *  Copyright (C) 2010 Andrew Hutchings
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "config.h"
+
+#define BOOST_TEST_DYN_LINK
+#include <boost/test/unit_test.hpp>
+
+#include "drizzled/global_buffer.h"
+
+BOOST_AUTO_TEST_SUITE(GlobalBufferTests)
+BOOST_AUTO_TEST_CASE(overflow)
+{
+  drizzled::global_buffer_constraint<uint64_t> test_buffer(1024);
+
+  BOOST_REQUIRE(test_buffer.add(512));
+  BOOST_REQUIRE(test_buffer.add(512));
+  BOOST_REQUIRE(not test_buffer.add(1));
+}
+
+BOOST_AUTO_TEST_CASE(subtract)
+{
+  drizzled::global_buffer_constraint<uint64_t> test_buffer(1024);
+
+  BOOST_REQUIRE(test_buffer.add(1024));
+  BOOST_REQUIRE(test_buffer.sub(512));
+  BOOST_REQUIRE(test_buffer.add(512));
+  BOOST_REQUIRE(not test_buffer.add(1));
+}
+
+BOOST_AUTO_TEST_CASE(underflow)
+{
+  drizzled::global_buffer_constraint<uint64_t> test_buffer(1024);
+
+  BOOST_REQUIRE(test_buffer.add(10));
+  BOOST_REQUIRE(not test_buffer.sub(11));
+}
+
+BOOST_AUTO_TEST_CASE(change_max)
+{
+  drizzled::global_buffer_constraint<uint64_t> test_buffer(1024);
+
+  test_buffer.setMaxSize(512);
+
+  BOOST_REQUIRE(not test_buffer.add(513));
+}
+BOOST_AUTO_TEST_SUITE_END()
 
=== removed file 'unittests/global_buffer_test.cc'
--- unittests/global_buffer_test.cc	2010-10-20 09:34:21 +0000
+++ unittests/global_buffer_test.cc	1970-01-01 00:00:00 +0000
@@ -1,60 +0,0 @@
-/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
- *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
- *
- *  Copyright (C) 2010 Andrew Hutchings
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- */
-
-#include "config.h"
-
-#include <gtest/gtest.h>
-#include "drizzled/global_buffer.h"
-
-TEST(global_buffer, overflow)
-{
-  drizzled::global_buffer_constraint<uint64_t> test_buffer(1024);
-
-  ASSERT_TRUE(test_buffer.add(512));
-  ASSERT_TRUE(test_buffer.add(512));
-  ASSERT_FALSE(test_buffer.add(1));
-}
-
-TEST(global_buffer, subtract)
-{
-  drizzled::global_buffer_constraint<uint64_t> test_buffer(1024);
-
-  ASSERT_TRUE(test_buffer.add(1024));
-  ASSERT_TRUE(test_buffer.sub(512));
-  ASSERT_TRUE(test_buffer.add(512));
-  ASSERT_FALSE(test_buffer.add(1));
-}
-
-TEST(global_buffer, underflow)
-{
-  drizzled::global_buffer_constraint<uint64_t> test_buffer(1024);
-
-  ASSERT_TRUE(test_buffer.add(10));
-  ASSERT_FALSE(test_buffer.sub(11));
-}
-
-TEST(global_buffer, change_max)
-{
-  drizzled::global_buffer_constraint<uint64_t> test_buffer(1024);
-
-  test_buffer.setMaxSize(512);
-
-  ASSERT_FALSE(test_buffer.add(513));
-}
 
=== modified file 'unittests/include.am'
--- unittests/include.am	2010-12-28 20:54:15 +0000
+++ unittests/include.am	2011-01-24 09:18:02 +0000
@@ -17,8 +17,7 @@
 #  along with this program; if not, write to the Free Software
 #  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
-
-if HAVE_LIBGTEST
+if HAVE_BOOST_TEST
 check_PROGRAMS += unittests/unittests
 endif
 
@@ -26,9 +25,6 @@
 		  unittests/plugin/plugin_stubs.h \
 		  unittests/temporal_generator.h
 
-EXTRA_DIST += \
-	      unittests/client_server.c
-
 unit: unittests/unittests
 	unittests/unittests
 
@@ -38,30 +34,26 @@
 #		     
 
 unittests_unittests_SOURCES = \
+                              unittests/main.cc \
 			      unittests/atomics_test.cc \
 			      unittests/calendar_test.cc \
 			      unittests/constrained_value.cc \
 			      unittests/date_test.cc \
 			      unittests/date_time_test.cc \
-			      unittests/generators.cc \
-                              unittests/global_buffer_test.cc \
-                              unittests/libdrizzle_test.cc \
-			      unittests/main.cc \
+			      unittests/global_buffer_test.cc \
+			      unittests/libdrizzle_test.cc \
 			      unittests/micro_timestamp_test.cc \
 			      unittests/nano_timestamp_test.cc \
 			      unittests/option_context.cc \
-			      unittests/plugin/authentication_test.cc \
-			      unittests/plugin/client_test.cc \
-			      unittests/plugin/error_message_test.cc \
 			      unittests/pthread_atomics_test.cc \
 			      unittests/table_identifier.cc \
 			      unittests/temporal_format_test.cc \
-			      unittests/temporal_generator.cc \
+			      unittests/temporal_generator.cc  \
+			      unittests/timestamp_test.cc \
 			      unittests/time_test.cc \
-			      unittests/timestamp_test.cc \
 			      unittests/utf8_test.cc
 
 unittests_unittests_LDADD= \
   $(filter-out drizzled/main.$(OBJEXT), ${am_drizzled_drizzled_OBJECTS}) \
-  ${drizzled_drizzled_LDADD} ${LTLIBGTEST} ${BOOST_LIBS} \
-  libdrizzle/libdrizzle.la
+  ${drizzled_drizzled_LDADD} ${BOOST_LIBS} libdrizzle/libdrizzle.la \
+  ${LTLIBBOOST_UNIT_TEST_FRAMEWORK} ${LTLIBBOOST_UNIT_TEST_FRAMEWORK_MT}
 
=== added file 'unittests/libdrizzle_test.cc'
--- unittests/libdrizzle_test.cc	1970-01-01 00:00:00 +0000
+++ unittests/libdrizzle_test.cc	2011-01-24 09:18:02 +0000
@@ -0,0 +1,63 @@
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+ *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ *  Copyright (C) 2010 Andrew Hutchings
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "config.h"
+
+#define BOOST_TEST_DYN_LINK
+#include <boost/test/unit_test.hpp>
+
+#include <libdrizzle/drizzle_client.h>
+#include <libdrizzle/drizzle_server.h>
+
+BOOST_AUTO_TEST_SUITE(LibDrizzle)
+BOOST_AUTO_TEST_CASE(drizzleEscapeString)
+{
+  const char* orig= "hello \"world\"\n";
+  char out[255];
+  size_t out_len;
+
+  out_len= drizzle_escape_string(out, orig, strlen(orig));
+
+  BOOST_REQUIRE_EQUAL(17, out_len);
+  BOOST_REQUIRE_EQUAL("hello \\\"world\\\"\\n", out);
+}
+
+BOOST_AUTO_TEST_CASE(drizzleHexString)
+{
+  const unsigned char orig[5]= {0x34, 0x26, 0x80, 0x99, 0xFF};
+  char out[255];
+  size_t out_len;
+
+  out_len= drizzle_hex_string(out, (char*) orig, 5);
+
+  BOOST_REQUIRE_EQUAL(10, out_len);
+  BOOST_REQUIRE_EQUAL("34268099FF", out);
+}
+
+BOOST_AUTO_TEST_CASE(drizzleMysqlPasswordHash)
+{
+  const char* orig= "test password";
+  char out[255];
+
+  drizzle_mysql_password_hash(out, orig, strlen(orig));
+
+  BOOST_REQUIRE_EQUAL("3B942720DACACBBA7E3838AF03C5B6B5A6DFE0AB", out);
+}
+BOOST_AUTO_TEST_SUITE_END()
 
=== removed file 'unittests/libdrizzle_test.cc'
--- unittests/libdrizzle_test.cc	2010-10-17 16:04:42 +0000
+++ unittests/libdrizzle_test.cc	1970-01-01 00:00:00 +0000
@@ -1,59 +0,0 @@
-/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
- *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
- *
- *  Copyright (C) 2010 Andrew Hutchings
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- */
-
-#include "config.h"
-
-#include <gtest/gtest.h>
-#include <libdrizzle/drizzle_client.h>
-#include <libdrizzle/drizzle_server.h>
-
-TEST(libdrizzle, drizzle_escape_string)
-{
-  const char* orig= "hello \"world\"\n";
-  char out[255];
-  size_t out_len;
-
-  out_len= drizzle_escape_string(out, orig, strlen(orig));
-
-  EXPECT_EQ(17, out_len);
-  ASSERT_STREQ("hello \\\"world\\\"\\n", out);
-}
-
-TEST(libdrizzle, drizzle_hex_string)
-{
-  const unsigned char orig[5]= {0x34, 0x26, 0x80, 0x99, 0xFF};
-  char out[255];
-  size_t out_len;
-
-  out_len= drizzle_hex_string(out, (char*) orig, 5);
-
-  EXPECT_EQ(10, out_len);
-  ASSERT_STREQ("34268099FF", out);
-}
-
-TEST(libdrizzle, drizzle_mysql_password_hash)
-{
-  const char* orig= "test password";
-  char out[255];
-
-  drizzle_mysql_password_hash(out, orig, strlen(orig));
-
-  ASSERT_STREQ("3B942720DACACBBA7E3838AF03C5B6B5A6DFE0AB", out);
-}
 
=== modified file 'unittests/main.cc'
--- unittests/main.cc	2010-06-06 20:55:30 +0000
+++ unittests/main.cc	2011-01-24 09:18:02 +0000
@@ -1,7 +1,7 @@
 /* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
  *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
  *
- *  Copyright (C) 2010 Stewart Smith
+ *  Copyright (C) 2011 Andrew Hutchings
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -18,15 +18,26 @@
  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
-#include "config.h"
-
-#include <gtest/gtest.h>
-
-#include <drizzled/internal/my_sys.h>
-
-int main(int argc, char **argv)
-{
-	MY_INIT(argv[0]);
-  ::testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+#include <iostream>
+
+struct MyConfig
+{
+    MyConfig()
+    {
+       boost::unit_test::unit_test_log.set_threshold_level(boost::unit_test::log_messages);
+    }
+
+    ~MyConfig()
+    {
+    }
+};
+
+BOOST_GLOBAL_FIXTURE( MyConfig )
+
+BOOST_AUTO_TEST_CASE(MainInit)
+{
+  BOOST_REQUIRE(true);
 }
 
=== added file 'unittests/micro_timestamp_test.cc'
--- unittests/micro_timestamp_test.cc	1970-01-01 00:00:00 +0000
+++ unittests/micro_timestamp_test.cc	2011-01-24 09:18:02 +0000
@@ -0,0 +1,112 @@
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+ *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ *  Copyright (C) 2010 Pawel Blokus
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "config.h"
+
+#define BOOST_TEST_DYN_LINK
+#include <boost/test/unit_test.hpp>
+
+#include <drizzled/temporal.h>
+
+#include "temporal_generator.h"
+
+using namespace drizzled;
+
+class MicroTimestampTest
+{
+  protected:
+    MicroTimestamp micro_timestamp;
+    bool result;
+};
+
+BOOST_FIXTURE_TEST_SUITE(MicroTimestampTestSuite, MicroTimestampTest)
+BOOST_AUTO_TEST_CASE(is_valid_minOfMicroTimestampRange_shouldReturn_True)
+{
+  uint32_t year= 1970, month= 1, day= 1, hour= 0, minute= 0, second= 0, microsecond= 0;
+  TemporalGenerator::TimestampGen::make_micro_timestamp(&micro_timestamp, year, month, day, hour, minute, second, microsecond);
+
+  result= micro_timestamp.is_valid();
+
+  BOOST_REQUIRE(result);
+}
+
+BOOST_AUTO_TEST_CASE(is_valid_maxOfMicroTimestampRange_shouldReturn_True)
+{
+  uint32_t year= 2038, month= 1, day= 19, hour= 3, minute= 14, second= 7, microsecond= 0;
+  TemporalGenerator::TimestampGen::make_micro_timestamp(&micro_timestamp, year, month, day, hour, minute, second, microsecond);
+
+  result= micro_timestamp.is_valid();
+
+  BOOST_REQUIRE(result);
+}
+
+BOOST_AUTO_TEST_CASE(is_valid_oneMicroSecondBeforeMicroTimestampMinOfRange_shouldReturn_False)
+{
+  uint32_t year= 1969, month= 12, day= 31, hour= 23, minute= 59, second= 59, microsecond= 999999;
+  TemporalGenerator::TimestampGen::make_micro_timestamp(&micro_timestamp, year, month, day, hour, minute, second, microsecond);
+
+  result= micro_timestamp.is_valid();
+
+  BOOST_REQUIRE(not result);
+}
+
+BOOST_AUTO_TEST_CASE(is_valid_oneMicroSecondAfterMicroTimestampMaxOfRange_shouldReturn_False)
+{
+  uint32_t year= 2038, month= 1, day= 19, hour= 3, minute= 14, second= 8, microsecond= 1;
+  TemporalGenerator::TimestampGen::make_micro_timestamp(&micro_timestamp, year, month, day, hour, minute, second, microsecond);
+
+  result= micro_timestamp.is_valid();
+
+  BOOST_REQUIRE(not result);
+}
+
+BOOST_AUTO_TEST_CASE(is_valid_InsideOfMicroTimestampRange_shouldReturn_True)
+{
+  uint32_t year= 1980, month= 11, day= 1, hour= 5, minute= 8, second= 5, microsecond= 18263;
+  TemporalGenerator::TimestampGen::make_micro_timestamp(&micro_timestamp, year, month, day, hour, minute, second, microsecond);
+
+  result= micro_timestamp.is_valid();
+
+  BOOST_REQUIRE(result);
+}
+
+BOOST_AUTO_TEST_CASE(to_string_shouldProduce_hyphenSeperatedDateElements_and_colonSeperatedTimeElements)
+{
+  char expected[MicroTimestamp::MAX_STRING_LENGTH]= "2010-05-01 08:07:06.007654";
+  char returned[MicroTimestamp::MAX_STRING_LENGTH];
+  TemporalGenerator::TimestampGen::make_micro_timestamp(&micro_timestamp, 2010, 5, 1, 8, 7, 6, 7654);
+  
+  micro_timestamp.to_string(returned, MicroTimestamp::MAX_STRING_LENGTH);
+  
+  BOOST_REQUIRE_EQUAL(expected, returned);
+}
+
+BOOST_AUTO_TEST_CASE(to_timeval)
+{
+  struct timeval filled;
+  uint32_t year= 2009, month= 6, day= 3, hour= 4, minute= 59, second= 1, microsecond= 675;
+  TemporalGenerator::TimestampGen::make_micro_timestamp(&micro_timestamp, year, month, day, hour, minute, second, microsecond);
+
+  micro_timestamp.to_timeval(filled);
+
+  BOOST_REQUIRE_EQUAL(1244005141, filled.tv_sec);
+  BOOST_REQUIRE_EQUAL(675, filled.tv_usec);
+}
+BOOST_AUTO_TEST_SUITE_END()
 
=== removed file 'unittests/micro_timestamp_test.cc'
--- unittests/micro_timestamp_test.cc	2011-01-20 07:24:29 +0000
+++ unittests/micro_timestamp_test.cc	1970-01-01 00:00:00 +0000
@@ -1,108 +0,0 @@
-/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
- *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
- *
- *  Copyright (C) 2010 Pawel Blokus
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- */
-
-#include "config.h"
-
-#include <gtest/gtest.h>
-#include <drizzled/temporal.h>
-
-#include "temporal_generator.h"
-
-using namespace drizzled;
-
-class MicroTimestampTest : public ::testing::Test
-{
-  protected:
-    MicroTimestamp micro_timestamp;
-    bool result;
-};
-
-TEST_F(MicroTimestampTest, is_valid_minOfMicroTimestampRange_shouldReturn_True)
-{
-  uint32_t year= 1970, month= 1, day= 1, hour= 0, minute= 0, second= 0, microsecond= 0;
-  TemporalGenerator::TimestampGen::make_micro_timestamp(&micro_timestamp, year, month, day, hour, minute, second, microsecond);
-
-  result= micro_timestamp.is_valid();
-
-  ASSERT_TRUE(result);
-}
-
-TEST_F(MicroTimestampTest, is_valid_maxOfMicroTimestampRange_shouldReturn_True)
-{
-  uint32_t year= 2038, month= 1, day= 19, hour= 3, minute= 14, second= 7, microsecond= 0;
-  TemporalGenerator::TimestampGen::make_micro_timestamp(&micro_timestamp, year, month, day, hour, minute, second, microsecond);
-
-  result= micro_timestamp.is_valid();
-
-  ASSERT_TRUE(result);
-}
-
-TEST_F(MicroTimestampTest, is_valid_oneMicroSecondBeforeMicroTimestampMinOfRange_shouldReturn_False)
-{
-  uint32_t year= 1969, month= 12, day= 31, hour= 23, minute= 59, second= 59, microsecond= 999999;
-  TemporalGenerator::TimestampGen::make_micro_timestamp(&micro_timestamp, year, month, day, hour, minute, second, microsecond);
-
-  result= micro_timestamp.is_valid();
-
-  ASSERT_FALSE(result);
-}
-
-TEST_F(MicroTimestampTest, is_valid_oneMicroSecondAfterMicroTimestampMaxOfRange_shouldReturn_False)
-{
-  uint32_t year= 2038, month= 1, day= 19, hour= 3, minute= 14, second= 8, microsecond= 1;
-  TemporalGenerator::TimestampGen::make_micro_timestamp(&micro_timestamp, year, month, day, hour, minute, second, microsecond);
-
-  result= micro_timestamp.is_valid();
-
-  ASSERT_FALSE(result);
-}
-
-TEST_F(MicroTimestampTest, is_valid_InsideOfMicroTimestampRange_shouldReturn_True)
-{
-  uint32_t year= 1980, month= 11, day= 1, hour= 5, minute= 8, second= 5, microsecond= 18263;
-  TemporalGenerator::TimestampGen::make_micro_timestamp(&micro_timestamp, year, month, day, hour, minute, second, microsecond);
-
-  result= micro_timestamp.is_valid();
-
-  ASSERT_TRUE(result);
-}
-
-TEST_F(MicroTimestampTest, to_string_shouldProduce_hyphenSeperatedDateElements_and_colonSeperatedTimeElements)
-{
-  char expected[MicroTimestamp::MAX_STRING_LENGTH]= "2010-05-01 08:07:06.007654";
-  char returned[MicroTimestamp::MAX_STRING_LENGTH];
-  TemporalGenerator::TimestampGen::make_micro_timestamp(&micro_timestamp, 2010, 5, 1, 8, 7, 6, 7654);
-  
-  micro_timestamp.to_string(returned, MicroTimestamp::MAX_STRING_LENGTH);
-  
-  ASSERT_STREQ(expected, returned);
-}
-
-TEST_F(MicroTimestampTest, to_timeval)
-{
-  struct timeval filled;
-  uint32_t year= 2009, month= 6, day= 3, hour= 4, minute= 59, second= 1, microsecond= 675;
-  TemporalGenerator::TimestampGen::make_micro_timestamp(&micro_timestamp, year, month, day, hour, minute, second, microsecond);
-
-  micro_timestamp.to_timeval(filled);
-
-  EXPECT_EQ(1244005141, filled.tv_sec);
-  EXPECT_EQ(675, filled.tv_usec);
-}
 
=== added file 'unittests/nano_timestamp_test.cc'
--- unittests/nano_timestamp_test.cc	1970-01-01 00:00:00 +0000
+++ unittests/nano_timestamp_test.cc	2011-01-24 09:18:02 +0000
@@ -0,0 +1,101 @@
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+ *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ *  Copyright (C) 2010 Pawel Blokus
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "config.h"
+
+#define BOOST_TEST_DYN_LINK
+#include <boost/test/unit_test.hpp>
+
+#include <drizzled/temporal.h>
+
+#include "temporal_generator.h"
+
+using namespace drizzled;
+
+class NanoTimestampTest
+{
+  protected:
+    NanoTimestamp nano_timestamp;
+    bool result;
+};
+
+BOOST_FIXTURE_TEST_SUITE(NanoTimestampTestSuite, NanoTimestampTest)
+BOOST_AUTO_TEST_CASE(is_valid_minOfNanoTimestampRange_shouldReturn_True)
+{
+  uint32_t year= 1970, month= 1, day= 1, hour= 0, minute= 0, second= 0, nanosecond= 0;
+  TemporalGenerator::TimestampGen::make_nano_timestamp(&nano_timestamp, year, month, day, hour, minute, second, nanosecond);
+
+  result= nano_timestamp.is_valid();
+
+  BOOST_REQUIRE(result);
+}
+
+BOOST_AUTO_TEST_CASE(is_valid_maxOfNanoTimestampRange_shouldReturn_True)
+{
+  uint32_t year= 2038, month= 1, day= 19, hour= 3, minute= 14, second= 7, nanosecond= 0;
+  TemporalGenerator::TimestampGen::make_nano_timestamp(&nano_timestamp, year, month, day, hour, minute, second, nanosecond);
+
+  result= nano_timestamp.is_valid();
+
+  BOOST_REQUIRE(result);
+}
+
+BOOST_AUTO_TEST_CASE(is_valid_oneMicroSecondBeforeNanoTimestampMinOfRange_shouldReturn_False)
+{
+  uint32_t year= 1969, month= 12, day= 31, hour= 23, minute= 59, second= 59, nanosecond= 999999999;
+  TemporalGenerator::TimestampGen::make_nano_timestamp(&nano_timestamp, year, month, day, hour, minute, second, nanosecond);
+
+  result= nano_timestamp.is_valid();
+
+  BOOST_REQUIRE(not result);
+}
+
+BOOST_AUTO_TEST_CASE(is_valid_oneMicroSecondAfterNanoTimestampMaxOfRange_shouldReturn_False)
+{
+  uint32_t year= 2038, month= 1, day= 19, hour= 3, minute= 14, second= 8, nanosecond= 1;
+  TemporalGenerator::TimestampGen::make_nano_timestamp(&nano_timestamp, year, month, day, hour, minute, second, nanosecond);
+
+  result= nano_timestamp.is_valid();
+
+  BOOST_REQUIRE(not result);
+}
+
+BOOST_AUTO_TEST_CASE(is_valid_InsideOfNanoTimestampRange_shouldReturn_True)
+{
+  uint32_t year= 1980, month= 11, day= 1, hour= 5, minute= 8, second= 5, nanosecond= 3265832;
+  TemporalGenerator::TimestampGen::make_nano_timestamp(&nano_timestamp, year, month, day, hour, minute, second, nanosecond);
+
+  result= nano_timestamp.is_valid();
+
+  BOOST_REQUIRE(result);
+}
+
+BOOST_AUTO_TEST_CASE(to_timespec)
+{
+  struct timespec filled;
+  uint32_t year= 2009, month= 6, day= 3, hour= 4, minute= 59, second= 1, nanosecond= 675;
+  TemporalGenerator::TimestampGen::make_nano_timestamp(&nano_timestamp, year, month, day, hour, minute, second, nanosecond);
+
+  nano_timestamp.to_timespec(&filled);
+
+  BOOST_REQUIRE_EQUAL(1244005141, filled.tv_sec);
+  BOOST_REQUIRE_EQUAL(675, filled.tv_nsec);
+}
+BOOST_AUTO_TEST_SUITE_END()
 
=== removed file 'unittests/nano_timestamp_test.cc'
--- unittests/nano_timestamp_test.cc	2011-01-20 07:24:29 +0000
+++ unittests/nano_timestamp_test.cc	1970-01-01 00:00:00 +0000
@@ -1,97 +0,0 @@
-/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
- *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
- *
- *  Copyright (C) 2010 Pawel Blokus
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- */
-
-#include "config.h"
-
-#include <gtest/gtest.h>
-#include <drizzled/temporal.h>
-
-#include "temporal_generator.h"
-
-using namespace drizzled;
-
-class NanoTimestampTest : public ::testing::Test
-{
-  protected:
-    NanoTimestamp nano_timestamp;
-    bool result;
-};
-
-TEST_F(NanoTimestampTest, is_valid_minOfNanoTimestampRange_shouldReturn_True)
-{
-  uint32_t year= 1970, month= 1, day= 1, hour= 0, minute= 0, second= 0, nanosecond= 0;
-  TemporalGenerator::TimestampGen::make_nano_timestamp(&nano_timestamp, year, month, day, hour, minute, second, nanosecond);
-
-  result= nano_timestamp.is_valid();
-
-  ASSERT_TRUE(result);
-}
-
-TEST_F(NanoTimestampTest, is_valid_maxOfNanoTimestampRange_shouldReturn_True)
-{
-  uint32_t year= 2038, month= 1, day= 19, hour= 3, minute= 14, second= 7, nanosecond= 0;
-  TemporalGenerator::TimestampGen::make_nano_timestamp(&nano_timestamp, year, month, day, hour, minute, second, nanosecond);
-
-  result= nano_timestamp.is_valid();
-
-  ASSERT_TRUE(result);
-}
-
-TEST_F(NanoTimestampTest, is_valid_oneMicroSecondBeforeNanoTimestampMinOfRange_shouldReturn_False)
-{
-  uint32_t year= 1969, month= 12, day= 31, hour= 23, minute= 59, second= 59, nanosecond= 999999999;
-  TemporalGenerator::TimestampGen::make_nano_timestamp(&nano_timestamp, year, month, day, hour, minute, second, nanosecond);
-
-  result= nano_timestamp.is_valid();
-
-  ASSERT_FALSE(result);
-}
-
-TEST_F(NanoTimestampTest, is_valid_oneMicroSecondAfterNanoTimestampMaxOfRange_shouldReturn_False)
-{
-  uint32_t year= 2038, month= 1, day= 19, hour= 3, minute= 14, second= 8, nanosecond= 1;
-  TemporalGenerator::TimestampGen::make_nano_timestamp(&nano_timestamp, year, month, day, hour, minute, second, nanosecond);
-
-  result= nano_timestamp.is_valid();
-
-  ASSERT_FALSE(result);
-}
-
-TEST_F(NanoTimestampTest, is_valid_InsideOfNanoTimestampRange_shouldReturn_True)
-{
-  uint32_t year= 1980, month= 11, day= 1, hour= 5, minute= 8, second= 5, nanosecond= 3265832;
-  TemporalGenerator::TimestampGen::make_nano_timestamp(&nano_timestamp, year, month, day, hour, minute, second, nanosecond);
-
-  result= nano_timestamp.is_valid();
-
-  ASSERT_TRUE(result);
-}
-
-TEST_F(NanoTimestampTest, to_timespec)
-{
-  struct timespec filled;
-  uint32_t year= 2009, month= 6, day= 3, hour= 4, minute= 59, second= 1, nanosecond= 675;
-  TemporalGenerator::TimestampGen::make_nano_timestamp(&nano_timestamp, year, month, day, hour, minute, second, nanosecond);
-
-  nano_timestamp.to_timespec(&filled);
-
-  EXPECT_EQ(1244005141, filled.tv_sec);
-  EXPECT_EQ(675, filled.tv_nsec);
-}
 
=== added file 'unittests/option_context.cc'
--- unittests/option_context.cc	1970-01-01 00:00:00 +0000
+++ unittests/option_context.cc	2011-01-24 09:18:02 +0000
@@ -0,0 +1,60 @@
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+ *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ *  Copyright (C) 2010 Monty Taylor
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "config.h"
+
+#define BOOST_TEST_DYN_LINK
+#include <boost/test/unit_test.hpp>
+
+#include <boost/program_options.hpp>
+
+#include "drizzled/module/option_context.h"
+
+namespace po=boost::program_options;
+
+using namespace drizzled;
+
+BOOST_AUTO_TEST_SUITE(OptionContext)
+BOOST_AUTO_TEST_CASE(parsing)
+{
+  const std::string module_name("test");
+  po::options_description command_line_options("Test prefix injection");
+  module::option_context ctx(module_name, command_line_options.add_options());
+
+  ctx("option", po::value<std::string>(), "Test option name prefix injection");
+
+  po::variables_map vm;
+
+  const char *options[]= {
+    "test", "--test.option=foo"
+  };
+
+  // Disable allow_guessing
+  int style = po::command_line_style::default_style & ~po::command_line_style::allow_guessing;
+
+  po::store(po::command_line_parser(2, (char **)options).style(style).
+            options(command_line_options).run(), vm);
+  po::notify(vm);
+
+  BOOST_REQUIRE_EQUAL(0, vm.count("option"));
+  BOOST_REQUIRE_EQUAL(1, vm.count("test.option"));
+  BOOST_REQUIRE_EQUAL(0, vm["test.option"].as<std::string>().compare("foo"));
+}
+BOOST_AUTO_TEST_SUITE_END()
 
=== removed file 'unittests/option_context.cc'
--- unittests/option_context.cc	2010-09-26 08:33:47 +0000
+++ unittests/option_context.cc	1970-01-01 00:00:00 +0000
@@ -1,56 +0,0 @@
-/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
- *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
- *
- *  Copyright (C) 2010 Monty Taylor
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- */
-
-#include "config.h"
-
-#include <gtest/gtest.h>
-#include <boost/program_options.hpp>
-
-#include "drizzled/module/option_context.h"
-
-namespace po=boost::program_options;
-
-using namespace drizzled;
-
-TEST(option_context, parsing)
-{
-  const std::string module_name("test");
-  po::options_description command_line_options("Test prefix injection");
-  module::option_context ctx(module_name, command_line_options.add_options());
-
-  ctx("option", po::value<std::string>(), "Test option name prefix injection");
-
-  po::variables_map vm;
-
-  const char *options[]= {
-    "test", "--test.option=foo"
-  };
-
-  // Disable allow_guessing
-  int style = po::command_line_style::default_style & ~po::command_line_style::allow_guessing;
-
-  po::store(po::command_line_parser(2, (char **)options).style(style).
-            options(command_line_options).run(), vm);
-  po::notify(vm);
-
-  EXPECT_EQ(0, vm.count("option"));
-  EXPECT_EQ(1, vm.count("test.option"));
-  EXPECT_EQ(0, vm["test.option"].as<std::string>().compare("foo"));
-}
 
=== added file 'unittests/pthread_atomics_test.cc'
--- unittests/pthread_atomics_test.cc	1970-01-01 00:00:00 +0000
+++ unittests/pthread_atomics_test.cc	2011-01-24 09:18:02 +0000
@@ -0,0 +1,130 @@
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+ *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ *  Copyright (C) 2010 Stewart Smith
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "config.h"
+
+#define BOOST_TEST_DYN_LINK
+#include <boost/test/unit_test.hpp>
+
+# if defined(__SUNPRO_CC)
+#  include <drizzled/atomic/sun_studio.h>
+# endif
+
+# if !defined(__ICC) && (defined(HAVE_GCC_ATOMIC_BUILTINS) || defined(__SUNPRO_CC))
+#  include <drizzled/atomic/gcc_traits.h>
+#  define ATOMIC_TRAITS internal::gcc_traits
+# else  /* use pthread impl */
+#  define ATOMIC_TRAITS internal::pthread_traits
+# endif
+
+#include <pthread.h>
+#include <drizzled/atomic/pthread_traits.h>
+
+#include <drizzled/atomics.h>
+
+using namespace drizzled;
+
+template<typename T>
+struct atomic_pthread {
+};
+
+#   define __DRIZZLE_DECL_ATOMIC_PTHREAD(T)                              \
+  template<> struct atomic_pthread<T>                                   \
+  : internal::atomic_impl<T,T, internal::pthread_traits<T,T> > {         \
+    atomic_pthread<T>()                                                 \
+      : internal::atomic_impl<T,T, internal::pthread_traits<T,T> >() {}  \
+    T operator=( T rhs ) { return store_with_release(rhs); }            \
+  };
+
+__DRIZZLE_DECL_ATOMIC_PTHREAD(unsigned int)
+
+BOOST_AUTO_TEST_SUITE(PthreadAtomicOperations)
+BOOST_AUTO_TEST_CASE(fetch_and_store)
+{
+  atomic_pthread<uint32_t> u235;
+
+  BOOST_REQUIRE_EQUAL(0, u235.fetch_and_store(1));
+
+  u235.fetch_and_store(15);
+
+  BOOST_REQUIRE_EQUAL(15, u235.fetch_and_store(100));
+  BOOST_REQUIRE_EQUAL(100, u235);
+}
+
+BOOST_AUTO_TEST_CASE(fetch_and_increment)
+{
+  atomic_pthread<uint32_t> u235;
+
+  BOOST_REQUIRE_EQUAL(0, u235.fetch_and_increment());
+  BOOST_REQUIRE_EQUAL(1, u235);
+}
+
+BOOST_AUTO_TEST_CASE(fetch_and_add)
+{
+  atomic_pthread<uint32_t> u235;
+
+  BOOST_REQUIRE_EQUAL(0, u235.fetch_and_add(2));
+  BOOST_REQUIRE_EQUAL(2, u235);
+}
+
+BOOST_AUTO_TEST_CASE(add_and_fetch)
+{
+  atomic_pthread<uint32_t> u235;
+
+  BOOST_REQUIRE_EQUAL(10, u235.add_and_fetch(10));
+  BOOST_REQUIRE_EQUAL(10, u235);
+}
+
+BOOST_AUTO_TEST_CASE(fetch_and_decrement)
+{
+  atomic_pthread<uint32_t> u235;
+
+  u235.fetch_and_store(15);
+
+  BOOST_REQUIRE_EQUAL(15, u235.fetch_and_decrement());
+  BOOST_REQUIRE_EQUAL(14, u235);
+}
+
+BOOST_AUTO_TEST_CASE(compare_and_swap)
+{
+  atomic_pthread<uint32_t> u235;
+
+  u235.fetch_and_store(100);
+
+  BOOST_REQUIRE(not u235.compare_and_swap(42, 200));
+  BOOST_REQUIRE(u235.compare_and_swap(200, 100));
+  BOOST_REQUIRE_EQUAL(200, u235);
+}
+
+BOOST_AUTO_TEST_CASE(increment)
+{
+  atomic_pthread<uint32_t> u235;
+  u235.fetch_and_store(200);
+  BOOST_REQUIRE_EQUAL(201, u235.increment());
+}
+
+BOOST_AUTO_TEST_CASE(decrement)
+{
+  atomic_pthread<uint32_t> u235;
+  u235.fetch_and_store(200);
+
+  BOOST_REQUIRE_EQUAL(199, u235.decrement());
+}
+BOOST_AUTO_TEST_SUITE_END()
 
=== removed file 'unittests/pthread_atomics_test.cc'
--- unittests/pthread_atomics_test.cc	2010-10-20 09:36:04 +0000
+++ unittests/pthread_atomics_test.cc	1970-01-01 00:00:00 +0000
@@ -1,134 +0,0 @@
-/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
- *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
- *
- *  Copyright (C) 2010 Stewart Smith
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- */
-
-#include "config.h"
-
-#include <gtest/gtest.h>
-
-# if defined(__SUNPRO_CC)
-#  include <drizzled/atomic/sun_studio.h>
-# endif
-
-# if !defined(__ICC) && (defined(HAVE_GCC_ATOMIC_BUILTINS) || defined(__SUNPRO_CC))
-#  include <drizzled/atomic/gcc_traits.h>
-#  define ATOMIC_TRAITS internal::gcc_traits
-# else  /* use pthread impl */
-#  define ATOMIC_TRAITS internal::pthread_traits
-# endif
-
-#include <pthread.h>
-#include <drizzled/atomic/pthread_traits.h>
-
-#include <drizzled/atomics.h>
-
-using namespace drizzled;
-
-template<typename T>
-struct atomic_pthread {
-};
-
-#   define __DRIZZLE_DECL_ATOMIC_PTHREAD(T)                              \
-  template<> struct atomic_pthread<T>                                   \
-  : internal::atomic_impl<T,T, internal::pthread_traits<T,T> > {         \
-    atomic_pthread<T>()                                                 \
-      : internal::atomic_impl<T,T, internal::pthread_traits<T,T> >() {}  \
-    T operator=( T rhs ) { return store_with_release(rhs); }            \
-  };
-
-__DRIZZLE_DECL_ATOMIC_PTHREAD(unsigned int)
-
-TEST(pthread_atomic_operations, fetch_and_store)
-{
-  atomic_pthread<uint32_t> u235;
-
-  EXPECT_EQ(0, u235.fetch_and_store(1));
-
-  u235.fetch_and_store(15);
-
-  EXPECT_EQ(15, u235.fetch_and_store(100));
-  EXPECT_EQ(100, u235);
-}
-
-TEST(pthread_atomic_operations, fetch_and_increment)
-{
-  atomic_pthread<uint32_t> u235;
-
-  EXPECT_EQ(0, u235.fetch_and_increment());
-  EXPECT_EQ(1, u235);
-}
-
-TEST(pthread_atomic_operations, fetch_and_add)
-{
-  atomic_pthread<uint32_t> u235;
-
-  EXPECT_EQ(0, u235.fetch_and_add(2));
-  EXPECT_EQ(2, u235);
-}
-
-TEST(pthread_atomic_operations, add_and_fetch)
-{
-  atomic_pthread<uint32_t> u235;
-
-  EXPECT_EQ(10, u235.add_and_fetch(10));
-  EXPECT_EQ(10, u235);
-}
-
-TEST(pthread_atomic_operations, fetch_and_decrement)
-{
-  atomic_pthread<uint32_t> u235;
-
-  u235.fetch_and_store(15);
-
-  EXPECT_EQ(15, u235.fetch_and_decrement());
-  EXPECT_EQ(14, u235);
-}
-
-TEST(pthread_atomic_operations, compare_and_swap)
-{
-  atomic_pthread<uint32_t> u235;
-
-  u235.fetch_and_store(100);
-
-  ASSERT_FALSE(u235.compare_and_swap(42, 200));
-  ASSERT_TRUE(u235.compare_and_swap(200, 100));
-  EXPECT_EQ(200, u235);
-}
-
-TEST(pthread_atomic_operations, increment)
-{
-  atomic_pthread<uint32_t> u235;
-  u235.fetch_and_store(200);
-  EXPECT_EQ(201, u235.increment());
-}
-
-TEST(pthread_atomic_operations, decrement)
-{
-  atomic_pthread<uint32_t> u235;
-  u235.fetch_and_store(200);
-
-  EXPECT_EQ(199, u235.decrement());
-}
-
-// these don't build for whatever reason
-//  EXPECT_EQ(242, u235+=42);
-//  EXPECT_EQ(200, u235-=42);
-
-
-
 
=== added file 'unittests/table_identifier.cc'
--- unittests/table_identifier.cc	1970-01-01 00:00:00 +0000
+++ unittests/table_identifier.cc	2011-01-24 09:18:02 +0000
@@ -0,0 +1,91 @@
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+ *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ *  Copyright (C) 2010 Brian Aker
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "config.h"
+
+#define BOOST_TEST_DYN_LINK
+#include <boost/test/unit_test.hpp>
+
+#include <drizzled/identifier.h>
+
+using namespace drizzled;
+
+BOOST_AUTO_TEST_SUITE(TableIdentifierTest)
+BOOST_AUTO_TEST_CASE(CreateStandard)
+{
+  identifier::Table identifier("test", "a");
+  BOOST_REQUIRE_EQUAL("test/a", identifier.getPath());
+  std::string path;
+  identifier.getSQLPath(path);
+  BOOST_REQUIRE_EQUAL("test.a", path);
+}
+
+BOOST_AUTO_TEST_CASE(CreateTemporary)
+{
+  identifier::Table identifier("test", "a", message::Table::TEMPORARY);
+  BOOST_REQUIRE_EQUAL("/#sql", identifier.getPath().substr(0, 5));
+  std::string path;
+  identifier.getSQLPath(path);
+  BOOST_REQUIRE_EQUAL("test.#a", path);
+}
+
+BOOST_AUTO_TEST_CASE(CreateInternal)
+{
+  identifier::Table identifier("test", "a", message::Table::TEMPORARY);
+  BOOST_REQUIRE_EQUAL("/#sql", identifier.getPath().substr(0, 5));
+  std::string path;
+  identifier.getSQLPath(path);
+  BOOST_REQUIRE_EQUAL("test.#a", path);
+}
+
+BOOST_AUTO_TEST_CASE(StaticTmpTable)
+{
+  std::vector<char> pathname;
+
+  identifier::Table::build_tmptable_filename(pathname);
+
+  BOOST_REQUIRE_GT(pathname.size(), 0);
+  BOOST_REQUIRE_GT(strlen(&pathname[0]), 0);
+}
+
+BOOST_AUTO_TEST_CASE(Key)
+{
+  identifier::Table identifier("test", "a");
+
+  const identifier::Table::Key key= identifier.getKey();
+
+  BOOST_REQUIRE_EQUAL(key.size(), 7);
+  BOOST_REQUIRE_EQUAL(key.vector()[0], 't');
+  BOOST_REQUIRE_EQUAL(key.vector()[1], 'e');
+  BOOST_REQUIRE_EQUAL(key.vector()[2], 's');
+  BOOST_REQUIRE_EQUAL(key.vector()[3], 't');
+  BOOST_REQUIRE_EQUAL(key.vector()[4], 0);
+  BOOST_REQUIRE_EQUAL(key.vector()[5], 'a');
+  BOOST_REQUIRE_EQUAL(key.vector()[6], 0);
+}
+
+BOOST_AUTO_TEST_CASE(KeyCompare)
+{
+  identifier::Table identifier("test", "a");
+  identifier::Table identifier2("test", "a");
+
+  BOOST_REQUIRE_EQUAL((identifier.getKey() == identifier.getKey()), true);
+}
+BOOST_AUTO_TEST_SUITE_END()
 
=== removed file 'unittests/table_identifier.cc'
--- unittests/table_identifier.cc	2011-01-17 04:15:23 +0000
+++ unittests/table_identifier.cc	1970-01-01 00:00:00 +0000
@@ -1,88 +0,0 @@
-/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
- *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
- *
- *  Copyright (C) 2010 Brian Aker
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- */
-
-#include "config.h"
-
-#include <gtest/gtest.h>
-
-#include <drizzled/identifier.h>
-
-using namespace drizzled;
-
-TEST(table_identifier_test_standard, Create)
-{
-  identifier::Table identifier("test", "a");
-  EXPECT_EQ("test/a", identifier.getPath());
-  std::string path;
-  identifier.getSQLPath(path);
-  EXPECT_EQ("test.a", path);
-}
-
-TEST(table_identifier_test_temporary, Create)
-{
-  identifier::Table identifier("test", "a", message::Table::TEMPORARY);
-  EXPECT_EQ("/#sql", identifier.getPath().substr(0, 5));
-  std::string path;
-  identifier.getSQLPath(path);
-  EXPECT_EQ("test.#a", path);
-}
-
-TEST(table_identifier_test_internal, Create)
-{
-  identifier::Table identifier("test", "a", message::Table::TEMPORARY);
-  EXPECT_EQ("/#sql", identifier.getPath().substr(0, 5));
-  std::string path;
-  identifier.getSQLPath(path);
-  EXPECT_EQ("test.#a", path);
-}
-
-TEST(table_identifier_test_build_tmptable_filename, Static)
-{
-  std::vector<char> pathname;
-
-  identifier::Table::build_tmptable_filename(pathname);
-
-  EXPECT_GT(pathname.size(), 0);
-  EXPECT_GT(strlen(&pathname[0]), 0);
-}
-
-TEST(table_identifier_test_key, Key)
-{
-  identifier::Table identifier("test", "a");
-
-  const identifier::Table::Key key= identifier.getKey();
-
-  EXPECT_EQ(key.size(), 7);
-  EXPECT_EQ(key.vector()[0], 't');
-  EXPECT_EQ(key.vector()[1], 'e');
-  EXPECT_EQ(key.vector()[2], 's');
-  EXPECT_EQ(key.vector()[3], 't');
-  EXPECT_EQ(key.vector()[4], 0);
-  EXPECT_EQ(key.vector()[5], 'a');
-  EXPECT_EQ(key.vector()[6], 0);
-}
-
-TEST(table_identifier_test_key, KeyCompare)
-{
-  identifier::Table identifier("test", "a");
-  identifier::Table identifier2("test", "a");
-
-  EXPECT_EQ((identifier.getKey() == identifier.getKey()), true);
-}
 
=== added file 'unittests/temporal_format_test.cc'
--- unittests/temporal_format_test.cc	1970-01-01 00:00:00 +0000
+++ unittests/temporal_format_test.cc	2011-01-24 09:18:02 +0000
@@ -0,0 +1,157 @@
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+ *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ *  Copyright (C) 2010 Pawel Blokus
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "config.h"
+
+#include <drizzled/temporal.h>
+#include <drizzled/temporal_format.h>
+
+#define BOOST_TEST_DYN_LINK
+#include <boost/test/unit_test.hpp>
+
+#include <vector>
+
+#include "temporal_generator.h"
+
+using namespace drizzled;
+
+class TemporalFormatTest
+{
+  protected:
+    TemporalFormat *tf;
+    Temporal *temporal;
+    bool result;
+
+  TemporalFormatTest()
+  {
+    tf= NULL;
+    temporal= NULL;
+  }
+
+  ~TemporalFormatTest()
+  {
+    if (tf != NULL)
+      delete tf;
+    if (temporal != NULL)
+      delete temporal;
+  }
+};
+
+BOOST_FIXTURE_TEST_SUITE(TemporalFormatTestSuite, TemporalFormatTest)
+BOOST_AUTO_TEST_CASE(constructor_WithValidRegExp_shouldCompile)
+{
+  tf= new TemporalFormat("^(\\d{4})[-/.]$");
+  
+  result= tf->is_valid();
+
+  BOOST_REQUIRE(result);
+}
+
+BOOST_AUTO_TEST_CASE(constructor_WithInvalidRegExp_shouldNotCompile)
+{
+  tf= new TemporalFormat("^\\d{4)[-/.]$");
+
+  result= tf->is_valid();
+  
+  BOOST_REQUIRE(not result);
+}
+
+BOOST_AUTO_TEST_CASE(matches_OnNotMatchingString_shouldReturn_False)
+{
+  tf= new TemporalFormat("^(\\d{4})[-/.]$");
+  char matched[] ="1234/ABC";
+
+  result= tf->matches(matched, sizeof(matched) - sizeof(char), NULL);
+  
+  BOOST_REQUIRE(not result);
+}
+
+BOOST_AUTO_TEST_CASE(matches_OnMatchingString_FormatWithIndexesSet_shouldPopulateTemporal)
+{
+  char regexp[]= "^(\\d{4})[-/.](\\d{1,2})[-/.](\\d{1,2})[T|\\s+](\\d{2}):(\\d{2}):(\\d{2})$";
+  char matched[]= "1999/9/14T23:29:05";
+  tf= TemporalGenerator::TemporalFormatGen::make_temporal_format(regexp, 1, 2, 3, 4, 5, 6, 0, 0);
+  temporal= new DateTime();
+
+  
+  result= tf->matches(matched, sizeof(matched) - sizeof(char), temporal);
+  BOOST_REQUIRE(result);
+  
+  BOOST_REQUIRE_EQUAL(1999, temporal->years());
+  BOOST_REQUIRE_EQUAL(9, temporal->months());
+  BOOST_REQUIRE_EQUAL(14, temporal->days());
+  BOOST_REQUIRE_EQUAL(23, temporal->hours());
+  BOOST_REQUIRE_EQUAL(29, temporal->minutes());
+  BOOST_REQUIRE_EQUAL(5, temporal->seconds());
+}
+
+BOOST_AUTO_TEST_CASE(matches_FormatWithMicroSecondIndexSet_shouldAddTrailingZeros)
+{
+  tf= TemporalGenerator::TemporalFormatGen::make_temporal_format("^(\\d{1,6})$", 0, 0, 0, 0, 0, 0, 1, 0);
+  char matched[]= "560";
+  temporal= new Time();
+  
+  tf->matches(matched, sizeof(matched) - sizeof(char), temporal);
+  
+  BOOST_REQUIRE_EQUAL(560000, temporal->useconds());
+}
+
+BOOST_AUTO_TEST_CASE(matches_FormatWithNanoSecondIndexSet_shouldAddTrailingZeros)
+{
+  tf= TemporalGenerator::TemporalFormatGen::make_temporal_format("^(\\d{1,9})$", 0, 0, 0, 0, 0, 0, 0, 1);
+  char matched[]= "4321";
+  temporal= new Time();
+  
+  tf->matches(matched, sizeof(matched) - sizeof(char), temporal);
+  
+  BOOST_REQUIRE_EQUAL(432100000, temporal->nseconds());
+}
+BOOST_AUTO_TEST_SUITE_END()
+
+namespace drizzled
+{
+extern std::vector<TemporalFormat *> known_datetime_formats;
+extern std::vector<TemporalFormat *> known_date_formats;
+extern std::vector<TemporalFormat *> known_time_formats;
+extern std::vector<TemporalFormat *> all_temporal_formats;
+}
+
+BOOST_AUTO_TEST_SUITE(TemporalFormatTestSuite)
+BOOST_AUTO_TEST_CASE(init_temporal_formats_vectorsWithKnownFormats_shouldHaveExpectedLengths)
+{
+  init_temporal_formats();
+
+  BOOST_REQUIRE_EQUAL(13, known_datetime_formats.size());	
+  BOOST_REQUIRE_EQUAL(8, known_date_formats.size());
+  BOOST_REQUIRE_EQUAL(11, known_time_formats.size());
+  BOOST_REQUIRE_EQUAL(19, all_temporal_formats.size());
+}
+
+BOOST_AUTO_TEST_CASE(deinit_temporal_formats_vectorsWithKnownFormats_shouldHaveZeroLengths)
+{
+  init_temporal_formats();
+  deinit_temporal_formats();
+  
+  BOOST_REQUIRE_EQUAL(0, known_datetime_formats.size());
+  BOOST_REQUIRE_EQUAL(0, known_date_formats.size());
+  BOOST_REQUIRE_EQUAL(0, known_time_formats.size());
+  BOOST_REQUIRE_EQUAL(0, all_temporal_formats.size());
+}
+BOOST_AUTO_TEST_SUITE_END()
 
=== removed file 'unittests/temporal_format_test.cc'
--- unittests/temporal_format_test.cc	2010-12-22 19:43:00 +0000
+++ unittests/temporal_format_test.cc	1970-01-01 00:00:00 +0000
@@ -1,151 +0,0 @@
-/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
- *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
- *
- *  Copyright (C) 2010 Pawel Blokus
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- */
-
-#include "config.h"
-
-#include <drizzled/temporal.h>
-#include <drizzled/temporal_format.h>
-#include <gtest/gtest.h>
-#include <vector>
-
-#include "temporal_generator.h"
-
-using namespace drizzled;
-
-class TemporalFormatTest : public ::testing::Test
-{
-  protected:
-    TemporalFormat *tf;
-    Temporal *temporal;
-    bool result;
-
-  virtual void SetUp()
-  {
-    tf= NULL;
-    temporal= NULL;
-  }
-
-  virtual void TearDown()
-  {
-    if (tf != NULL)
-      delete tf;
-    if (temporal != NULL)
-      delete temporal;
-  }
-};
-
-
-TEST_F(TemporalFormatTest, constructor_WithValidRegExp_shouldCompile)
-{
-  tf= new TemporalFormat("^(\\d{4})[-/.]$");
-  
-  result= tf->is_valid();
-
-  ASSERT_TRUE(result);
-}
-
-TEST_F(TemporalFormatTest, constructor_WithInvalidRegExp_shouldNotCompile)
-{
-  tf= new TemporalFormat("^\\d{4)[-/.]$");
-
-  result= tf->is_valid();
-  
-  ASSERT_FALSE(result);
-}
-
-TEST_F(TemporalFormatTest, matches_OnNotMatchingString_shouldReturn_False)
-{
-  tf= new TemporalFormat("^(\\d{4})[-/.]$");
-  char matched[] ="1234/ABC";
-
-  result= tf->matches(matched, sizeof(matched) - sizeof(char), NULL);
-  
-  ASSERT_FALSE(result);
-}
-
-TEST_F(TemporalFormatTest, matches_OnMatchingString_FormatWithIndexesSet_shouldPopulateTemporal)
-{
-  char regexp[]= "^(\\d{4})[-/.](\\d{1,2})[-/.](\\d{1,2})[T|\\s+](\\d{2}):(\\d{2}):(\\d{2})$";
-  char matched[]= "1999/9/14T23:29:05";
-  tf= TemporalGenerator::TemporalFormatGen::make_temporal_format(regexp, 1, 2, 3, 4, 5, 6, 0, 0);
-  temporal= new DateTime();
-
-  
-  result= tf->matches(matched, sizeof(matched) - sizeof(char), temporal);
-  ASSERT_TRUE(result);
-  
-  EXPECT_EQ(1999, temporal->years());
-  EXPECT_EQ(9, temporal->months());
-  EXPECT_EQ(14, temporal->days());
-  EXPECT_EQ(23, temporal->hours());
-  EXPECT_EQ(29, temporal->minutes());
-  EXPECT_EQ(5, temporal->seconds());
-}
-
-TEST_F(TemporalFormatTest, matches_FormatWithMicroSecondIndexSet_shouldAddTrailingZeros)
-{
-  tf= TemporalGenerator::TemporalFormatGen::make_temporal_format("^(\\d{1,6})$", 0, 0, 0, 0, 0, 0, 1, 0);
-  char matched[]= "560";
-  temporal= new Time();
-  
-  tf->matches(matched, sizeof(matched) - sizeof(char), temporal);
-  
-  ASSERT_EQ(560000, temporal->useconds());
-}
-
-TEST_F(TemporalFormatTest, matches_FormatWithNanoSecondIndexSet_shouldAddTrailingZeros)
-{
-  tf= TemporalGenerator::TemporalFormatGen::make_temporal_format("^(\\d{1,9})$", 0, 0, 0, 0, 0, 0, 0, 1);
-  char matched[]= "4321";
-  temporal= new Time();
-  
-  tf->matches(matched, sizeof(matched) - sizeof(char), temporal);
-  
-  ASSERT_EQ(432100000, temporal->nseconds());
-}
-
-namespace drizzled
-{