/***************************************************************************
 * Copyright (C) 2018 by gempa GmbH                                        *
 *                                                                         *
 * All Rights Reserved.                                                    *
 *                                                                         *
 * NOTICE: All information contained herein is, and remains                *
 * the property of gempa GmbH and its suppliers, if any. The intellectual  *
 * and technical concepts contained herein are proprietary to gempa GmbH   *
 * and its suppliers.                                                      *
 * Dissemination of this information or reproduction of this material      *
 * is strictly forbidden unless prior written permission is obtained       *
 * from gempa GmbH.                                                        *
 *                                                                         *
 * Author: Tracey Werner, Enrico Ellguth                                   *
 * Email: tracey.werner@gempa.de, enrico.ellguth@gempa.de                  *
 ***************************************************************************/


#define SEISCOMP_TEST_MODULE gempa
#include <seiscomp3/unittest/unittests.h>
#include <gempa/caps/datetime.h>

#include <string>


namespace gc = Gempa::CAPS;
namespace bu = boost::unit_test;



bool isClose(gc::TimeSpan time, long sec, long micro, int offset = 1) {
	long microSeconds = time.microseconds();

	long secDiff = time.seconds() - sec;
	if ( secDiff > 0 )
		microSeconds += secDiff * 1000000;
	else if ( secDiff < 0 )
		micro += abs(secDiff) * 1000000;

	if ( abs(microSeconds - micro) <= offset )
		return true;
	return false;
}

//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_SUITE(gempa_common_caps_datetime)


