gempa_public/libcapsclient
7
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Initial commit based on common repo commit ffeb9c9b

Browse Source
This commit is contained in:
Enrico Ellguth
2021-04-22 15:57:00 +02:00
commit 8b2a408e6f
107 changed files with 61542 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
libs/gempa/caps/test/CMakeLists.txt Normal file
View File

@ -0,0 +1,23 @@
SET(TESTS
datetime.cpp
rawpacket.cpp
packet.cpp
utils.cpp
datetime_time.cpp
endianess.cpp
mseedpacket.cpp
)
FOREACH(testSrc ${TESTS})
GET_FILENAME_COMPONENT(testName ${testSrc} NAME_WE)
SET(testName test_caps_${testName})
ADD_EXECUTABLE(${testName} ${testSrc})
SC_LINK_LIBRARIES_INTERNAL(${testName} unittest)
SC_LINK_LIBRARIES(${testName} ${CURL_LIBRARIES} caps_client)
ADD_TEST(
NAME ${testName}
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
COMMAND ${testName}
)
ENDFOREACH(testSrc)

BIN
libs/gempa/caps/test/data/AM.RFE4F.00.SHZ.20180912.mseed Normal file
View File

Binary file not shown.

566
libs/gempa/caps/test/datetime.cpp Normal file
View File

