/* Copyright (C) 2014 InfiniDB, Inc.

   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; version 2 of
   the License.

   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 Street, Fifth Floor, Boston,
   MA 02110-1301, USA. */

/**
 * $Id: tdriver.cpp 3495 2013-01-21 14:09:51Z rdempsey $
 */

#include <iostream>
#include <string>
using namespace std;

#include <boost/any.hpp>
#include <boost/date_time/gregorian/gregorian.hpp>
using namespace boost;

#include <cppunit/extensions/HelperMacros.h>

#include "calpontsystemcatalog.h"
using namespace execplan;

#include "dataconvert.h"
using namespace dataconvert;

class DataConvertTest : public CppUnit::TestFixture
{
  CPPUNIT_TEST_SUITE(DataConvertTest);

  CPPUNIT_TEST(dc1);
  CPPUNIT_TEST(dc2);
  CPPUNIT_TEST(dc3);
  CPPUNIT_TEST(dc4);
  CPPUNIT_TEST(dc5);
  CPPUNIT_TEST(dc6);
  CPPUNIT_TEST(dc7);
  CPPUNIT_TEST(dc8);
  CPPUNIT_TEST(dc_datetest);
  CPPUNIT_TEST(dc_datetostrtest);
  CPPUNIT_TEST(dc_datetostr1test);
  CPPUNIT_TEST(dc_datetomysqlinttest);
  CPPUNIT_TEST(dc_datetest_perf);
  CPPUNIT_TEST(dc_datetimetest);
  CPPUNIT_TEST(dc_datetimetostrtest);
  CPPUNIT_TEST(dc_datetimetostr1test);
  CPPUNIT_TEST(dc_datetimetest_perf);
  CPPUNIT_TEST(dc_datetimetomysqlinttest);
  CPPUNIT_TEST(dc_datevalidtest);
  CPPUNIT_TEST(dc9);
  CPPUNIT_TEST(dc10);
  CPPUNIT_TEST_SUITE_END();

 private:
  DataConvert converter;
  boost::any anyval;
  CalpontSystemCatalog::ColType ct;
  string data;

 public:
  void setUp()
  {
  }

  void tearDown()
  {
  }

  /* from calpontsystemcatalog.h
      struct ColType
      {
          int colWidth;
          ConstraintType constraintType;
          ColDataType colDataType;
          DictOID ddn;
          boost::any defaultValue;
          int colPosition;    // temporally put here. may need to have ColInfo struct later
          int scale;  //number after decimal points
          int precision;
      };
          colWidth
          constraintType
          colDataType
          defaultValue
          scale
          precision
  */

  // mid-range positive integers
  void dc1()
  {
    ct.colWidth = 1;
    ct.constraintType = CalpontSystemCatalog::NO_CONSTRAINT;
    ct.colDataType = CalpontSystemCatalog::TINYINT;
    ct.scale = -1;
    ct.precision = 2;
    data = "12";
    bool pushWarning;

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(char));
    char tinyintval = any_cast<char>(anyval);
    CPPUNIT_ASSERT(tinyintval == 12);