BOOST_AUTO_TEST_CASE(construction) {

	bu::unit_test_log.set_threshold_level(bu::log_warnings);
	bu::unit_test_log.set_threshold_level(bu::log_messages);

	struct timeval tvPositive;
	tvPositive.tv_sec = 60000;
	tvPositive.tv_usec = 123456;
	gc::TimeSpan k(tvPositive);
	BOOST_CHECK(k.seconds() == tvPositive.tv_sec);
	BOOST_CHECK(k.microseconds() == tvPositive.tv_usec);

	struct timeval tvNegativeUsec;
	tvNegativeUsec.tv_sec = 300;
	tvNegativeUsec.tv_usec = -13456;
	gc::TimeSpan ki(tvNegativeUsec);
	BOOST_CHECK_EQUAL(ki.seconds() , tvNegativeUsec.tv_sec);
	BOOST_CHECK_EQUAL(ki.microseconds() , tvNegativeUsec.tv_usec);

	struct timeval tvNegativeSec;
	tvNegativeSec.tv_sec = -300;
	tvNegativeSec.tv_usec = 13456;

	gc::TimeSpan kj(tvNegativeSec);
	BOOST_CHECK_EQUAL(kj.seconds() , tvNegativeSec.tv_sec);
	BOOST_CHECK_EQUAL(kj.microseconds() , tvNegativeSec.tv_usec);

	struct timeval tvNegative;
	tvNegative.tv_sec = -3000;
	tvNegative.tv_usec = -123456;
	gc::TimeSpan kk(tvNegative);
	BOOST_CHECK_EQUAL(kk.seconds() , tvNegative.tv_sec);
	BOOST_CHECK_EQUAL(kk.microseconds() , tvNegative.tv_usec);

	struct timeval tvNull;
	gc::TimeSpan kl(tvNull);
	BOOST_CHECK_EQUAL(kl.seconds() , tvNull.tv_sec);
	BOOST_CHECK_EQUAL(kl.microseconds() , tvNull.tv_usec);

	// copy
	gc::TimeSpan copyPositive(gc::TimeSpan(79743.123456));
	BOOST_CHECK(copyPositive.seconds() == 79743);
	BOOST_CHECK(copyPositive.microseconds() == 123456);

	gc::TimeSpan copyNegative(gc::TimeSpan(-98765.123456));
	long sec = -98765;
	long micro = -123456;
	BOOST_CHECK(isClose(copyNegative, sec, micro,20) == true);

	gc::TimeSpan copyNegativeTest(gc::TimeSpan(-98765.000070));
	sec = -98765 ;
	micro = 70;
	BOOST_CHECK_EQUAL(isClose(copyNegativeTest,sec, micro,500), true);

	// long
	gc::TimeSpan longPositive(765432, 456789);
	BOOST_CHECK(longPositive.seconds() == 765432);
	BOOST_CHECK(longPositive.microseconds() == 456789);

	gc::TimeSpan longNegativeUsec(200, -732);
	BOOST_CHECK_EQUAL(longNegativeUsec.seconds(), 200);
	BOOST_CHECK_EQUAL(longNegativeUsec.microseconds(), -732);

	gc::TimeSpan longNegativeSec(-800, 73265);
	BOOST_CHECK_EQUAL(longNegativeSec.seconds(), -800);
	BOOST_CHECK_EQUAL(longNegativeSec.microseconds(), 73265);

	gc::TimeSpan longNegative(-500, -732650);
	BOOST_CHECK_EQUAL(longNegative.seconds(), -500);
	BOOST_CHECK_EQUAL(longNegative.microseconds(), -732650);

	// double
	double number = 123456.98765;
	gc::TimeSpan doublePositive(number);
	BOOST_CHECK_EQUAL(doublePositive.seconds(), 123456);
	BOOST_CHECK_EQUAL(doublePositive.microseconds(), 987650);

	number = -98765.123470;
	gc::TimeSpan doubleNegative(number);
	BOOST_CHECK_EQUAL(doubleNegative.seconds(), -98765);
	BOOST_CHECK_CLOSE((double)doubleNegative.microseconds(), -123470, 0.01);

	number = -98765.000080;
	gc::TimeSpan doubleNegativeTest(number);
	sec = -98765;
	micro = 80;
	BOOST_CHECK_EQUAL(isClose(doubleNegativeTest,sec, micro,500), true);

	// pointer
	timeval n;
	n.tv_sec = 123;
	n.tv_usec = 123456;

	gc::TimeSpan pointerPositive(&n);
	BOOST_CHECK_EQUAL(pointerPositive.seconds(), 123);
	BOOST_CHECK_EQUAL(pointerPositive.microseconds(), 123456);

	n.tv_sec = -123;
	n.tv_usec = 123456;

	gc::TimeSpan pointerNegativeSec(&n);
	BOOST_CHECK_EQUAL(pointerNegativeSec.seconds(), -123);
	BOOST_CHECK_EQUAL(pointerNegativeSec.microseconds(), 123456);

	n.tv_sec = 123;
	n.tv_usec = -123456;

	gc::TimeSpan pointerNegativeUsec(&n);
	BOOST_CHECK_EQUAL(pointerNegativeUsec.seconds(), 123);
	BOOST_CHECK_EQUAL(pointerNegativeUsec.microseconds(), -123456);

	n.tv_sec = -123;
	n.tv_usec = -123456;

	gc::TimeSpan pointerNegative(&n);
	BOOST_CHECK_EQUAL(pointerNegative.seconds(), -123);
	BOOST_CHECK_EQUAL(pointerNegative.microseconds(), -123456);

	timeval *nullPointer = NULL;
	gc::TimeSpan pointerNull(nullPointer);
	BOOST_CHECK_EQUAL(pointerNull.seconds(), 0);
	BOOST_CHECK_EQUAL(pointerNull.microseconds(), 0);
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>




//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_CASE(addition) {
	gc::TimeSpan k = 5, l = 7;
	BOOST_CHECK(k + l  == gc::TimeSpan(12));

	gc::TimeSpan m = 320.5, n = 60.2;
	BOOST_CHECK(m + n  == gc::TimeSpan(380.7));

	gc::TimeSpan g = 55, d = -50;
	BOOST_CHECK(d + g  == gc::TimeSpan(5));

	gc::TimeSpan t = -80.0053, s = -70.0044;
	gc::TimeSpan result = t + s;
	long sec = t.seconds() + s.seconds();
	long micro = t.microseconds() + s.microseconds();
	BOOST_CHECK_EQUAL(isClose(result, sec,micro),true);

	gc::TimeSpan u = -5.035, v = -60.044;
	result = u + v;
	sec = u.seconds() + v.seconds();
	micro = u.microseconds() + v.microseconds();
	BOOST_CHECK_EQUAL(isClose(result,sec, micro), true);

	gc::TimeSpan w = -5.0885, x = -6.01111;
	result = w + x;
	sec = w.seconds() + x.seconds();
	micro = w.microseconds() + x.microseconds();
	BOOST_CHECK_EQUAL(isClose(result,sec, micro), true);
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>




//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_CASE(subtraction) {
	gc::TimeSpan k = 5, l = 6;
	BOOST_CHECK(k - l == gc::TimeSpan(-1));

	gc::TimeSpan t = 58, i = 68.05;
	gc::TimeSpan result = t - i;
	long sec = t.seconds() - i.seconds();
	long micro = t.microseconds() - i.microseconds();
	BOOST_CHECK_EQUAL(isClose(result,sec, micro), true);

	gc::TimeSpan e(30,4);
	gc::TimeSpan o(45,3);
	result = e - o;
	sec = e.seconds() - o.seconds();
	micro = e.microseconds() - o.microseconds();
	BOOST_CHECK_EQUAL(isClose(result,sec, micro), true);

	gc::TimeSpan f = 30.00004, g = -45.00003;
	result = f - g;
	sec = f.seconds() - g.seconds();
	micro = f.microseconds() - g.microseconds();
	BOOST_CHECK_EQUAL(isClose(result,sec, micro), true);
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>




//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_CASE(setSec) {
	gc::TimeSpan h, k, l;
	BOOST_CHECK_EQUAL(h.set(4), gc::TimeSpan(4));
	BOOST_CHECK_EQUAL(k.set(2), gc::TimeSpan(2));
	BOOST_CHECK_EQUAL(l.set(1), gc::TimeSpan(1));
	BOOST_CHECK_EQUAL(l.set(-10), gc::TimeSpan(-10));
	BOOST_CHECK_EQUAL(k.set(-9876), gc::TimeSpan(-9876));
	BOOST_CHECK_EQUAL(l.set(0), gc::TimeSpan(0.));
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>




//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_CASE(setMicro) {
	gc::TimeSpan h, k, l, ts;
	BOOST_CHECK_EQUAL(h.setUSecs(9), gc::TimeSpan(0.000009));
	BOOST_CHECK_EQUAL(k.setUSecs(2), gc::TimeSpan(0.0000020));
	BOOST_CHECK_EQUAL(l.setUSecs(3), gc::TimeSpan(0.000003));
	BOOST_CHECK_EQUAL(ts.setUSecs(4), gc::TimeSpan(0.000004));
	BOOST_CHECK_EQUAL(l.setUSecs(0), gc::TimeSpan(0.0));
	BOOST_CHECK_EQUAL(h.setUSecs(2000000), gc::TimeSpan(2.00));
	BOOST_CHECK_EQUAL(k.setUSecs(-3000000), gc::TimeSpan(-3.0));

	bu::unit_test_log.set_threshold_level(bu::log_warnings);

	gc::TimeSpan test = l.setUSecs(-7262);
	BOOST_WARN_EQUAL(test.microseconds(), -7262);

	gc::TimeSpan test2 = l.setUSecs(-98744);
	BOOST_WARN_EQUAL(test2.microseconds(), -98744);

	gc::TimeSpan test3 = l.setUSecs(-98);
	BOOST_WARN_EQUAL(isClose(test3,0, -98), true);
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>




//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_CASE(secAndMicro) {
	gc::TimeSpan ts(2.000002);
	BOOST_CHECK(ts.seconds() == 2 && ts.microseconds() == 2);

	gc::TimeSpan h(4.000009);
	BOOST_CHECK(h.seconds() == 4 && h.microseconds()  == 9);

	gc::TimeSpan t(0.000004);
	BOOST_CHECK(t.seconds() == 0 && t.microseconds()  == 4);

	gc::TimeSpan k(0.000000);
	BOOST_CHECK(k.seconds() == 0 && k.microseconds()  == 0);

	gc::TimeSpan m(-8.123456);
	long sec =  -8;
	long micro = -123456;
	BOOST_WARN_EQUAL(isClose(m,sec, micro,20), true);
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>




//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_CASE(absolute) {
	gc::TimeSpan k(-2.567);
	gc::TimeSpan result = k.abs();
	long sec = result.seconds();
	long micro = result.microseconds();
	BOOST_CHECK_EQUAL(isClose(result,2, 567000,20), true);

	gc::TimeSpan m(-2, -5);
	gc::TimeSpan n(2, 5);
	BOOST_CHECK_EQUAL(m.abs(), n.abs());
	BOOST_CHECK_EQUAL(m.abs(), n);

	gc::TimeSpan i(600, -700000);
	result = i.abs();
	BOOST_CHECK_EQUAL(result.seconds(), 600);
	BOOST_CHECK_EQUAL(result.microseconds(),700000);

	gc::TimeSpan r(200, -5);
	gc::TimeSpan s(200.000005);
	gc::TimeSpan absR = r.abs();
	BOOST_CHECK_EQUAL(r.abs(), s.abs());
	BOOST_CHECK_EQUAL(absR.seconds(), s.seconds());
	BOOST_CHECK_EQUAL(absR.microseconds(), s.microseconds());

	gc::TimeSpan l = (double)-1.000678;
	result = l.abs();
	sec = 1;
	micro = 678;
	BOOST_CHECK_EQUAL(isClose(result,sec, micro), true);

	gc::TimeSpan h = -4;
	BOOST_CHECK_EQUAL(h.abs(), gc::TimeSpan(4));

	gc::TimeSpan ts;
	BOOST_CHECK_EQUAL(ts.abs(), gc::TimeSpan(0.0));
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>




//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_CASE(length) {
	gc::TimeSpan k = 2.000002;
	BOOST_CHECK(k.length() == 2.000002);

	gc::TimeSpan l = 1.000003;
	BOOST_CHECK(l.length() == 1.000003);

	gc::TimeSpan h = 4.000009;
	BOOST_CHECK(h.length() == 4.000009);
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>




//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_CASE(notEqual) {
	gc::TimeSpan k = 2.000002, l = 1.000003;
	BOOST_CHECK(k != l);

	gc::TimeSpan ts, t = 0.000007;
	BOOST_CHECK(ts != t);

	gc::TimeSpan h = 4.000009, j = 2845687.000004;
	BOOST_CHECK(h != j);
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>




//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_CASE(assign) {
	gc::TimeSpan k = 2.000002;
	BOOST_CHECK(k == gc::TimeSpan(2.000002));

	gc::TimeSpan t;
	BOOST_CHECK(t  == gc::TimeSpan(0.0));

	gc::TimeSpan h = 4.000009;
	BOOST_CHECK(h  == gc::TimeSpan(4.000009));

	gc::TimeSpan ts = 0.000004;
	BOOST_CHECK(ts == gc::TimeSpan(0.000004));
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>




//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_CASE(plus) {
	gc::TimeSpan k = 2.000002, l = 1.000003;
	BOOST_CHECK_EQUAL(k += l, gc::TimeSpan(3.000005));

	gc::TimeSpan h = 4.000009, t;
	BOOST_CHECK_EQUAL(t += h, gc::TimeSpan(4.000009));

	gc::TimeSpan ts = 0.000004, j = 80005.000004;
	BOOST_CHECK_EQUAL(ts += j, gc::TimeSpan(80005.000008));
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>




//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_CASE(minus) {
	gc::TimeSpan k = 2.000002, l = 1.000003;
	BOOST_CHECK_EQUAL(k -= l, gc::TimeSpan(0.999999));

	gc::TimeSpan t, j = 6897.098772;
	BOOST_CHECK_EQUAL(j -= t, gc::TimeSpan(6897.098772));

	gc::TimeSpan h = 4.000009, ts = 0.000004;
	BOOST_CHECK_EQUAL(h -= ts, gc::TimeSpan(4.000005));
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>




//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_CASE(lower) {
	gc::TimeSpan k = 2.000002, t;
	BOOST_CHECK_EQUAL(t < k, true);

	gc::TimeSpan h = 4.000009, j = 2.897665;
	BOOST_CHECK_EQUAL(j < h, true);

	gc::TimeSpan ts = 0.000004, z = 7893648.987645;
	BOOST_CHECK_EQUAL(z < ts, false);
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>




//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_CASE(greater) {
	gc::TimeSpan k = 2.000002, t;
	BOOST_CHECK_EQUAL(k > t, true);

	gc::TimeSpan h = 4.000009, j = 3.909888;
	BOOST_CHECK_EQUAL(h > j, true);

	gc::TimeSpan ts = 0.000004, g = 0.000001;
	BOOST_CHECK_EQUAL(g > ts, false);
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>




//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_CASE(lowerEqual) {
	gc::TimeSpan k = 2.000002;
	BOOST_CHECK_EQUAL(k <= gc::TimeSpan(2.000002), true);

	gc::TimeSpan t;
	BOOST_CHECK_EQUAL(t <= gc::TimeSpan(2), true);

	gc::TimeSpan h = 4.000009;
	BOOST_CHECK_EQUAL(h <= gc::TimeSpan(2), false);
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>




//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_CASE(greaterEqual) {
	gc::TimeSpan h = 4.000009;
	BOOST_CHECK_EQUAL(h >= gc::TimeSpan(2), true);

	gc::TimeSpan ts = 0.000004;
	BOOST_CHECK_EQUAL(ts >= gc::TimeSpan(0.000001), true);

	gc::TimeSpan k = 2.000002;
	BOOST_CHECK_EQUAL(k >= gc::TimeSpan(2.000002), true);
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>




//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_CASE(inDouble) {
	gc::TimeSpan k = 6.000003;
	double kd = k.operator double();
	BOOST_CHECK_EQUAL(kd, 6.000003);

	gc::TimeSpan t = 0.000008;
	double td = t.operator double();
	BOOST_CHECK_EQUAL(td, 0.000008);

	gc::TimeSpan ts = 2.000004;
	double tsd = ts.operator double();
	BOOST_CHECK_EQUAL(tsd, 2.000004);
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>




//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_CASE(toTimeval) {
	const timeval tv = gc::Time(6.000003);
	gc::TimeSpan k = 6.000003;
	timeval kv = k.operator const timeval &();
	BOOST_CHECK_EQUAL(kv.tv_sec, tv.tv_sec);
	BOOST_CHECK_EQUAL(kv.tv_usec, tv.tv_usec);

	const timeval ti = gc::Time(0.000008);
	gc::TimeSpan t = 0.000008;
	timeval tvi = t.operator const timeval &();
	BOOST_CHECK_EQUAL(tvi.tv_sec, ti.tv_sec);
	BOOST_CHECK_EQUAL(tvi.tv_usec, ti.tv_usec);

	const timeval tl = gc::Time(2.000004);
	gc::TimeSpan ts = 2.000004;
	timeval tsv = ts.operator const timeval &();
	BOOST_CHECK_EQUAL(tsv.tv_sec, tl.tv_sec);
	BOOST_CHECK_EQUAL(tsv.tv_usec, tl.tv_usec);
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>




//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_CASE(fromString) {
	gc::Time time = gc::Time::FromString("2019-01-01 10:01:59", "%F %T");

	BOOST_CHECK(time.valid());

	int year, month, day, hour, min, sec;
	BOOST_CHECK(time.get(&year, &month, &day, &hour, &min, &sec));
	BOOST_CHECK_EQUAL(year, 2019);
	BOOST_CHECK_EQUAL(month, 1);
	BOOST_CHECK_EQUAL(day, 1);
	BOOST_CHECK_EQUAL(hour, 10);
	BOOST_CHECK_EQUAL(min, 01);
	BOOST_CHECK_EQUAL(sec, 59);

	// Buffer overflow test
	std::string str;
	str.resize(1024);
	time = gc::Time::FromString(str.c_str(), "%F %T");
	BOOST_CHECK(!time.valid());
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>




//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_SUITE_END()