Martino Ferrari
108 lines
3.6 KiB
C++
108 lines
3.6 KiB
C++
/**
|
|
* @file LTTBGTest.cpp
|
|
* @brief Unit tests for the StreamHub LTTB decimation.
|
|
*
|
|
* @copyright Copyright 2015 F4E | European Joint Undertaking for ITER and
|
|
* the Development of Fusion Energy ('Fusion for Energy').
|
|
* Licensed under the EUPL, Version 1.1 or - as soon they will be approved
|
|
* by the European Commission - subsequent versions of the EUPL (the "Licence")
|
|
* You may not use this work except in compliance with the Licence.
|
|
* You may obtain a copy of the Licence at: http://ec.europa.eu/idabc/eupl
|
|
*
|
|
* @warning Unless required by applicable law or agreed to in writing,
|
|
* software distributed under the Licence is distributed on an "AS IS"
|
|
* basis, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
|
|
* or implied. See the Licence permissions and limitations under the Licence.
|
|
*/
|
|
|
|
#include "LTTB.h"
|
|
|
|
#include <gtest/gtest.h>
|
|
#include <math.h>
|
|
|
|
using StreamHub::LTTBDecimate;
|
|
using MARTe::float64;
|
|
using MARTe::uint32;
|
|
|
|
TEST(LTTBGTest, TestEmptyInput) {
|
|
float64 t[4] = {0.0};
|
|
float64 v[4] = {0.0};
|
|
EXPECT_EQ(0u, LTTBDecimate(t, v, 0u, t, v, 4u));
|
|
}
|
|
|
|
TEST(LTTBGTest, TestPassthroughWhenSmall) {
|
|
float64 tIn[5] = {0.0, 1.0, 2.0, 3.0, 4.0};
|
|
float64 vIn[5] = {5.0, 6.0, 7.0, 8.0, 9.0};
|
|
float64 tOut[5], vOut[5];
|
|
ASSERT_EQ(5u, LTTBDecimate(tIn, vIn, 5u, tOut, vOut, 10u));
|
|
for (uint32 i = 0u; i < 5u; i++) {
|
|
EXPECT_DOUBLE_EQ(tIn[i], tOut[i]);
|
|
EXPECT_DOUBLE_EQ(vIn[i], vOut[i]);
|
|
}
|
|
}
|
|
|
|
TEST(LTTBGTest, TestDecimateCountAndEndpoints) {
|
|
const uint32 n = 1000u;
|
|
static float64 tIn[1000], vIn[1000];
|
|
for (uint32 i = 0u; i < n; i++) {
|
|
tIn[i] = static_cast<float64>(i) * 0.001;
|
|
vIn[i] = sin(tIn[i] * 50.0);
|
|
}
|
|
static float64 tOut[100], vOut[100];
|
|
ASSERT_EQ(100u, LTTBDecimate(tIn, vIn, n, tOut, vOut, 100u));
|
|
/* First and last points preserved */
|
|
EXPECT_DOUBLE_EQ(tIn[0], tOut[0]);
|
|
EXPECT_DOUBLE_EQ(tIn[n - 1u], tOut[99]);
|
|
/* Output time strictly increasing */
|
|
for (uint32 i = 1u; i < 100u; i++) {
|
|
EXPECT_LT(tOut[i - 1u], tOut[i]);
|
|
}
|
|
}
|
|
|
|
TEST(LTTBGTest, TestSpikePreserved) {
|
|
const uint32 n = 500u;
|
|
static float64 tIn[500], vIn[500];
|
|
for (uint32 i = 0u; i < n; i++) {
|
|
tIn[i] = static_cast<float64>(i);
|
|
vIn[i] = 0.0;
|
|
}
|
|
vIn[250] = 100.0; /* single spike in a flat signal */
|
|
static float64 tOut[50], vOut[50];
|
|
const uint32 nOut = LTTBDecimate(tIn, vIn, n, tOut, vOut, 50u);
|
|
ASSERT_EQ(50u, nOut);
|
|
bool spikeFound = false;
|
|
for (uint32 i = 0u; i < nOut; i++) {
|
|
if (vOut[i] == 100.0) { spikeFound = true; }
|
|
}
|
|
EXPECT_TRUE(spikeFound);
|
|
}
|
|
|
|
TEST(LTTBGTest, TestOutputPointsExistInInput) {
|
|
const uint32 n = 200u;
|
|
static float64 tIn[200], vIn[200];
|
|
for (uint32 i = 0u; i < n; i++) {
|
|
tIn[i] = static_cast<float64>(i);
|
|
vIn[i] = cos(static_cast<float64>(i) * 0.3);
|
|
}
|
|
static float64 tOut[20], vOut[20];
|
|
const uint32 nOut = LTTBDecimate(tIn, vIn, n, tOut, vOut, 20u);
|
|
ASSERT_EQ(20u, nOut);
|
|
/* Every output sample must be an actual input sample (no interpolation) */
|
|
for (uint32 i = 0u; i < nOut; i++) {
|
|
const uint32 idx = static_cast<uint32>(tOut[i]);
|
|
EXPECT_DOUBLE_EQ(tIn[idx], tOut[i]);
|
|
EXPECT_DOUBLE_EQ(vIn[idx], vOut[i]);
|
|
}
|
|
}
|
|
|
|
TEST(LTTBGTest, TestThresholdBelowThreeCopiesAll) {
|
|
float64 tIn[10], vIn[10];
|
|
for (uint32 i = 0u; i < 10u; i++) {
|
|
tIn[i] = static_cast<float64>(i);
|
|
vIn[i] = static_cast<float64>(i);
|
|
}
|
|
float64 tOut[10], vOut[10];
|
|
/* threshold < 3 → fast path copies everything */
|
|
EXPECT_EQ(10u, LTTBDecimate(tIn, vIn, 10u, tOut, vOut, 2u));
|
|
}
|