    ct.colWidth = 2;
    ct.constraintType = CalpontSystemCatalog::NO_CONSTRAINT;
    ct.colDataType = CalpontSystemCatalog::SMALLINT;
    ct.scale = -1;
    ct.precision = 4;
    data = "1234";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(int16_t));
    int16_t smallintval = any_cast<int16_t>(anyval);
    CPPUNIT_ASSERT(smallintval == 1234);

    ct.colWidth = 4;
    ct.constraintType = CalpontSystemCatalog::NO_CONSTRAINT;
    ct.colDataType = CalpontSystemCatalog::INT;
    ct.scale = -1;
    ct.precision = 9;
    data = "12345678";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(int32_t));
    int32_t intval = any_cast<int32_t>(anyval);
    CPPUNIT_ASSERT(intval == 12345678);

    ct.colWidth = 4;
    ct.constraintType = CalpontSystemCatalog::NO_CONSTRAINT;
    ct.colDataType = CalpontSystemCatalog::MEDINT;
    ct.scale = -1;
    ct.precision = 9;
    data = "12345678";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(int32_t));
    intval = any_cast<int32_t>(anyval);
    CPPUNIT_ASSERT(intval == 12345678);

    ct.colWidth = 8;
    ct.constraintType = CalpontSystemCatalog::NO_CONSTRAINT;
    ct.colDataType = CalpontSystemCatalog::BIGINT;
    ct.scale = -1;
    ct.precision = 18;
    data = "1234567890123456";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(long long));
    int64_t bigintval = static_cast<int64_t>(any_cast<long long>(anyval));
    CPPUNIT_ASSERT(bigintval == 1234567890123456LL);
  }

  // mid-range negative integers
  void dc2()
  {
    ct.colWidth = 1;
    ct.constraintType = CalpontSystemCatalog::NO_CONSTRAINT;
    ct.colDataType = CalpontSystemCatalog::TINYINT;
    ct.scale = -1;
    ct.precision = 2;
    data = "-12";
    bool pushWarning;

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(char));
    char tinyintval = any_cast<char>(anyval);
    CPPUNIT_ASSERT(tinyintval == -12);

    ct.colWidth = 2;
    ct.constraintType = CalpontSystemCatalog::NO_CONSTRAINT;
    ct.colDataType = CalpontSystemCatalog::SMALLINT;
    ct.scale = -1;
    ct.precision = 4;
    data = "-1234";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(int16_t));
    int16_t smallintval = any_cast<int16_t>(anyval);
    CPPUNIT_ASSERT(smallintval == -1234);

    ct.colWidth = 4;
    ct.constraintType = CalpontSystemCatalog::NO_CONSTRAINT;
    ct.colDataType = CalpontSystemCatalog::INT;
    ct.scale = -1;
    ct.precision = 9;
    data = "-12345678";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(int32_t));
    int32_t intval = any_cast<int32_t>(anyval);
    CPPUNIT_ASSERT(intval == -12345678);

    ct.colWidth = 4;
    ct.constraintType = CalpontSystemCatalog::NO_CONSTRAINT;
    ct.colDataType = CalpontSystemCatalog::MEDINT;
    ct.scale = -1;
    ct.precision = 9;
    data = "-12345678";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(int32_t));
    intval = any_cast<int32_t>(anyval);
    CPPUNIT_ASSERT(intval == -12345678);

    ct.colWidth = 8;
    ct.constraintType = CalpontSystemCatalog::NO_CONSTRAINT;
    ct.colDataType = CalpontSystemCatalog::BIGINT;
    ct.scale = -1;
    ct.precision = 18;
    data = "-1234567890123456";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(long long));
    int64_t bigintval = static_cast<int64_t>(any_cast<long long>(anyval));
    CPPUNIT_ASSERT(bigintval == -1234567890123456LL);
  }

  // limit positive integers
  void dc3()
  {
    ct.colWidth = 1;
    ct.constraintType = CalpontSystemCatalog::NO_CONSTRAINT;
    ct.colDataType = CalpontSystemCatalog::TINYINT;
    ct.scale = -1;
    ct.precision = 3;
    data = "127";
    bool pushWarning;

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(char));
    char tinyintval = any_cast<char>(anyval);
    CPPUNIT_ASSERT(tinyintval == 127);

    ct.colWidth = 2;
    ct.constraintType = CalpontSystemCatalog::NO_CONSTRAINT;
    ct.colDataType = CalpontSystemCatalog::SMALLINT;
    ct.scale = -1;
    ct.precision = 5;
    data = "32767";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(int16_t));
    int16_t smallintval = any_cast<int16_t>(anyval);
    CPPUNIT_ASSERT(smallintval == 32767);

    ct.colWidth = 4;
    ct.constraintType = CalpontSystemCatalog::NO_CONSTRAINT;
    ct.colDataType = CalpontSystemCatalog::INT;
    ct.scale = -1;
    ct.precision = 10;
    data = "2147483647";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(int32_t));
    int32_t intval = any_cast<int32_t>(anyval);
    CPPUNIT_ASSERT(intval == 2147483647);

    ct.colWidth = 4;
    ct.constraintType = CalpontSystemCatalog::NO_CONSTRAINT;
    ct.colDataType = CalpontSystemCatalog::MEDINT;
    ct.scale = -1;
    ct.precision = 10;
    data = "2147483647";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(int32_t));
    intval = any_cast<int32_t>(anyval);
    CPPUNIT_ASSERT(intval == 2147483647);

    ct.colWidth = 8;
    ct.constraintType = CalpontSystemCatalog::NO_CONSTRAINT;
    ct.colDataType = CalpontSystemCatalog::BIGINT;
    ct.scale = 0;
    ct.precision = 18;
    data = "9223372036854775807";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(long long));
    int64_t bigintval = static_cast<int64_t>(any_cast<long long>(anyval));
    CPPUNIT_ASSERT(bigintval == 9223372036854775807LL);
  }

  // limit negative integers
  void dc4()
  {
    ct.colWidth = 1;
    ct.constraintType = CalpontSystemCatalog::NO_CONSTRAINT;
    ct.colDataType = CalpontSystemCatalog::TINYINT;
    ct.scale = -1;
    ct.precision = 3;
    data = "-126";
    bool pushWarning;

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(char));
    char tinyintval = any_cast<char>(anyval);
    CPPUNIT_ASSERT(tinyintval == -126);

    ct.colWidth = 2;
    ct.constraintType = CalpontSystemCatalog::NO_CONSTRAINT;
    ct.colDataType = CalpontSystemCatalog::SMALLINT;
    ct.scale = -1;
    ct.precision = 4;
    data = "-32766";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(int16_t));
    int16_t smallintval = any_cast<int16_t>(anyval);
    CPPUNIT_ASSERT(smallintval == -32766);

    ct.colWidth = 4;
    ct.constraintType = CalpontSystemCatalog::NO_CONSTRAINT;
    ct.colDataType = CalpontSystemCatalog::INT;
    ct.scale = -1;
    ct.precision = 9;
    data = "-2147483646";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(int32_t));
    int32_t intval = any_cast<int32_t>(anyval);
    CPPUNIT_ASSERT(intval == -2147483646);

    ct.colWidth = 4;
    ct.constraintType = CalpontSystemCatalog::NO_CONSTRAINT;
    ct.colDataType = CalpontSystemCatalog::MEDINT;
    ct.scale = -1;
    ct.precision = 9;
    data = "-2147483646";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(int32_t));
    intval = any_cast<int32_t>(anyval);
    CPPUNIT_ASSERT(intval == -2147483646);

    ct.colWidth = 8;
    ct.constraintType = CalpontSystemCatalog::NO_CONSTRAINT;
    ct.colDataType = CalpontSystemCatalog::BIGINT;
    ct.scale = -1;
    ct.precision = 18;
    data = "-9223372036854775806";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(long long));
    int64_t bigintval = static_cast<int64_t>(any_cast<long long>(anyval));
    CPPUNIT_ASSERT(bigintval == -9223372036854775806LL);
  }

  // mid-range positive decimals (2 fixed points)
  void dc5()
  {
    ct.colWidth = 2;
    ct.constraintType = CalpontSystemCatalog::NO_CONSTRAINT;
    ct.colDataType = CalpontSystemCatalog::SMALLINT;
    ct.scale = 2;
    ct.precision = 4;
    bool pushWarning;

    data = "12.34";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(int16_t));
    int16_t smallintval = any_cast<int16_t>(anyval);
    CPPUNIT_ASSERT(smallintval == 1234);

    data = "2.345";

    anyval = converter.convertColumnData(ct, data, pushWarning, false, true);

    CPPUNIT_ASSERT(anyval.type() == typeid(int16_t));
    smallintval = any_cast<int16_t>(anyval);
    CPPUNIT_ASSERT(smallintval == 234);

    data = "(2.34)";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(int16_t));
    smallintval = any_cast<int16_t>(anyval);
    CPPUNIT_ASSERT(smallintval == 234);

    data = "2.3";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(int16_t));
    smallintval = any_cast<int16_t>(anyval);
    CPPUNIT_ASSERT(smallintval == 230);

    data = "2.";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(int16_t));
    smallintval = any_cast<int16_t>(anyval);
    CPPUNIT_ASSERT(smallintval == 200);

    data = "2";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(int16_t));
    smallintval = any_cast<int16_t>(anyval);
    CPPUNIT_ASSERT(smallintval == 200);

    ct.colWidth = 4;
    ct.constraintType = CalpontSystemCatalog::NO_CONSTRAINT;
    ct.colDataType = CalpontSystemCatalog::INT;
    ct.scale = 6;
    ct.precision = 9;
    data = "0.000481";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(int32_t));
    int32_t intval = any_cast<int32_t>(anyval);
    CPPUNIT_ASSERT(intval == 481);

    ct.colWidth = 4;
    ct.constraintType = CalpontSystemCatalog::NO_CONSTRAINT;
    ct.colDataType = CalpontSystemCatalog::INT;
    ct.scale = 2;
    ct.precision = 9;
    data = "1234567.89";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(int32_t));
    intval = any_cast<int32_t>(anyval);
    CPPUNIT_ASSERT(intval == 123456789);

    data = "34567.8999";

    anyval = converter.convertColumnData(ct, data, pushWarning, false, true);

    CPPUNIT_ASSERT(anyval.type() == typeid(int32_t));
    intval = any_cast<int32_t>(anyval);
    CPPUNIT_ASSERT(intval == 3456789);

    data = "(34567.89)";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(int32_t));
    intval = any_cast<int32_t>(anyval);
    CPPUNIT_ASSERT(intval == 3456789);

    data = "34567.8";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(int32_t));
    intval = any_cast<int32_t>(anyval);
    CPPUNIT_ASSERT(intval == 3456780);

    data = "34567.";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(int32_t));
    intval = any_cast<int32_t>(anyval);
    CPPUNIT_ASSERT(intval == 3456700);

    data = "34567";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(int32_t));
    intval = any_cast<int32_t>(anyval);
    CPPUNIT_ASSERT(intval == 3456700);

    ct.colWidth = 8;
    ct.constraintType = CalpontSystemCatalog::NO_CONSTRAINT;
    ct.colDataType = CalpontSystemCatalog::BIGINT;
    ct.scale = 2;
    ct.precision = 18;

    data = "12345678901234.56";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(long long));
    int64_t bigintval = static_cast<int64_t>(any_cast<long long>(anyval));
    CPPUNIT_ASSERT(bigintval == 1234567890123456LL);

    data = "45678901234.56093";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(long long));
    bigintval = static_cast<int64_t>(any_cast<long long>(anyval));
    CPPUNIT_ASSERT(bigintval == 4567890123456LL);

    data = "(45678901234.56)";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(long long));
    bigintval = static_cast<int64_t>(any_cast<long long>(anyval));
    CPPUNIT_ASSERT(bigintval == 4567890123456LL);

    data = "12345678901234.5";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(long long));
    bigintval = static_cast<int64_t>(any_cast<long long>(anyval));
    CPPUNIT_ASSERT(bigintval == 1234567890123450LL);

    data = "12345678901234.";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(long long));
    bigintval = static_cast<int64_t>(any_cast<long long>(anyval));
    CPPUNIT_ASSERT(bigintval == 1234567890123400LL);

    data = "12345678901234";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(long long));
    bigintval = static_cast<int64_t>(any_cast<long long>(anyval));
    CPPUNIT_ASSERT(bigintval == 1234567890123400LL);
  }

  // mid-range positive decimals (fixed-point)
  void dc6()
  {
    ct.colWidth = 8;
    ct.constraintType = CalpontSystemCatalog::NO_CONSTRAINT;
    ct.colDataType = CalpontSystemCatalog::BIGINT;
    ct.scale = 1;
    ct.precision = 18;
    bool pushWarning;

    data = "123456789012345.6";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(long long));
    int64_t bigintval = static_cast<int64_t>(any_cast<long long>(anyval));
    CPPUNIT_ASSERT(bigintval == 1234567890123456LL);

    ct.scale = 3;

    data = "1234567890123.456";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(long long));
    bigintval = static_cast<int64_t>(any_cast<long long>(anyval));
    CPPUNIT_ASSERT(bigintval == 1234567890123456LL);

    ct.scale = 4;

    data = "123456789012.3456";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(long long));
    bigintval = static_cast<int64_t>(any_cast<long long>(anyval));
    CPPUNIT_ASSERT(bigintval == 1234567890123456LL);
  }

  // mid-range negative decimals (2 fixed points)
  void dc7()
  {
    ct.colWidth = 2;
    ct.constraintType = CalpontSystemCatalog::NO_CONSTRAINT;
    ct.colDataType = CalpontSystemCatalog::SMALLINT;
    ct.scale = 2;
    ct.precision = 4;
    bool pushWarning;

    data = "-12.34";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(int16_t));
    int16_t smallintval = any_cast<int16_t>(anyval);
    CPPUNIT_ASSERT(smallintval == -1234);

    data = "-2.345";

    anyval = converter.convertColumnData(ct, data, pushWarning, false, true);

    CPPUNIT_ASSERT(anyval.type() == typeid(int16_t));
    smallintval = any_cast<int16_t>(anyval);
    CPPUNIT_ASSERT(smallintval == -234);

    data = "(-2.34)";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(int16_t));
    smallintval = any_cast<int16_t>(anyval);
    CPPUNIT_ASSERT(smallintval == -234);

    data = "-2.3";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(int16_t));
    smallintval = any_cast<int16_t>(anyval);
    CPPUNIT_ASSERT(smallintval == -230);

    data = "-2.";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(int16_t));
    smallintval = any_cast<int16_t>(anyval);
    CPPUNIT_ASSERT(smallintval == -200);

    ct.colWidth = 4;
    ct.constraintType = CalpontSystemCatalog::NO_CONSTRAINT;
    ct.colDataType = CalpontSystemCatalog::INT;
    ct.scale = 2;
    ct.precision = 9;
    data = "-1234567.89";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(int32_t));
    int32_t intval = any_cast<int32_t>(anyval);
    CPPUNIT_ASSERT(intval == -123456789);

    data = "-34567.8999";

    anyval = converter.convertColumnData(ct, data, pushWarning, false, true);

    CPPUNIT_ASSERT(anyval.type() == typeid(int32_t));
    intval = any_cast<int32_t>(anyval);
    CPPUNIT_ASSERT(intval == -3456789);

    data = "(-34567.89)";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(int32_t));
    intval = any_cast<int32_t>(anyval);
    CPPUNIT_ASSERT(intval == -3456789);

    data = "-34567.8";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(int32_t));
    intval = any_cast<int32_t>(anyval);
    CPPUNIT_ASSERT(intval == -3456780);

    data = "-34567.";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(int32_t));
    intval = any_cast<int32_t>(anyval);
    CPPUNIT_ASSERT(intval == -3456700);

    ct.colWidth = 8;
    ct.constraintType = CalpontSystemCatalog::NO_CONSTRAINT;
    ct.colDataType = CalpontSystemCatalog::BIGINT;
    ct.scale = 2;
    ct.precision = 18;

    data = "-12345678901234.56";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(long long));
    int64_t bigintval = static_cast<int64_t>(any_cast<long long>(anyval));
    CPPUNIT_ASSERT(bigintval == -1234567890123456LL);

    data = "-45678901234.56093";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(long long));
    bigintval = static_cast<int64_t>(any_cast<long long>(anyval));
    CPPUNIT_ASSERT(bigintval == -4567890123456LL);

    data = "(-45678901234.56)";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(long long));
    bigintval = static_cast<int64_t>(any_cast<long long>(anyval));
    CPPUNIT_ASSERT(bigintval == -4567890123456LL);

    data = "-12345678901234.5";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(long long));
    bigintval = static_cast<int64_t>(any_cast<long long>(anyval));
    CPPUNIT_ASSERT(bigintval == -1234567890123450LL);

    data = "-12345678901234.";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(long long));
    bigintval = static_cast<int64_t>(any_cast<long long>(anyval));
    CPPUNIT_ASSERT(bigintval == -1234567890123400LL);
  }

  void dc8()
  {
    data = "2007-05-11";
    int status = 0;
    uint32_t anyval;
    anyval = converter.convertColumnDate(data.c_str(), CALPONTDATE_ENUM, status, data.length());
    CPPUNIT_ASSERT(anyval == 131551998);
    std::string backToString = converter.dateToString(anyval);
    CPPUNIT_ASSERT(backToString == data);
  }

  void show_date_debugs(const Date& d1)
  {
    cout << "d1.spare = " << d1.spare << endl;
    cout << "d1.day   = " << d1.day << endl;
    cout << "d1.month = " << d1.month << endl;
    cout << "d1.year  = " << d1.year << endl;
  }