@ -0,0 +1,566 @@
/***************************************************************************
* 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()

511
libs/gempa/caps/test/datetime_time.cpp Normal file
View File

@ -0,0 +1,511 @@
/***************************************************************************
* 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>
namespace gc = Gempa::CAPS;
namespace bu = boost::unit_test;
BOOST_AUTO_TEST_SUITE(gempa_common_caps_datetime_time)
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_CASE(construction) {
bu::unit_test_log.set_threshold_level(bu::log_warnings);
bu::unit_test_log.set_threshold_level(bu::log_messages);
gc::Time time;
BOOST_CHECK(time == gc::Time(0.0));
// long
gc::Time tPositive(200, 600);
BOOST_CHECK(tPositive == gc::Time(200.000600));
gc::Time tNegativeUsec(3000, -789);
BOOST_WARN_EQUAL(tNegativeUsec.seconds(), 3000);
BOOST_WARN_EQUAL(tNegativeUsec.microseconds(), -789);
gc::Time tNegativeSec(-12, 12345);
BOOST_WARN_EQUAL(tNegativeSec.seconds(), -12);
BOOST_WARN_EQUAL(tNegativeSec.microseconds(), 12345);
gc::Time tNegative(-15,-9876);
BOOST_WARN_EQUAL(tNegative.seconds(), -15);
BOOST_WARN_EQUAL(tNegative.microseconds(), -9876);
// TimeSpan
gc::Time tsPositive(gc::TimeSpan(5.345));
BOOST_WARN_EQUAL(tsPositive.seconds(), 5);
BOOST_WARN_EQUAL(tsPositive.microseconds(), 345000);
// timeval
timeval number;
number.tv_sec = 150;
number.tv_usec = 6000;
gc::Time tvPositive(number);
BOOST_WARN_EQUAL(tvPositive.seconds(), 150);
BOOST_WARN_EQUAL(tvPositive.microseconds(), 6000);
number.tv_sec = -150;
number.tv_usec = 9000;
gc::Time tvNegativeSec(number);
BOOST_WARN_EQUAL(tvNegativeSec.seconds(), -150);
BOOST_WARN_EQUAL(tvNegativeSec.microseconds(),9000);
number.tv_sec = 4000;
number.tv_usec = -98876;
gc::Time tvNegativeUsec(number);
BOOST_WARN_EQUAL(tvNegativeUsec.seconds(), 4000);
BOOST_WARN_EQUAL(tvNegativeUsec.microseconds(), -98876);
number.tv_sec = -9877;
number.tv_usec = -874547;
gc::Time tvNegative(number);
BOOST_WARN_EQUAL(tvNegative.seconds(), -9877);
BOOST_WARN_EQUAL(tvNegative.microseconds(), -874547);
// double
double val = 5678.9864;
gc::Time tdPositive(val);
BOOST_WARN_EQUAL(tdPositive.seconds(), 5678);
BOOST_CHECK_EQUAL(tdPositive.microseconds(), 986400);
val = -89765.745377;
gc::Time tdNegative(val);
BOOST_WARN_EQUAL(isClose(tdNegative, -89765, -745377), true);
// pointer
timeval pointer;
pointer.tv_sec = 76656;
pointer.tv_usec = 8900;
gc::Time tpPositive(&pointer);
BOOST_WARN_EQUAL(tpPositive.seconds(), 76656);
BOOST_WARN_EQUAL(tpPositive.microseconds(), 8900);
pointer.tv_sec = -76656;
pointer.tv_usec = 8900;
gc::Time tpNegativeSec(&pointer);
BOOST_WARN_EQUAL(tpNegativeSec.seconds(), -76656);
BOOST_WARN_EQUAL(tpNegativeSec.microseconds(), 8900);
pointer.tv_sec = 98744;
pointer.tv_usec = -8965;
gc::Time tpNegativeUsec(&pointer);
BOOST_WARN_EQUAL(tpNegativeUsec.seconds(), 98744);
BOOST_WARN_EQUAL(tpNegativeUsec.microseconds(), -8965);
pointer.tv_sec = -44;
pointer.tv_usec = -895;
gc::Time tpNegative(&pointer);
BOOST_WARN_EQUAL(tpNegative.seconds(), -44);
BOOST_WARN_EQUAL(tpNegative.microseconds(), -895);
// copy
gc::Time copyPositive(gc::Time(758.9975));
BOOST_CHECK_EQUAL(copyPositive.seconds(), 758);
BOOST_CHECK_EQUAL(copyPositive.microseconds(), 997500);
gc::Time copyNegative(gc::Time(-877.963));
BOOST_WARN_EQUAL(isClose(copyNegative, -877, -963000), true);
// date
gc::Time date(1971,1,3,1,1,4,6544);
double dayInSeconds = 86400;
double yearInSeconds = 31536000;
BOOST_WARN_CLOSE(double(date), dayInSeconds*2 + yearInSeconds,0.3);
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_CASE(addition) {
gc::Time a(7,5);
gc::TimeSpan b = 9.000004;
gc::TimeSpan result = a + b;
BOOST_CHECK_EQUAL(result.microseconds(), 9);
BOOST_CHECK_EQUAL(result.seconds(), 16);
gc::Time c(7,5);
gc::TimeSpan d = -3.000004;
result = c + d;
BOOST_CHECK_EQUAL(result.microseconds(), 2);
BOOST_CHECK_EQUAL(result.seconds(), 4);
gc::Time e(-7,5);
gc::TimeSpan f = 9.000004;
result = e + f;
BOOST_CHECK_EQUAL(result.microseconds(),9);
BOOST_CHECK_EQUAL(result.seconds(), 2);
gc::Time g(900,789);
gc::TimeSpan h;
result = h += g;
BOOST_CHECK_EQUAL(result.microseconds(),789);
BOOST_CHECK_EQUAL(result.seconds(), 900);
gc::Time i(455, -355);
gc::TimeSpan j = 80.000444;
i += j;
BOOST_CHECK_EQUAL(i.microseconds(),89);
BOOST_CHECK_EQUAL(i.seconds(), 535);
gc::Time k(-899, 22255);
gc::TimeSpan l = 773.992;
l += k;
BOOST_WARN_EQUAL(l.seconds(), -125);
BOOST_WARN_EQUAL(l.microseconds(), 14255);
gc::Time m(500, 987);
gc::TimeSpan n(-30, 876);
int result2 = m.microseconds() + n.microseconds();
int result3 = m.seconds() + n.seconds();
m += n;
BOOST_WARN_EQUAL(m.microseconds(),result2);
BOOST_WARN_EQUAL(m.seconds(),result3);
gc::Time o(-60, 47);
gc::TimeSpan p(-44,5);
long sec = o.seconds() + p.seconds();
long micro = o.microseconds() + p.microseconds();
o += p;
BOOST_CHECK_EQUAL(isClose(o, sec, micro), true);
gc::Time q(9876, -6748);
gc::TimeSpan r = -876.987;
q += r;
BOOST_WARN_EQUAL(q.microseconds(), 6253);
BOOST_CHECK_EQUAL(q.seconds(),8999);
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_CASE(subtraction) {
gc::Time a(7,5);
gc::TimeSpan b(9,000004);
gc::TimeSpan result = a - b;
long sec = a.seconds() - b.seconds();
long micro = a.microseconds() - b.microseconds();
BOOST_WARN_EQUAL(isClose(result, sec, micro),true);
gc::Time c(7,5);
gc::TimeSpan d = -3.000004;
result = c - d;
BOOST_CHECK_EQUAL(result.microseconds(), 8);
BOOST_CHECK_EQUAL(result.seconds(), 10);
gc::Time e(-7,5);
gc::TimeSpan f(9,000004);
result = e - f;
sec = e.seconds() - f.seconds();
micro = e.microseconds() -f.microseconds();
BOOST_WARN_EQUAL(isClose(result, sec, micro),true);
gc::Time g(900,789);
gc::TimeSpan h;
sec = h.seconds() - g.seconds();
micro = h.microseconds() - g.microseconds();
h -= g;
BOOST_CHECK_EQUAL(isClose(h, sec, micro), true);
gc::Time i(455, -355);
gc::TimeSpan j(80, 444);
sec = i.seconds() - j.seconds();
micro = i.microseconds() - j.microseconds();
i -= j;
BOOST_CHECK_EQUAL(isClose(i, sec, micro), true);
gc::Time k(-899, 22255);
gc::TimeSpan l(773, 992);
sec = l.seconds() - k.seconds();
micro = l.microseconds() - k.microseconds();
l -= k;
BOOST_CHECK_EQUAL(isClose(l, sec, micro), true);
gc::Time m(500,987);
gc::TimeSpan n = -30.876;
m -= n;
BOOST_CHECK_EQUAL(m.microseconds(),876986);
BOOST_CHECK_EQUAL(m.seconds(), 530);
gc::Time o(-60, 47);
gc::TimeSpan p = -44.05;
sec = o.seconds() - p.seconds();
micro = o.microseconds() - p.microseconds();
o -= p;
BOOST_CHECK_EQUAL(isClose(o, sec, micro), true);
gc::Time q(9876, -6748);
gc::TimeSpan r = -876.987;
sec = q.seconds() -r.seconds();
micro = q.microseconds() - r.microseconds();
q -= r;
BOOST_CHECK_EQUAL(isClose(q, sec, micro), true);
gc::Time s(50, 778), t(4, 221);
result = s - t;
BOOST_CHECK_EQUAL(result.microseconds(), 557);
BOOST_CHECK_EQUAL(result.seconds(), 46);
gc::Time u(-30,0),v(60,66);
result = u - v;
sec = u.seconds() -v.seconds();
micro = u.microseconds() - v.microseconds();
BOOST_CHECK_EQUAL(isClose(result, sec, micro), true);
gc::Time w(798, -444),x(6, 0321);
sec = w.seconds() - x.seconds();
micro = w.microseconds() - x.microseconds();
result = w - x;
BOOST_CHECK_EQUAL(isClose(result, sec, micro), true);
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_CASE(setAndGet) {
gc::Time date;
gc::TimeSpan oneDay (86400); // one day in seconds
gc::TimeSpan oneYear (31536000); // one year in seconds
gc::TimeSpan toNextYear (26524800); // seconds to the next year
int year = 1970, month = 8, day = 5,h = 7,min = 50,sec = 33,uSec= 80;
date.set(year,month,day,h,min,sec,uSec);
BOOST_CHECK(date.get(&year,&month,&day,&h,&min,&sec,&uSec) == true);
BOOST_CHECK(year == 1970);
BOOST_CHECK(month == 8);
BOOST_CHECK(day == 5);
BOOST_CHECK(h == 7);
BOOST_CHECK(min = 50);
BOOST_CHECK(sec = 33);
BOOST_CHECK(uSec = 80);
date -= oneYear;
BOOST_CHECK(date.get(&year,&month,&day,&h,&min,&sec,&uSec) == true);
BOOST_CHECK(year == 1969);
BOOST_CHECK(month == 8);
BOOST_CHECK_EQUAL(day , 5);
year = 2017, month = 2, day = 28;
date.set(year,month,day,h,min,sec,uSec);
BOOST_CHECK(date.get(&year,&month,&day,&h,&min,&sec,&uSec) == true);
BOOST_CHECK(year == 2017);
BOOST_CHECK(month == 2);
BOOST_CHECK(day == 28);
date += oneDay;
BOOST_CHECK(date.get(&year,&month,&day,&h,&min,&sec,&uSec) == true);
BOOST_CHECK_EQUAL(month , 3);
BOOST_CHECK_EQUAL(day , 1);
year = 2018, month = 2, day = 28;
date.set(year,month,day,h,min,sec,uSec);
date += oneDay;
BOOST_CHECK(date.get(&year,&month,&day,&h,&min,&sec,&uSec) == true);
BOOST_CHECK_EQUAL(month , 3);
BOOST_CHECK_EQUAL(day, 1);
date += oneYear;
BOOST_CHECK(date.get(&year,&month,&day,&h,&min,&sec,&uSec) == true);
BOOST_CHECK_EQUAL(year , 2019);
BOOST_CHECK_EQUAL(day, 1);
BOOST_CHECK_EQUAL(month , 3);
gc::Time leapYear;
year = 1956, month = 2, day = 28;
leapYear.set(year,month,day,h,min,sec,uSec);
BOOST_CHECK(leapYear.get(&year,&month,&day,&h,&min,&sec,&uSec) == true);
BOOST_CHECK(year == 1956);
BOOST_CHECK(month == 2);
BOOST_CHECK(day == 28);
leapYear += oneDay;
BOOST_CHECK(leapYear.get(&year,&month,&day,&h,&min,&sec,&uSec) == true);
BOOST_CHECK(month == 2);
BOOST_CHECK(day == 29);
leapYear += oneDay;
BOOST_CHECK(leapYear.get(&year,&month,&day,&h,&min,&sec,&uSec) == true);
BOOST_CHECK(month == 3);
BOOST_CHECK(day == 1);
gc::Time time;
year = 2011, month = 2, day = 28;
int yday ;
time.set(year,month,day,h,min,sec,uSec);
BOOST_CHECK(time.get2(&year,&yday,&h,&min,&sec,&uSec) == true);
BOOST_CHECK(year == 2011);
BOOST_CHECK_EQUAL(yday , 58);
time += toNextYear;
BOOST_CHECK(time.get2(&year,&yday,&h,&min,&sec,&uSec) == true);
BOOST_CHECK_EQUAL(year , 2012);
BOOST_CHECK_EQUAL(yday , 0);
year = 1964, month = 2, day = 29;
leapYear.set(year,month,day,h,min,sec,uSec);
BOOST_CHECK(leapYear.get2(&year,&yday,&h,&min,&sec,&uSec) == true);
BOOST_CHECK_EQUAL(yday , 59);
leapYear += toNextYear;
BOOST_CHECK(leapYear.get2(&year,&yday,&h,&min,&sec,&uSec) == true);
BOOST_CHECK_EQUAL(year, 1965);
BOOST_CHECK_EQUAL(yday , 0);
gc::Time before1900;
day = 28, month = 2, year = 1900;
before1900.set(year,month,day,h,min,sec,uSec);
BOOST_CHECK(before1900.get(&year,&month,&day,&h,&min,&sec,&uSec) == true);
BOOST_CHECK_EQUAL(year , 1900);
BOOST_CHECK_EQUAL(day , 28);
BOOST_CHECK_EQUAL(month, 2);
gc::Time pure;
pure.get(&year,&month,&day,&h,&min,&sec,&uSec);
BOOST_CHECK_EQUAL(year, 1970);
pure -= oneYear;
pure.get(&year,&month,&day,&h,&min,&sec,&uSec);
BOOST_CHECK_EQUAL(year, 1969);
day = 50, month = 4, year = 1566;
before1900.set(year,month,day,h,min,sec,uSec);
BOOST_CHECK(before1900.get(&year,&month,&day,&h,&min,&sec,&uSec) == true);
BOOST_CHECK_EQUAL(year , 1566);
BOOST_CHECK_EQUAL(day , 20);
BOOST_CHECK_EQUAL(month, 5);
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_CASE(localTime) {
gc::Time local;
local.set(1970,3,14,5,30,3,39);
gc::Time time(local);
BOOST_CHECK_EQUAL(double(local), double(time));
std::string check1 = local.toString("%FT%T.%fZ");
std::string check2 = "1970-03-14T05:30:03.000039Z";
bool equal = boost::iequals(check1,check2);
BOOST_CHECK_EQUAL(equal, true);
gc::Time localtest = local.LocalTime();
local = local.LocalTime();
localtest.setUSecs(0);
local.setUSecs(0);
check1 = local.iso();
check2 = localtest.iso();
BOOST_CHECK_EQUAL(check1, check2);
local.set(1970,3,14,5,30,3,39);
check1 = "1970-03-14T05:30:03.000039Z";
check2 = local.toString("%FT%T.%fZ");
BOOST_CHECK_EQUAL(check1, check2);
local.set(1981,9,14,5,30,3,39);
check1 = "1981-09-14T05:30:03.000039Z";
check2 = local.toString("%FT%T.%fZ");
BOOST_CHECK_EQUAL(check1, check2);
local.set(2014,3,14,5,30,3,39);
check1 = "2014-03-14T05:30:03.000039Z";
check2 = local.toString("%FT%T.%fZ");
BOOST_CHECK_EQUAL(check1, check2);
local.set(2000,8,14,5,30,3,39);
check1 = local.toString("%FT%T.%fZ");
check2 = "2000-08-14T05:30:03.000039Z";
BOOST_CHECK_EQUAL(check1, check2);
// before 1970
gc::Time before1970;
before1970.set(1950,6,4,15,8,66,11);
gc::Time t(before1970);
gc::Time time1 = local.LocalTime();
time1.setUSecs(0);
gc::Time time2 = before1970.LocalTime();
time2.setUSecs(0);
check1 = time1.toString("%FT%T.%fZ");
check2 = time2.toString("%FT%T.%fZ");
BOOST_CHECK_EQUAL(check1, check2);
before1970.set(1914,9,4,7,8,66,11);
check1 = "1914-09-04T07:09:06.000011Z";
check2 = before1970.toString("%FT%T.%fZ");
BOOST_CHECK_EQUAL(check1, check2);
gc::Time yearDay = yearDay.FromYearDay(1971, 3);
double dayInSeconds = 86400;
double yearInSeconds = 31536000;
BOOST_CHECK_EQUAL(double(yearDay),dayInSeconds*2 + yearInSeconds);
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_CASE(validStrings) {
gc::Time date(2016,8,26,15,44,9,644);
std::string test = date.toString("%FT%T.%fZ");
std::string check = "2016-08-26T15:44:09.000644Z";
bool equal = boost::iequals(test,check);
BOOST_CHECK_EQUAL(equal, true);
BOOST_CHECK(date.FromString(test.c_str(),"%FT%T.%fZ") == date);
BOOST_CHECK(test == date.iso());
BOOST_CHECK(date.fromString(test.c_str(),"%FT%T.%fZ") == true);
BOOST_CHECK_EQUAL(date.valid(), true);
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_SUITE_END()

105
libs/gempa/caps/test/endianess.cpp Normal file
View File

@ -0,0 +1,105 @@
/***************************************************************************
* 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/endianess.h>
#include <gempa/caps/rawpacket.cpp>
namespace gce = Gempa::CAPS::Endianess;
namespace bu = boost::unit_test;
using namespace std;
BOOST_AUTO_TEST_SUITE(gempa_common_caps_endianess)
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_CASE(converter) {
bu::unit_test_log.set_threshold_level(bu::log_warnings);
bu::unit_test_log.set_threshold_level(bu::log_messages);
// Check little_endian int16_t.
const int16_t k16Value{0x0123};
if(gce::Current::LittleEndian) {
BOOST_CHECK_EQUAL(gce::Converter::ToLittleEndian(k16Value), k16Value);
BOOST_CHECK_EQUAL(gce::Converter::FromLittleEndian(k16Value), k16Value);
int16_t g16Value = gce::Converter::ToBigEndian(k16Value);
BOOST_CHECK_EQUAL(g16Value, 8961);
BOOST_CHECK_EQUAL(gce::Converter::FromBigEndian(g16Value), k16Value);
gce::Converter::ToLittleEndian(&k16Value, 4);
BOOST_CHECK_EQUAL(291, k16Value);
}
else {
BOOST_CHECK_EQUAL(gce::Converter::ToBigEndian(k16Value), k16Value);
BOOST_CHECK_EQUAL(gce::Converter::FromBigEndian(k16Value), k16Value);
int16_t g16Value = gce::Converter::ToLittleEndian(k16Value);
BOOST_CHECK_EQUAL(g16Value, 291);
BOOST_CHECK_EQUAL(gce::Converter::FromLittleEndian(g16Value), k16Value);
}
// Check little_endian int32_t.
const int32_t k32Value{0x01234567};
if(gce::Current::LittleEndian) {
BOOST_CHECK_EQUAL(gce::Converter::ToLittleEndian(k32Value), k32Value);
BOOST_CHECK_EQUAL(gce::Converter::FromLittleEndian(k32Value), k32Value);
int32_t g32Value = gce::Converter::ToBigEndian(k32Value);
BOOST_CHECK_EQUAL(g32Value, 1732584193);
BOOST_CHECK_EQUAL(gce::Converter::FromBigEndian(g32Value), k32Value);
gce::Converter::ToLittleEndian(&k32Value, 11);
BOOST_CHECK_EQUAL(19088743, k32Value);
}
else {
BOOST_CHECK_EQUAL(gce::Converter::ToBigEndian(k32Value), k32Value);
BOOST_CHECK_EQUAL(gce::Converter::FromBigEndian(k32Value), k32Value);
int16_t g32Value = gce::Converter::ToLittleEndian(k32Value);
BOOST_CHECK_EQUAL(g32Value, 19088743);
BOOST_CHECK_EQUAL(gce::Converter::FromLittleEndian(g32Value), k32Value);
}
// Check little_endian int64_t.
const int64_t k64Value{0x0123456789abcdef};
if(gce::Current::LittleEndian) {
BOOST_CHECK_EQUAL(gce::Converter::ToLittleEndian(k64Value), k64Value);
BOOST_CHECK_EQUAL(gce::Converter::FromLittleEndian(k64Value), k64Value);
int64_t g32Value = gce::Converter::ToBigEndian(k64Value);
BOOST_CHECK_EQUAL(g32Value, -1167088121787636991);
BOOST_CHECK_EQUAL(gce::Converter::FromBigEndian(g32Value), k64Value);
gce::Converter::ToLittleEndian(&k64Value, 11);
BOOST_CHECK_EQUAL(81985529216486895, k64Value);
}
else {
BOOST_CHECK_EQUAL(gce::Converter::ToBigEndian(k64Value), k64Value);
BOOST_CHECK_EQUAL(gce::Converter::FromBigEndian(k64Value), k64Value);
int16_t g64Value = gce::Converter::ToLittleEndian(k64Value);
BOOST_CHECK_EQUAL(g64Value, 19088743);
BOOST_CHECK_EQUAL(gce::Converter::FromLittleEndian(g64Value), k64Value);
}
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_SUITE_END()

29
libs/gempa/caps/test/errors_find Normal file
View File

@ -0,0 +1,29 @@
Bei utils.h
---------------------------------------------------------------------------------------------------------------------------
Bei datetime.h
---------------------------------------------------------------------------------------------------------------------------
Bei rawpacket.cpp
---------------------------------------------------------------------------------------------------------------------------
Bei packet.h
---------------------------------------------------------------------------------------------------------------------------
Bei endianess.h
1) Bei reader ist der Pointer nicht an der ersten stelle des Streams. Siehe endianess.cpp (test) Zeile 114 und folgende.
---------------------------------------------------------------------------------------------------------------------------
Bei mseedpacket.cpp
1)
---------------------------------------------------------------------------------------------------------------------------

227
libs/gempa/caps/test/mseedpacket.cpp Normal file
View File

@ -0,0 +1,227 @@
/***************************************************************************
* 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 "test_utils.h"
#include <seiscomp3/unittest/unittests.h>
#include <gempa/caps/mseedpacket.h>
#include <gempa/caps/rawpacket.cpp>
#include <gempa/caps/utils.h>
#include <gempa/caps/datetime.h>
#include <fstream>
#include <iostream>
#include <math.h>
#include <string>
#include <streambuf>
namespace bu = boost::unit_test;
using namespace std;
using namespace Gempa::CAPS;
namespace {
struct Record {
Record() {
vector<char> mseed;
mseed.resize(512);
ifstream ifs("data/AM.RFE4F.00.SHZ.20180912.mseed");
if( ifs.is_open() ) {
ifs.read(mseed.data(), 512);
testRec.setData(mseed.data(), 512);
}
else
BOOST_TEST_MESSAGE("unable to open test data file.");
}
MSEEDDataRecord testRec;
};
}
BOOST_AUTO_TEST_SUITE(gempa_common_caps_mseedpacket)
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_CASE(equal_functions) {
bu::unit_test_log.set_threshold_level(bu::log_warnings);
bu::unit_test_log.set_threshold_level(bu::log_messages);
MSEEDDataRecord::Header header;
MSEEDDataRecord::Header otherHeader;
header.setSamplingTime(fromString("2018-01-01 00:00:01"));
header.samplingFrequencyNumerator = 30;
header.samplingFrequencyDenominator = 1;
BOOST_CHECK_EQUAL(header != otherHeader, true);
bool valid = header.compatible(otherHeader);
BOOST_CHECK_EQUAL(valid, false);
otherHeader = header;
valid = header.compatible(otherHeader);
BOOST_CHECK_EQUAL(valid, true);
BOOST_CHECK_EQUAL(header != otherHeader, false);
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_CASE(header_functions) {
MSEEDDataRecord::Header header;
header.dataType = DT_INT64;
header.samplingFrequencyNumerator = 1;
header.samplingFrequencyDenominator = 1;
char buf[1024];
arraybuf abuf(buf, 1024);
BOOST_CHECK_EQUAL(header.put(abuf), true);
MSEEDDataRecord::Header otherHeader;
BOOST_CHECK_EQUAL(otherHeader.get(abuf), true);
BOOST_CHECK_EQUAL(otherHeader.samplingFrequencyNumerator, 1);
BOOST_CHECK_EQUAL(otherHeader.samplingFrequencyDenominator, 1);
BOOST_CHECK_EQUAL(otherHeader.dataType, DT_INT64);
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_CASE(trim_function) {
// MSEEDs records can not be trimmed -> always false
MSEEDDataRecord testRec;
BOOST_CHECK(!testRec.canTrim());
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_CASE(merge_function) {
// MSEEDs records can not be merged -> always false
MSEEDDataRecord testRec;
BOOST_CHECK(!testRec.canMerge());
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_SUITE_END()
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_FIXTURE_TEST_CASE(getter_and_setter, Record) {
BOOST_CHECK_EQUAL("MSEED", testRec.formatName());
// get data size with and without header
size_t sizeWithout = testRec.dataSize(false);
BOOST_CHECK_EQUAL(sizeWithout, 512);
size_t sizeWith = testRec.dataSize(true);
BOOST_CHECK_EQUAL(512, sizeWith);
// check start end end time
BOOST_CHECK_EQUAL(testRec.startTime().iso(), "2018-09-12T10:55:56.751Z");
BOOST_CHECK_EQUAL(testRec.endTime().iso(), "2018-09-12T10:56:03.511Z");
// check sampling frequency
BOOST_CHECK_EQUAL(testRec.header()->samplingFrequencyNumerator, 50);
BOOST_CHECK_EQUAL(testRec.header()->samplingFrequencyDenominator, 1);
// check packet type
BOOST_CHECK_EQUAL(testRec.packetType(), MSEEDPacket);
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_FIXTURE_TEST_CASE(read_header_from_buffer, Record) {
char data[512];
// write test record data into a buffer
arraybuf abuf(data, 512);
BOOST_CHECK(testRec.put(abuf, true));
Time startTime, endTime;
MSEEDDataRecord::Header header;
// read start, end time and further information from buffer
MSEEDDataRecord rec;
rec.readMetaData(abuf, 512, header, startTime, endTime);
BOOST_CHECK_EQUAL(startTime.iso(), "2018-09-12T10:55:56.751Z");
BOOST_CHECK_EQUAL(endTime.iso(), "2018-09-12T10:56:03.511Z");
BOOST_CHECK_EQUAL(header.dataType, DT_INT32);
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_FIXTURE_TEST_CASE(read_data_from_file, Record) {
ifstream ifs("data/AM.RFE4F.00.SHZ.20180912.mseed");
BOOST_CHECK(ifs.is_open());
vector<char> buf;
buf.resize(512);
ifs.read(buf.data(), 512);
MSEEDDataRecord rec;
rec.setData(buf.data(),512);
BOOST_CHECK_EQUAL(rec.header()->samplingFrequencyDenominator, 1);
BOOST_CHECK_EQUAL(rec.header()->samplingFrequencyNumerator, 50);
TimeSpan timeSpan = samplesToTimeSpan(*rec.header(), 338);
// check that the record start time + all samples is equal to
// the record end time
Time endTime = rec.startTime() + timeSpan;
BOOST_CHECK(endTime == rec.endTime());
// check both header are equal
BOOST_CHECK_EQUAL(rec.header()->compatible(*testRec.header()), true);
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

97
libs/gempa/caps/test/packet.cpp Normal file
View File

@ -0,0 +1,97 @@
/***************************************************************************
* 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/packet.h>
#include <gempa/caps/rawpacket.cpp>
#include <gempa/caps/utils.h>
namespace gc = Gempa::CAPS;
namespace bu = boost::unit_test;
using namespace std;
BOOST_AUTO_TEST_SUITE(gempa_common_caps_packet)
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_CASE(equal_function) {
bu::unit_test_log.set_threshold_level(bu::log_warnings);
bu::unit_test_log.set_threshold_level(bu::log_messages);
gc::DataRecord::Header header;
gc::DataRecord::Header other;
gc::Time t(1004791084,45368);
BOOST_CHECK_NO_THROW(header.setSamplingTime(t));
header.samplingFrequencyNumerator = 3;
header.samplingFrequencyDenominator = 7;
BOOST_CHECK_EQUAL(header != other, true);
bool valid = header.compatible(other);
BOOST_CHECK_EQUAL(valid, false);
other = header;
valid = header.compatible(other);
BOOST_CHECK_EQUAL(valid, true);
BOOST_CHECK_EQUAL(header != other, false);
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_CASE(getAndPut) {
gc::DataRecord::Header header;
header.dataType = gc::DT_INT64;
header.samplingFrequencyNumerator = 1;
header.samplingFrequencyDenominator = 1;
char buf[1024];
gc::arraybuf abuf(buf, 1024);
BOOST_CHECK_EQUAL(header.samplingFrequencyNumerator, 1);
BOOST_CHECK_EQUAL(header.samplingFrequencyDenominator, 1);
BOOST_CHECK_EQUAL(header.dataType, gc::DT_INT64);
bool valid = header.put(abuf);
BOOST_CHECK_EQUAL(valid, true);
gc::DataRecord::Header otherHeader;
valid = otherHeader.get(abuf);
BOOST_CHECK_EQUAL(valid,true);
BOOST_CHECK_EQUAL(otherHeader.samplingFrequencyNumerator, 1);
BOOST_CHECK_EQUAL(otherHeader.samplingFrequencyDenominator, 1);
BOOST_CHECK_EQUAL(otherHeader.dataType, gc::DT_INT64);
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_SUITE_END()

288
libs/gempa/caps/test/rawpacket.cpp Normal file
View File

@ -0,0 +1,288 @@
/***************************************************************************
* 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 *
***************************************************************************/
#ifndef M_PI
#define M_PI 3.14159265359
#endif
#define SEISCOMP_TEST_MODULE gempa
#include "test_utils.h"
#include <seiscomp3/unittest/unittests.h>
#include <gempa/caps/rawpacket.cpp>
#include <gempa/caps/mseedpacket.cpp>
#include <gempa/caps/datetime.h>
#include <math.h>
#include <string>
#include <streambuf>
namespace gc = Gempa::CAPS;
namespace bu = boost::unit_test;
using namespace std;
namespace {
struct Record {
Record() {
gc::DataRecord::Header header;
header.setSamplingTime(fromString("2018-01-01 00:00:01"));
header.dataType = gc::DT_INT32;
header.samplingFrequencyNumerator = 1;
header.samplingFrequencyDenominator = 1;
rdr.setHeader(header);
}
gc::RawDataRecord rdr;
};
}
template<typename T> void fillRecord(T *data, size_t len , gc::Time stime, int sample_microsecs,
double amplitude, double period) {
double periodScale = (2 * M_PI) / period;
double x = (double)stime * periodScale;
double xOffset = sample_microsecs * 1E-6 * periodScale;
for ( size_t i = 0; i < len; ++i ) {
*data = amplitude * sin(x);
++data;
x += xOffset;
}
}
BOOST_AUTO_TEST_SUITE(gempa_common_caps_rawpacket)
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_FIXTURE_TEST_CASE(getAndSet, Record) {
bu::unit_test_log.set_threshold_level(bu::log_warnings);
bu::unit_test_log.set_threshold_level(bu::log_messages);
vector<int> data;
data.resize(256);
rdr.setBuffer(data.data(), 256);
// Set data type and get size of it
rdr.setDataType(gc::DT_FLOAT);
BOOST_CHECK_EQUAL(sizeof(float), gc::sizeOf(rdr.header()->dataType));
BOOST_CHECK_EQUAL("RAW/FLOAT", rdr.formatName());
rdr.setDataType(gc::DT_INT64);
BOOST_CHECK_EQUAL(sizeof(int64_t), gc::sizeOf(rdr.header()->dataType));
BOOST_CHECK_EQUAL("RAW/INT64", rdr.formatName());
// get data size with and without header
size_t sizeWithout = rdr.dataSize(false);
BOOST_CHECK_EQUAL(sizeWithout, 256);
size_t sizeWith = rdr.dataSize(true);
BOOST_CHECK_EQUAL(sizeWithout + rdr.header()->dataSize(), sizeWith);
data.resize(65536);
rdr.setBuffer(data.data(), 65536);
sizeWithout = rdr.dataSize(false);
BOOST_CHECK_EQUAL(sizeWithout, 65536);
sizeWith = rdr.dataSize(true);
BOOST_CHECK_EQUAL(sizeWithout + rdr.header()->dataSize(), sizeWith);
// Set new FrequencyNumerator and FrequencyDenominator
rdr.setSamplingFrequency(100,1);
BOOST_CHECK_EQUAL(rdr.header()->samplingFrequencyNumerator, 100);
BOOST_CHECK_EQUAL(rdr.header()->samplingFrequencyDenominator, 1);
rdr.setSamplingFrequency(20,1);
BOOST_CHECK_EQUAL(rdr.header()->samplingFrequencyNumerator, 20);
BOOST_CHECK_EQUAL(rdr.header()->samplingFrequencyDenominator, 1);
gc::Time t = gc::getEndTime(rdr.startTime(),20, *rdr.header());
BOOST_CHECK_EQUAL(t.iso(), "2018-01-01T00:00:02.0000Z");
gc::DataRecord::Header otherHeader;
BOOST_CHECK_NO_THROW(rdr.setHeader(otherHeader));
BOOST_CHECK_EQUAL("RAW/UNKWN", rdr.formatName());
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_FIXTURE_TEST_CASE(checkTime, Record) {
gc::Time t = gc::getEndTime(rdr.startTime(), 3, *rdr.header());
BOOST_CHECK_EQUAL(t.iso(), "2018-01-01T00:00:04.0000Z");
rdr.setStartTime(fromString("2018-02-01 00:00:03.0000"));
vector<int> data;
data.resize(1024);
rdr.setBuffer(data.data(), 1024);
t = gc::getEndTime(rdr.startTime(), 3, *rdr.header());
BOOST_CHECK_EQUAL(rdr.startTime().iso(), "2018-02-01T00:00:03.0000Z");
BOOST_CHECK_EQUAL(t.iso(), "2018-02-01T00:00:06.0000Z");
rdr.setStartTime(fromString("1988-03-14 14:22:57.322"));
t = gc::getEndTime(rdr.startTime(), 2, *rdr.header());
BOOST_CHECK_EQUAL(t.iso(), "1988-03-14T14:22:59.0000Z");
rdr.setStartTime(fromString("1970-01-01 00:00:00.0000"));
rdr.setSamplingFrequency(20,1);
BOOST_CHECK_EQUAL(rdr.endTime().iso(), "1970-01-01T00:00:12.8Z");
rdr.setDataType(gc::DT_FLOAT);
BOOST_CHECK_EQUAL(rdr.endTime().iso(), "1970-01-01T00:00:12.8Z");
rdr.setDataType(gc::DT_DOUBLE);
data.resize(2048);
rdr.setBuffer(data.data(), 2048);
BOOST_CHECK_EQUAL(rdr.endTime().iso(), "1970-01-01T00:00:12.8Z");
rdr.setDataType(gc::DT_INT64);
BOOST_CHECK_EQUAL(rdr.endTime().iso(), "1970-01-01T00:00:12.8Z");
rdr.setDataType(gc::DT_INT8);
data.resize(256);
rdr.setBuffer(data.data(), 256);
BOOST_CHECK_EQUAL(rdr.endTime().iso(), "1970-01-01T00:00:12.8Z");
rdr.setDataType(gc::DT_INT16);
data.resize(512);
rdr.setBuffer(data.data(),512);
BOOST_CHECK_EQUAL(rdr.endTime().iso(), "1970-01-01T00:00:12.8Z");
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_FIXTURE_TEST_CASE(trimTest, Record) {
// Raw records are trimable -> always true
BOOST_CHECK(rdr.canTrim());
const gc::Time endT = gc::getEndTime(rdr.startTime(), 1, *rdr.header());
BOOST_CHECK_EQUAL(rdr.canTrim(), true);
bool trimTest = rdr.trim(rdr.startTime(), endT);
BOOST_CHECK_EQUAL(trimTest, true);
BOOST_CHECK_EQUAL(rdr.startTime().iso(), "2018-01-01T00:00:01.0000Z");
BOOST_CHECK_EQUAL(endT.iso(), "2018-01-01T00:00:02.0000Z");
trimTest = rdr.trim(endT, rdr.startTime());
BOOST_CHECK_EQUAL(trimTest, false);
rdr.setSamplingFrequency(0,0);
trimTest = rdr.trim(rdr.startTime(), endT);
BOOST_CHECK_EQUAL(trimTest, false);
BOOST_CHECK_EQUAL(rdr.canMerge(), true);
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_FIXTURE_TEST_CASE(getAndPut, Record) {
char data[500000];
uint64_t sample_microsecs = uint64_t(rdr.header()->samplingFrequencyDenominator) * 1000000 / rdr.header()->samplingFrequencyNumerator;
fillRecord<float>((float*)&data, 1024, rdr.startTime(), (int)sample_microsecs, 4.2, 2.1);
gc::arraybuf abuf(data, 1024);
vector<int> arr;
arr.resize(1024);
rdr.setBuffer(arr.data(), 1024);
bool check = rdr.put(abuf, true);
BOOST_CHECK_EQUAL(check, false);
// RS_PARTIAL = 2
gc::RawDataRecord rdrOther;
gc::DataRecord::ReadStatusCode ret = rdrOther.get(abuf, 1024, rdr.startTime(),rdr.endTime(), 10);
BOOST_CHECK_EQUAL(ret, gc::DataRecord::RS_Partial);
BOOST_CHECK_EQUAL(rdrOther.startTime() == rdr.startTime(), true);
// RS_COMPLETE = 1
gc::arraybuf abuf2(data, 1024);
check = rdrOther.put(abuf2, true);
BOOST_CHECK_EQUAL(check, true);
gc::RawDataRecord rdrOther2;
ret = rdrOther2.get(abuf2, 1024, rdrOther2.startTime(),rdrOther2.endTime(), 10);
BOOST_CHECK_EQUAL(ret, gc::DataRecord::RS_Complete);
gc::DataRecord::Header header = *rdrOther2.header();
gc::Time start = rdrOther2.startTime();
gc::Time end = gc::getEndTime(rdrOther2.startTime(), 2, header);
rdrOther2.readMetaData(abuf, 1024, header, start, end);
BOOST_CHECK_EQUAL(rdrOther2.startTime().iso(), "2018-01-01T00:00:01.0000Z");
BOOST_CHECK_EQUAL(rdrOther2.endTime().iso(), "2018-01-01T00:04:13.0000Z");
// RS_BEFORE_TIME_WINDOW = 3
gc::arraybuf abuf3(data, 1024);
gc::RawDataRecord rdrBefore;
header.setSamplingTime(fromString("2018-01-01 00:00:00"));
header.dataType = gc::DT_INT32;
header.samplingFrequencyNumerator = 1;
header.samplingFrequencyDenominator = 1;
rdrBefore.setHeader(header);
check = rdrBefore.put(abuf3, true);
BOOST_CHECK_EQUAL(check, true);
ret = rdrOther.get(abuf3, 1024, rdr.endTime(),rdr.startTime(), 10);
BOOST_CHECK_EQUAL(ret, gc::DataRecord::RS_BeforeTimeWindow);
// RS_AFTER_TIME_WINDOW = 4
gc::arraybuf abuf4(data, 1024);
gc::RawDataRecord rdrAfter;
header.setSamplingTime(fromString("2020-01-01 00:00:00"));
header.dataType = gc::DT_INT32;
header.samplingFrequencyNumerator = 1;
header.samplingFrequencyDenominator = 1;
rdrAfter.setHeader(header);
check = rdrAfter.put(abuf4, true);
BOOST_CHECK_EQUAL(check, true);
ret = rdrOther.get(abuf4, 1024, rdrBefore.startTime(),rdrBefore.endTime(), 10);
BOOST_CHECK_EQUAL(ret, gc::DataRecord::RS_AfterTimeWindow);
// RS_ERROR = 0
gc::RawDataRecord rdrError;
ret = rdrError.get(abuf, 1248, rdr.startTime(),rdr.endTime(), 10);
BOOST_CHECK_EQUAL(ret, gc::DataRecord::RS_Error);
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_SUITE_END()

10
libs/gempa/caps/test/test_utils.h Normal file
View File

@ -0,0 +1,10 @@
#ifndef __TEST_UTILS_H__
#define __TEST_UTILS_H__
#include <gempa/caps/datetime.h>
Gempa::CAPS::Time fromString(const char *str) {
return Gempa::CAPS::Time::FromString(str, "%F %T");
}
#endif

289
libs/gempa/caps/test/utils.cpp Normal file
View File

@ -0,0 +1,289 @@
/***************************************************************************
* 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/utils.h>
namespace gc = Gempa::CAPS;
namespace bu = boost::unit_test;
using namespace gc;
using namespace std;
BOOST_AUTO_TEST_SUITE(gempa_common_caps_utils)
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_CASE(split_address_function) {
bu::unit_test_log.set_threshold_level(bu::log_warnings);
bu::unit_test_log.set_threshold_level(bu::log_messages);
string name;
unsigned short port;
int defaultPort = 18002;
string hostname = "localhost";
bool valid = splitAddress(name, port, hostname,defaultPort);
BOOST_CHECK_EQUAL(valid, true);
BOOST_CHECK_EQUAL(hostname, "localhost");
BOOST_CHECK_EQUAL(port, 18002);
hostname = "data.gempa.de:18000";
valid = splitAddress(name, port, hostname, defaultPort);
BOOST_CHECK_EQUAL(valid, true);
BOOST_CHECK_EQUAL(name, "data.gempa.de");
BOOST_CHECK_EQUAL(port, 18000);
hostname = "";
valid = splitAddress(name, port, hostname, defaultPort);
BOOST_CHECK_EQUAL(valid, false);
hostname = "localhost:abcde";
valid = splitAddress(name, port, hostname, defaultPort);
BOOST_CHECK_EQUAL(valid, false);
// port range check. By definition allowed ports are 1 - 65535
hostname = "localhost:0";
valid = splitAddress(name, port, hostname, defaultPort);
BOOST_CHECK_EQUAL(valid, false);
hostname = "localhost:1";
valid = splitAddress(name, port, hostname, defaultPort);
BOOST_CHECK_EQUAL(valid, true);
hostname = "localhost:65536";
valid = splitAddress(name, port, hostname, defaultPort);
BOOST_CHECK_EQUAL(valid, false);
hostname = "localhost:-1";
valid = splitAddress(name, port, hostname, defaultPort);
BOOST_CHECK_EQUAL(valid, false);
hostname = "localhost:";
valid = splitAddress(name, port, hostname,defaultPort);
BOOST_CHECK_EQUAL(valid, false);
}
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
BOOST_AUTO_TEST_CASE(trim_function) {
// delete whitespaces before and after string
string text = " This is a test text 1";
BOOST_CHECK_EQUAL(trim(text), "This is a test text 1");
const char *str = text.c_str();
int len = text.length();
const char *res = trim(str,len);
BOOST_CHECK_EQUAL(string(res, len), "This is a test text 1");
text = " This is a test text 2";
BOOST_CHECK_EQUAL(trim(text), "This is a test text 2");
str = text.c_str();
len = text.length();
res = trim(str,len);
BOOST_CHECK_EQUAL(string(res,len), "This is a test text 2");
text = "This is a test text ";
BOOST_CHECK_EQUAL(trim(text), "This is a test text");
str = text.c_str();
len = text.length();
res = trim(str,len);
BOOST_CHECK_EQUAL(string(res,len), "This is a test text");
text = " Hello World ";
BOOST_CHECK_EQUAL(trim(text), "Hello World");
str = text.c_str();
len = text.length();
res = trim(str,len);
BOOST_CHECK_EQUAL(string(res,len), "Hello World");
text = " Hello : world";
BOOST_CHECK_EQUAL(trim(text), "Hello : world");
str = text.c_str();
len = text.length();
res = trim(str, len);
BOOST_CHECK_EQUAL(string(res,len), "Hello : world");
}
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
BOOST_AUTO_TEST_CASE(converts_time) {
// Converts time object to timestamp
const Time t(2014,4,14,6,34,39,7389);
TimeStamp ts;
timeToTimestamp(ts, t);
BOOST_CHECK_EQUAL(ts.year, 2014);
BOOST_CHECK_EQUAL(ts.second, 39);
const Time t2(0,0);
timeToTimestamp(ts,t2);
BOOST_CHECK_EQUAL(ts.year, 1970);
BOOST_CHECK_EQUAL(ts.hour, 0);
BOOST_CHECK_EQUAL(ts.yday, 0);
// Converts timestamp to time object
Time t3 = timestampToTime(ts);
int year, yday, hour, min, sec, usec;
t3.get2(&year, &yday, &hour, &min, &sec, &usec);
BOOST_CHECK_EQUAL(year, 1970);
BOOST_CHECK_EQUAL(min, 0);
}
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
BOOST_AUTO_TEST_CASE(samples) {
DataRecord::Header head;
head.samplingFrequencyNumerator = 1;
head.samplingFrequencyDenominator = 1;
// Convert samples to timespan
TimeSpan ts = samplesToTimeSpan(head, 2);
BOOST_CHECK_EQUAL(ts, TimeSpan(2,0));
// Convert time span to samples
BOOST_CHECK_EQUAL(timeSpanToSamples(head, ts), 2);
// Convert time span to samples and round up/down
BOOST_CHECK_EQUAL(timeSpanToSamplesCeil(head, TimeSpan(0, 500000)), 1);
BOOST_CHECK_EQUAL(timeSpanToSamplesFloor(head, TimeSpan(0, 600000)), 0);
}
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
BOOST_AUTO_TEST_CASE(str_to_int) {
// int tests
const char *str = "1352";
int i;
bool ret = str2int(i, str);
BOOST_CHECK_EQUAL(ret, true);
BOOST_CHECK_EQUAL(i, 1352);
str = "";
ret = str2int(i, str);
BOOST_CHECK_EQUAL(ret, false);
str = "478a2";
ret = str2int(i, str);
BOOST_CHECK_EQUAL(ret, false);
str = " 57721";
ret = str2int(i, str);
BOOST_CHECK_EQUAL(ret, true);
BOOST_CHECK_EQUAL(i, 57721);
str = "4876 9742";
ret = str2int(i, str);
BOOST_CHECK_EQUAL(ret, true);
BOOST_CHECK_EQUAL(i, 4876);
str = "-98256";
ret = str2int(i,str);
BOOST_CHECK_EQUAL(ret, true);
BOOST_CHECK_EQUAL(i, -98256);
str = "-2147483649";
ret = str2int(i,str);
BOOST_CHECK_EQUAL(ret, false);
str = "2147483648";
ret = str2int(i,str);
BOOST_CHECK_EQUAL(ret, false);
// uint16_t tests
str = "1";
uint16_t value;
ret = str2int(value, str);
BOOST_CHECK_EQUAL(ret, true);
str = "-1";
ret = str2int(value, str);
BOOST_CHECK_EQUAL(ret, false);
str = "65535";
ret = str2int(value, str);
BOOST_CHECK_EQUAL(ret, true);
str = "65536";
ret = str2int(value, str);
BOOST_CHECK_EQUAL(ret, false);
}
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
BOOST_AUTO_TEST_CASE(tokenize_function) {
const char *text = "Hello, World!";
int len = strlen(text), tok_len;
const char *tok = tokenize(text, ",", len, tok_len);
BOOST_CHECK_EQUAL(string(tok, tok_len), "Hello");
tok = tokenize(text, ",", len, tok_len);
BOOST_CHECK_EQUAL(string(tok,tok_len)," World!");
text = "This is a book";
len = strlen(text);
int tok_count = 0;
while ( (tok = tokenize(text, ",", len, tok_len)) != NULL ) {
if ( tok_count == 3 ) {
BOOST_CHECK_EQUAL(string(tok, tok_len), "book");
}
++tok_count;
}
text = "";
len = strlen(text);
tok = tokenize(text, ";", len,tok_len);
BOOST_CHECK_EQUAL(string(tok,tok_len), "");
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
BOOST_AUTO_TEST_SUITE_END()