#include <stdlib.h>
#include <sys/time.h>

  /* Subtract the `struct timeval' values X and Y,
     storing the result in RESULT.
     Return 1 if the difference is negative, otherwise 0.  */

  int timeval_subtract(struct timeval* result, struct timeval* x, struct timeval* y)
  {
    /* Perform the carry for the later subtraction by updating y. */
    if (x->tv_usec < y->tv_usec)
    {
      int nsec = (y->tv_usec - x->tv_usec) / 1000000 + 1;
      y->tv_usec -= 1000000 * nsec;
      y->tv_sec += nsec;
    }

    if (x->tv_usec - y->tv_usec > 1000000)
    {
      int nsec = (x->tv_usec - y->tv_usec) / 1000000;
      y->tv_usec += 1000000 * nsec;
      y->tv_sec -= nsec;
    }

    /* Compute the time remaining to wait.
       tv_usec is certainly positive. */
    result->tv_sec = x->tv_sec - y->tv_sec;
    result->tv_usec = x->tv_usec - y->tv_usec;

    /* Return 1 if result is negative. */
    return x->tv_sec < y->tv_sec;
  }

  void dc_datetest_perf()
  {
    data = "2007-05-11";

    struct timeval tv1, tv2, delta;
    const int iters = 10000000;

    // test the performance of the default date conversion with full format support
    gettimeofday(&tv1, 0);

    for (int i = 0; i < iters; i++)
    {
      converter.stringToDate(data);
    }

    gettimeofday(&tv2, 0);

    timeval_subtract(&delta, &tv2, &tv1);
    cout << iters << " operations performed in " << delta.tv_sec << "." << delta.tv_usec << " seconds"
         << " using the default stringToDate method" << endl;
    unsigned long total_usec = delta.tv_sec * 1000000 + delta.tv_usec;
    CPPUNIT_ASSERT(total_usec < 3000000);

    // now run the performance of the "fast path" date conversions to check relative performance
    int status = 0;
    gettimeofday(&tv1, 0);

    for (int i = 0; i < iters; i++)
    {
      converter.convertColumnDate(data.c_str(), CALPONTDATE_ENUM, status, data.length());
    }

    gettimeofday(&tv2, 0);

    timeval_subtract(&delta, &tv2, &tv1);
    cout << iters << " operations performed in " << delta.tv_sec << "." << delta.tv_usec << " seconds"
         << " using the \"fastpath\" convertColumnDate method" << endl;
  }

  void dc_datetimetest_perf()
  {
    data = "2007-05-11 10:30:45";

    struct timeval tv1, tv2, delta;
    const int iters = 10000000;

    // test the performance of the default datetime conversion with full format support
    gettimeofday(&tv1, 0);

    for (int i = 0; i < iters; i++)
    {
      converter.stringToDatetime(data);
    }

    gettimeofday(&tv2, 0);

    timeval_subtract(&delta, &tv2, &tv1);
    cout << iters << " operations performed in " << delta.tv_sec << "." << delta.tv_usec << " seconds"
         << " using the default stringToDatetime method" << endl;
    unsigned long total_usec = delta.tv_sec * 1000000 + delta.tv_usec;
    CPPUNIT_ASSERT(total_usec < 3000000);

    // now run the performance of the "fast path" datetime conversions to check relative performance
    int status = 0;
    gettimeofday(&tv1, 0);

    for (int i = 0; i < iters; i++)
    {
      converter.convertColumnDatetime(data.c_str(), CALPONTDATETIME_ENUM, status, data.length());
    }

    gettimeofday(&tv2, 0);

    timeval_subtract(&delta, &tv2, &tv1);
    cout << iters << " operations performed in " << delta.tv_sec << "." << delta.tv_usec << " seconds"
         << " using the \"fastpath\" convertColumnDatetime method" << endl;
  }

  void dc_datetest()
  {
    struct DateCheck
    {
      const char* str;
      Date date;
    };

    DateCheck date_tests[] = {
        {"0000-00-00", Date()},  // bogus date
        {"2000-01-01", Date(2000, 1, 1)},
        {"2000-00-01", Date()},       // 0 not a valid monht
        {"2000-Jan-01", Date()},      // no conversion from month names
        {"2000-January-01", Date()},  // no conversion from month names
        {"2000-Jac-01", Date()},      // no conversion from month names
        {"2000-jan-01", Date()},      // no conversion from month names
        {"20000101", Date(2000, 1, 1)},
        {"2000", Date()},    // no month or day
        {"200001", Date()},  // no day
        {"000101", Date(2000, 1, 1)},
        {"01-01-2000", Date()},  // can not swap field order
        //{ "100-10-1", Date(100,10,1) },     // boost min date is 1400-1-1
        {"10-100-1", Date()},  // invalid month=100
        //{ "5-02-28", Date(5,2,28) },        // boost min date is 1400-1-1
        {"2000-02-28", Date(2000, 2, 28)},
        {"2000-02-29", Date(2000, 2, 29)},
        {"2004-02-29", Date(2004, 2, 29)},
        {"2003-12-31", Date(2003, 12, 31)},
        {"2003-12-32", Date()},  // no Dec. 32nd
        {"03-11-30", Date(2003, 11, 30)},
        {"07-07-31", Date(2007, 7, 31)},
        {"2005-06-23 ", Date(2005, 6, 23)},
        {"2005-06-23 tomorrow", Date()},  // no trailing text
        {"2005-06-23tomorrow ", Date()},  // no trailing text
        {"2006-011-29 ", Date(2006, 11, 29)},
        {"2006-11-029 ", Date(2006, 11, 29)},
        {"10000-01-02 ", Date()},
        {"1999-0102 ", Date()},
    };

    for (unsigned i = 0; i < sizeof(date_tests) / sizeof(DateCheck); i++)
    {
      uint32_t val = converter.stringToDate(date_tests[i].str);
      bool check = (((uint32_t)(val & 0xFFFFFFC0)) ==
                    ((*(reinterpret_cast<uint32_t*>(&date_tests[i].date))) & 0xFFFFFFC0));

      if (!check)
      {
        printf("For input \"%s\", check 0x%08x vs 0x%08x\n", date_tests[i].str, (val & 0xFFFFFFC0),
               (*(reinterpret_cast<uint32_t*>(&date_tests[i].date))) & 0xFFFFFFC0);
      }

      CPPUNIT_ASSERT(check);
    }
  }

  void dc_datetostrtest()
  {
    struct DateCheck
    {
      const char* str;
      Date date;
    };

    DateCheck date_tests[] = {{"2000-01-01", Date(2000, 1, 1)},   {"0100-10-01", Date(100, 10, 1)},
                              {"0005-02-28", Date(5, 2, 28)},     {"2000-02-28", Date(2000, 2, 28)},
                              {"2000-02-29", Date(2000, 2, 29)},  {"2004-02-29", Date(2004, 2, 29)},
                              {"2003-12-31", Date(2003, 12, 31)}, {"2003-11-30", Date(2003, 11, 30)},
                              {"2007-07-31", Date(2007, 7, 31)},  {"2005-06-23", Date(2005, 6, 23)},
                              {"2006-11-29", Date(2006, 11, 29)}};

    for (unsigned i = 0; i < sizeof(date_tests) / sizeof(DateCheck); i++)
    {
      string val = converter.dateToString(*(reinterpret_cast<uint32_t*>(&date_tests[i].date)));

      bool check = (val == date_tests[i].str);

      if (!check)
      {
        cout << "\"" << date_tests[i].str << "\" != \"" << val << endl;
      }

      CPPUNIT_ASSERT(check);
    }
  }

  void dc_datetostr1test()
  {
    struct DateCheck
    {
      const char* str;
      Date date;
    };

    DateCheck date_tests[] = {
        {"20000101", Date(2000, 1, 1)},   {"01001001", Date(100, 10, 1)},   {"00050228", Date(5, 2, 28)},
        {"20000228", Date(2000, 2, 28)},  {"20000229", Date(2000, 2, 29)},  {"20040229", Date(2004, 2, 29)},
        {"20031231", Date(2003, 12, 31)}, {"20031130", Date(2003, 11, 30)}, {"20070731", Date(2007, 7, 31)},
        {"20050623", Date(2005, 6, 23)},  {"20061129", Date(2006, 11, 29)}};

    for (unsigned i = 0; i < sizeof(date_tests) / sizeof(DateCheck); i++)
    {
      string val = converter.dateToString1(*(reinterpret_cast<uint32_t*>(&date_tests[i].date)));

      bool check = (val == date_tests[i].str);

      if (!check)
      {
        cout << "\"" << date_tests[i].str << "\" != \"" << val << endl;
      }

      CPPUNIT_ASSERT(check);
    }
  }

  void dc_datetomysqlinttest()
  {
    struct DateCheck
    {
      int32_t intval;
      Date date;
    };

    DateCheck date_tests[] = {
        {20000101, Date(2000, 1, 1)},   {1001001, Date(100, 10, 1)},    {50228, Date(5, 2, 28)},
        {20000228, Date(2000, 2, 28)},  {20000229, Date(2000, 2, 29)},  {20040229, Date(2004, 2, 29)},
        {20031231, Date(2003, 12, 31)}, {20031130, Date(2003, 11, 30)}, {20070731, Date(2007, 7, 31)},
        {20050623, Date(2005, 6, 23)},  {20061129, Date(2006, 11, 29)}};

    for (unsigned i = 0; i < sizeof(date_tests) / sizeof(DateCheck); i++)
    {
      int64_t val = date_tests[i].date.convertToMySQLint();

      bool check = (val == date_tests[i].intval);

      if (!check)
      {
        cout << val << " != " << date_tests[i].intval << endl;
      }

      CPPUNIT_ASSERT(check);
    }
  }

  void show_datetime_debugs(const DateTime& d1)
  {
    cout << "d1.day     = " << setw(10) << d1.day << endl;
    cout << "d1.month   = " << setw(10) << d1.month << endl;
    cout << "d1.year    = " << setw(10) << d1.year << endl;
    cout << "d1.hour    = " << setw(10) << d1.hour << endl;
    cout << "d1.minute  = " << setw(10) << d1.minute << endl;
    cout << "d1.second  = " << setw(10) << d1.second << endl;
    cout << "d1.msecond = " << setw(10) << d1.msecond << endl;
  }

  void dc_datetimetest()
  {
    struct DateTimeCheck
    {
      const char* str;
      DateTime dtime;
    };

    DateTimeCheck dtime_tests[] = {
        {"2010-03-31 10:30:45.000PM", DateTime()},   // AM/PM not supported
        {"2010-03-31 10:30:45.000 PM", DateTime()},  // AM/PM not supported
        {"2010-03-31 10:30:45PM", DateTime()},       // AM/PM not allowed without microsecs
        {"2010-03-31 10:30:45AM", DateTime()},       // AM/PM not allowed without microsecs
        {"2010-03-31 10:30:45 PM", DateTime()},      // AM/PM not allowed without microsecs
        {"2008-01-01 10:00", DateTime(2008, 1, 1, 10, 0, 0, 0)},
        {"2008-01-01 10:30:02", DateTime(2008, 1, 1, 10, 30, 2, 0)},
        {"2008-01-01 10:45:01.1111", DateTime(2008, 1, 1, 10, 45, 1, 111100)},
        {"2008-01-01 10:45:02.222222", DateTime(2008, 1, 1, 10, 45, 2, 222222)},
        {"2008-01-01 10:45:02.2222223", DateTime()},  // microsecs field too long
        {"2008-01-01 10", DateTime(2008, 1, 1, 10, 0, 0, 0)},
        {"200903311030", DateTime()},  // Interprets as YYMMDDHHMMSS so hour(31) is invalid
        {"20090331103017", DateTime(2009, 03, 31, 10, 30, 17, 0)},
        // { "2009-04-28 11.34.55", DateTime(2009,4,28,11,34,55,0) }, // no more support for arbitrary
        // separators
        {"20100228T134501", DateTime(2010, 02, 28, 13, 45, 1, 0)},
        {"10:45:00 2010-01-31", DateTime()},                            // can't switch time/date order
        {"0000-00-00 00:00:00", DateTime()},                            // invalid date/time
        {"2009-12-31 23:59:56", DateTime(2009, 12, 31, 23, 59, 56, 0)}  // invalid date/time
    };

    for (unsigned i = 0; i < sizeof(dtime_tests) / sizeof(DateTimeCheck); i++)
    {
      u_int64_t val = converter.stringToDatetime(dtime_tests[i].str);

      // this is a little screwy, but the way things are working is that stringToDateTime
      // returns a -1 when the stringToDatetime operation fails.  The default value for
      // datetime, though is -2, so if we get back the error value then we need to mask
      // off the LSB
      if (val == 0xFFFFFFFFFFFFFFFF)
        val = (val & 0xFFFFFFFFFFFFFFFE);

      bool check = (val == *(reinterpret_cast<uint64_t*>(&dtime_tests[i].dtime)));

      if (!check)
      {
        printf("For input \"%s\", check 0x%016lx vs 0x%016lx\n", dtime_tests[i].str, val,
               *(reinterpret_cast<uint64_t*>(&dtime_tests[i].dtime)));
      }

      if (!check)
        show_datetime_debugs(DateTime(val));

      CPPUNIT_ASSERT(check);
    }
  }

  void dc_datetimetostrtest()
  {
    struct DateTimeCheck
    {
      const char* str;
      DateTime dtime;
    };

    DateTimeCheck dtime_tests[] = {
        {"2008-01-01 10:00:00", DateTime(2008, 1, 1, 10, 0, 0, 0)},
        {"2008-01-01 10:30:02", DateTime(2008, 1, 1, 10, 30, 2, 0)},
        {"2008-01-01 10:45:01", DateTime(2008, 1, 1, 10, 45, 1, 111100)},
        {"2008-01-01 10:45:02", DateTime(2008, 1, 1, 10, 45, 2, 222222)},
        {"2008-01-01 10:00:00", DateTime(2008, 1, 1, 10, 0, 0, 0)},
        {"2009-03-31 10:30:17", DateTime(2009, 03, 31, 10, 30, 17, 0)},
        {"2009-04-28 11:34:55", DateTime(2009, 4, 28, 11, 34, 55, 0)},
        {"2010-02-28 13:45:01", DateTime(2010, 02, 28, 13, 45, 1, 0)},
        {"2009-12-31 23:59:56", DateTime(2009, 12, 31, 23, 59, 56, 0)}  // invalid date/time
    };

    for (unsigned i = 0; i < sizeof(dtime_tests) / sizeof(DateTimeCheck); i++)
    {
      string val = converter.datetimeToString(*(reinterpret_cast<uint64_t*>(&dtime_tests[i].dtime)));

      bool check = (val == dtime_tests[i].str);

      if (!check)
      {
        cout << "\"" << dtime_tests[i].str << "\" != \"" << val << endl;
      }

      CPPUNIT_ASSERT(check);
    }
  }

  void dc_datetimetostr1test()
  {
    struct DateTimeCheck
    {
      const char* str;
      DateTime dtime;
    };

    DateTimeCheck dtime_tests[] = {{"20080101100000000000", DateTime(2008, 1, 1, 10, 0, 0, 0)},
                                   {"20080101103002000000", DateTime(2008, 1, 1, 10, 30, 2, 0)},
                                   {"20080101104501111100", DateTime(2008, 1, 1, 10, 45, 1, 111100)},
                                   {"20080101104502222222", DateTime(2008, 1, 1, 10, 45, 2, 222222)},
                                   {"20080101100000000000", DateTime(2008, 1, 1, 10, 0, 0, 0)},
                                   {"20090331103017000000", DateTime(2009, 03, 31, 10, 30, 17, 0)},
                                   {"20090428113455000000", DateTime(2009, 4, 28, 11, 34, 55, 0)},
                                   {"20100228134501000000", DateTime(2010, 02, 28, 13, 45, 1, 0)},
                                   {"20091231235956000000", DateTime(2009, 12, 31, 23, 59, 56, 0)}};

    for (unsigned i = 0; i < sizeof(dtime_tests) / sizeof(DateTimeCheck); i++)
    {
      string val = converter.datetimeToString1(*(reinterpret_cast<uint64_t*>(&dtime_tests[i].dtime)));

      bool check = (val == dtime_tests[i].str);

      if (!check)
      {
        cout << "\"" << dtime_tests[i].str << "\" != \"" << val << endl;
      }

      CPPUNIT_ASSERT(check);
    }
  }

  void dc_datetimetomysqlinttest()
  {
    struct DateTimeCheck
    {
      int64_t intval;
      DateTime dtime;
    };

    DateTimeCheck dtime_tests[] = {{20080101100000, DateTime(2008, 1, 1, 10, 0, 0, 0)},
                                   {20080101103002, DateTime(2008, 1, 1, 10, 30, 2, 0)},
                                   {20080101104501, DateTime(2008, 1, 1, 10, 45, 1, 111100)},
                                   {20080101104502, DateTime(2008, 1, 1, 10, 45, 2, 222222)},
                                   {20080101100000, DateTime(2008, 1, 1, 10, 0, 0, 0)},
                                   {20090331103017, DateTime(2009, 03, 31, 10, 30, 17, 0)},
                                   {20090428113455, DateTime(2009, 4, 28, 11, 34, 55, 0)},
                                   {20100228134501, DateTime(2010, 02, 28, 13, 45, 1, 0)},
                                   {20091231235956, DateTime(2009, 12, 31, 23, 59, 56, 0)}};

    for (unsigned i = 0; i < sizeof(dtime_tests) / sizeof(DateTimeCheck); i++)
    {
      int64_t val = dtime_tests[i].dtime.convertToMySQLint();

      bool check = (val == dtime_tests[i].intval);

      if (!check)
      {
        cout << val << " != " << dtime_tests[i].intval << endl;
      }

      CPPUNIT_ASSERT(check);
    }
  }

  void check_date(int year, int month, int day, bool valid, bool boost_only = false)
  {
    bool idbval = isDateValid(day, month, year);

    bool boostval;

    try
    {
      boost::gregorian::date d(year, month, day);
      boostval = true;
    }
    catch (...)
    {
      boostval = false;
    }

    bool check = boost_only ? (idbval == boostval) : (idbval == valid && ((boostval == idbval) || boostval));

    if (!check)
    {
      cout << "(" << year << "," << month << "," << day << "), expected:" << valid << ", idb=" << idbval
           << ", boost=" << boostval << endl;
    }

    CPPUNIT_ASSERT(check);
  }

  void dc_datevalidtest()
  {
    struct Check
    {
      int year;
      int month;
      int day;
      bool valid;
    };

    Check tests[] = {
        {2000, 2, 29, true},   {2001, 2, 29, false}, {1900, 2, 29, false}, {1900, 2, 28, true},
        {1399, 12, 31, false}, {10000, 1, 1, false}, {2000, 0, 29, false}, {2000, 13, 29, false},
        {2000, 1, 0, false},   {2000, 1, 32, false},
    };

    // predefined tests shown above
    for (unsigned i = 0; i < sizeof(tests) / sizeof(Check); i++)
    {
      check_date(tests[i].year, tests[i].month, tests[i].day, tests[i].valid);
    }

    // randomly generated date tests
    for (unsigned i = 0; i < 1000000; i++)
    {
      int year = random() % 9000 + 1200;  // some spillage on either side

      if (year == 10000)
        --year;  // year 10000 is not good because boost calls it good but we don't want to

      int month = random() % 14;  // some spillage on either side
      int day = random() % 33;    // some spillage on either side
      check_date(year, month, day, true, true);
    }
  }

  // Testing equality of floating point numbers is not good practice, rather make sure
  //  the conversion is within a tolerance (usually +/- 1 LSD).
  inline bool inTolerance(double d, double a, double t)
  {
    return ((d > (a - t)) && (d < (a + t)));
  }

  // Float tests 6 digits of accuracy
  void dc9()
  {
    ct.colWidth = 4;
    ct.constraintType = CalpontSystemCatalog::NO_CONSTRAINT;
    ct.colDataType = CalpontSystemCatalog::FLOAT;
    ct.scale = 0;
    ct.precision = 4;
    bool pushWarning;

    data = "0.123456";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(float));
    float floatval = any_cast<float>(anyval);
    CPPUNIT_ASSERT(inTolerance(floatval, 0.123456, 0.000001));

    data = "3456.01";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(float));
    floatval = any_cast<float>(anyval);
    CPPUNIT_ASSERT(inTolerance(floatval, 3456.01, 0.01));

    data = "(3456.01)";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(float));
    floatval = any_cast<float>(anyval);
    CPPUNIT_ASSERT(inTolerance(floatval, 3456.01, 0.01));

    data = "6.02214E+23";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(float));
    floatval = any_cast<float>(anyval);
    CPPUNIT_ASSERT(inTolerance(floatval, 6.02214E+23, 0.00001E+23));

    data = "1.60217E-19";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(float));
    floatval = any_cast<float>(anyval);
    CPPUNIT_ASSERT(inTolerance(floatval, 1.60217E-19, 0.00001E-19));
  }

  // Double tests 15 digits of accuracy
  void dc10()
  {
    ct.colWidth = 8;
    ct.constraintType = CalpontSystemCatalog::NO_CONSTRAINT;
    ct.colDataType = CalpontSystemCatalog::DOUBLE;
    ct.scale = 0;
    ct.precision = 4;
    bool pushWarning;

    data = "0.123456789012345";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(double));
    double doubleval = any_cast<double>(anyval);
    CPPUNIT_ASSERT(inTolerance(doubleval, 0.123456789012345, 0.000000000000001));

    data = "123456.000000001";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(double));
    doubleval = any_cast<double>(anyval);
    CPPUNIT_ASSERT(inTolerance(doubleval, 123456.000000001, 0.000000001));

    data = "(123456.000000001)";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(double));
    doubleval = any_cast<double>(anyval);
    CPPUNIT_ASSERT(inTolerance(doubleval, 123456.000000001, 0.000000001));

    data = "6.02214179000000E+23";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(double));
    doubleval = any_cast<double>(anyval);
    CPPUNIT_ASSERT(inTolerance(doubleval, 6.02214179000000E+23, 0.00000000000001E+23));

    data = "1.60217653140000E-19";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(double));
    doubleval = any_cast<double>(anyval);
    CPPUNIT_ASSERT(inTolerance(doubleval, 1.60217653140000E-19, 0.00000000000001E-19));

    data = "3.14159265358979";

    anyval = converter.convertColumnData(ct, data, pushWarning, false);

    CPPUNIT_ASSERT(anyval.type() == typeid(double));
    doubleval = any_cast<double>(anyval);
    CPPUNIT_ASSERT(inTolerance(doubleval, 3.14159265358979, 0.00000000000001));
  }
};

CPPUNIT_TEST_SUITE_REGISTRATION(DataConvertTest);

#include <cppunit/extensions/TestFactoryRegistry.h>
#include <cppunit/ui/text/TestRunner.h>

int main(int argc, char** argv)
{
  CppUnit::TextUi::TestRunner runner;
  CppUnit::TestFactoryRegistry& registry = CppUnit::TestFactoryRegistry::getRegistry();
  runner.addTest(registry.makeTest());
  bool wasSuccessful = runner.run("", false);
  return (wasSuccessful ? 0 : 1);
}