ros2/openvehicle-api
3
0
Fork 0
mirror of https://github.com/eclipse-openvehicle-api/openvehicle-api.git synced 2026-07-02 05:35:11 +00:00
Code Issues Packages Projects Releases 1 Wiki Activity

Precommit (#1)

Browse Source 
* first commit

* cleanup
This commit is contained in:
tompzf
2025-11-04 13:28:06 +01:00
committed by GitHub
parent dba45dc636
commit 6ed4b1534e
898 changed files with 256340 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
tests/unit_tests/asc_format/CMakeLists.txt Normal file
View File

@@ -0,0 +1,27 @@
# Define project
project (UnitTest_ASC_Format VERSION 1.0 LANGUAGES CXX)
# Compile the source code
add_executable(UnitTest_ASC_Format
"asc_reader_test.cpp"
"main.cpp"
"asc_writer_test.cpp")
target_link_libraries(UnitTest_ASC_Format ${CMAKE_DL_LIBS} GTest::GTest)
# Add the IDL Compiler unittest
add_test(NAME UnitTest_ASC_Format COMMAND UnitTest_ASC_Format)
# Execute the test
add_custom_command(TARGET UnitTest_ASC_Format POST_BUILD
COMMAND ${CMAKE_COMMAND} -E env TEST_EXECUTION_MODE=CMake "$<TARGET_FILE:UnitTest_ASC_Format>" --gtest_output=xml:${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/UnitTest_ASC_Format.xml
VERBATIM
)
# copy the ASC test file to binary folder
file (COPY ${PROJECT_SOURCE_DIR}/asc_reader_timing_test.asc DESTINATION ${CMAKE_BINARY_DIR}/tests/bin)
file (COPY ${PROJECT_SOURCE_DIR}/asc_reader_test.asc DESTINATION ${CMAKE_BINARY_DIR}/tests/bin)
file (COPY ${PROJECT_SOURCE_DIR}/asc_reader_ext_id_test.asc DESTINATION ${CMAKE_BINARY_DIR}/tests/bin)
file (COPY ${PROJECT_SOURCE_DIR}/asc_reader_canfd_test.asc DESTINATION ${CMAKE_BINARY_DIR}/tests/bin)
# Build dependencies
add_dependencies(UnitTest_ASC_Format dependency_sdv_components)

9
tests/unit_tests/asc_format/asc_reader_canfd_test.asc Normal file
View File

@@ -0,0 +1,9 @@
date Dez. 3 2014 16:34:20
base hex timestamps absolute
no internal events logged
Begin Triggerblock
3.35516 1 B4323x Rx D 8 72 E4 19 2F 14 00 00 00
3.35522 6 52 Rx D 2 6C 60
3.36716 1 B4323x Rx D 8 73 E5 E9 24 e2 00 00 00
3.36722 CANFD 15 Rx 86 1 0 8 8 48 75 6d 61 6e 69 73 6d 0 0 3000 0 0 0
End TriggerBlock

11
tests/unit_tests/asc_format/asc_reader_ext_id_test.asc Normal file
View File

@@ -0,0 +1,11 @@
date Mon Mai 19 15:37:13.000 2014
base hex timestamps absolute
internal events logged
// version 8.5.0
Begin Triggerblock Mon Mai 19 15:37:13.690 2014
0.590000 1 539 Rx d 1 03 Length 108000 BitCount = 58 ID = 1337
0.619000 1 71x Rx d 1 42 Length 152000 BitCount = 80 ID = 113x
0.690000 1 539 Rx d 1 04 Length 106000 BitCount = 57 ID = 1337
0.690000 log trigger event
0.719000 1 71x Rx d 1 42 Length 152000 BitCount 80 ID 113x
End TriggerBlock

3540
tests/unit_tests/asc_format/asc_reader_test.asc Normal file
View File

File diff suppressed because it is too large Load Diff

512
tests/unit_tests/asc_format/asc_reader_test.cpp Normal file
View File

@@ -0,0 +1,512 @@
#include "../../include/gtest_custom.h"
#include "../../../global/ascformat/ascreader.cpp"
#include <iostream>
#include <fstream>
#include "../../../global/exec_dir_helper.h"
TEST(CAscReaderTest, ReadASCFile)
{
asc::CAscReader reader;
EXPECT_TRUE(reader.IsBOF());
EXPECT_TRUE(reader.IsEOF());
EXPECT_TRUE(reader.Read(GetExecDirectory() / "asc_reader_test.asc"));
EXPECT_TRUE(reader.IsBOF());
EXPECT_FALSE(reader.IsEOF());
}
TEST(CAscReaderTest, SingleSampleNavigation)
{
asc::CAscReader reader;
EXPECT_TRUE(reader.Read(GetExecDirectory() / "asc_reader_test.asc"));
// First value
EXPECT_TRUE(reader.IsBOF());
EXPECT_FALSE(reader.IsEOF());
auto prSample = reader.Get();
EXPECT_TRUE(prSample.second);
EXPECT_EQ(prSample.first.dTimestamp, 0.007096);
EXPECT_EQ(prSample.first.uiChannel, 1ul);
EXPECT_EQ(prSample.first.uiId, 0xb6ul);
EXPECT_FALSE(prSample.first.bExtended);
EXPECT_EQ(prSample.first.eDirection, asc::SCanMessage::EDirection::rx);
EXPECT_EQ(prSample.first.uiLength, 5ul);
EXPECT_EQ(prSample.first.rguiData[0], 0x06);
EXPECT_EQ(prSample.first.rguiData[1], 0x06);
EXPECT_EQ(prSample.first.rguiData[2], 0x80);
EXPECT_EQ(prSample.first.rguiData[3], 0x00);
EXPECT_EQ(prSample.first.rguiData[4], 0xc8);
EXPECT_EQ(prSample.first.rguiData[5], 0x00);
// Next value
++reader;
EXPECT_FALSE(reader.IsBOF());
EXPECT_FALSE(reader.IsEOF());
prSample = reader.Get();
EXPECT_TRUE(prSample.second);
EXPECT_EQ(prSample.first.dTimestamp, 0.007123);
EXPECT_EQ(prSample.first.uiChannel, 2ul);
EXPECT_EQ(prSample.first.uiId, 0x85ul);
EXPECT_FALSE(prSample.first.bExtended);
EXPECT_EQ(prSample.first.eDirection, asc::SCanMessage::EDirection::rx);
EXPECT_EQ(prSample.first.uiLength, 8ul);
EXPECT_EQ(prSample.first.rguiData[0], 0x00);
EXPECT_EQ(prSample.first.rguiData[1], 0x00);
EXPECT_EQ(prSample.first.rguiData[2], 0x00);
EXPECT_EQ(prSample.first.rguiData[3], 0x00);
EXPECT_EQ(prSample.first.rguiData[4], 0xff);
EXPECT_EQ(prSample.first.rguiData[5], 0xff);
EXPECT_EQ(prSample.first.rguiData[6], 0xf3);
EXPECT_EQ(prSample.first.rguiData[7], 0x1d);
EXPECT_EQ(prSample.first.rguiData[8], 0x00);
// Next value
++reader;
EXPECT_FALSE(reader.IsBOF());
EXPECT_FALSE(reader.IsEOF());
prSample = reader.Get();
EXPECT_TRUE(prSample.second);
EXPECT_EQ(prSample.first.dTimestamp, 0.007333);
EXPECT_EQ(prSample.first.uiChannel, 1ul);
EXPECT_EQ(prSample.first.uiId, 0x19eul);
EXPECT_FALSE(prSample.first.bExtended);
EXPECT_EQ(prSample.first.eDirection, asc::SCanMessage::EDirection::rx);
EXPECT_EQ(prSample.first.uiLength, 8ul);
EXPECT_EQ(prSample.first.rguiData[0], 0x00);
EXPECT_EQ(prSample.first.rguiData[1], 0xec);
EXPECT_EQ(prSample.first.rguiData[2], 0xef);
EXPECT_EQ(prSample.first.rguiData[3], 0xfc);
EXPECT_EQ(prSample.first.rguiData[4], 0xff);
EXPECT_EQ(prSample.first.rguiData[5], 0x0c);
EXPECT_EQ(prSample.first.rguiData[6], 0x00);
EXPECT_EQ(prSample.first.rguiData[7], 0x85);
EXPECT_EQ(prSample.first.rguiData[8], 0x00);
// Previous value
--reader;
EXPECT_FALSE(reader.IsBOF());
EXPECT_FALSE(reader.IsEOF());
prSample = reader.Get();
EXPECT_TRUE(prSample.second);
EXPECT_EQ(prSample.first.dTimestamp, 0.007123);
EXPECT_EQ(prSample.first.uiChannel, 2ul);
EXPECT_EQ(prSample.first.uiId, 0x85ul);
EXPECT_FALSE(prSample.first.bExtended);
EXPECT_EQ(prSample.first.eDirection, asc::SCanMessage::EDirection::rx);
EXPECT_EQ(prSample.first.uiLength, 8ul);
EXPECT_EQ(prSample.first.rguiData[0], 0x00);
EXPECT_EQ(prSample.first.rguiData[1], 0x00);
EXPECT_EQ(prSample.first.rguiData[2], 0x00);
EXPECT_EQ(prSample.first.rguiData[3], 0x00);
EXPECT_EQ(prSample.first.rguiData[4], 0xff);
EXPECT_EQ(prSample.first.rguiData[5], 0xff);
EXPECT_EQ(prSample.first.rguiData[6], 0xf3);
EXPECT_EQ(prSample.first.rguiData[7], 0x1d);
EXPECT_EQ(prSample.first.rguiData[8], 0x00);
// Previous value
--reader;
EXPECT_TRUE(reader.IsBOF());
EXPECT_FALSE(reader.IsEOF());
prSample = reader.Get();
EXPECT_TRUE(prSample.second);
EXPECT_EQ(prSample.first.dTimestamp, 0.007096);
EXPECT_EQ(prSample.first.uiChannel, 1ul);
EXPECT_EQ(prSample.first.uiId, 0xb6ul);
EXPECT_FALSE(prSample.first.bExtended);
EXPECT_EQ(prSample.first.eDirection, asc::SCanMessage::EDirection::rx);
EXPECT_EQ(prSample.first.uiLength, 5ul);
EXPECT_EQ(prSample.first.rguiData[0], 0x06);
EXPECT_EQ(prSample.first.rguiData[1], 0x06);
EXPECT_EQ(prSample.first.rguiData[2], 0x80);
EXPECT_EQ(prSample.first.rguiData[3], 0x00);
EXPECT_EQ(prSample.first.rguiData[4], 0xc8);
EXPECT_EQ(prSample.first.rguiData[5], 0x00);
// Jump to end
reader.JumpEnd();
EXPECT_FALSE(reader.IsBOF());
EXPECT_TRUE(reader.IsEOF());
prSample = reader.Get();
EXPECT_FALSE(prSample.second);
// Jump to begin
reader.JumpBegin();
EXPECT_TRUE(reader.IsBOF());
EXPECT_FALSE(reader.IsEOF());
prSample = reader.Get();
EXPECT_TRUE(prSample.second);
EXPECT_EQ(prSample.first.dTimestamp, 0.007096);
EXPECT_EQ(prSample.first.uiChannel, 1ul);
EXPECT_EQ(prSample.first.uiId, 0xb6ul);
EXPECT_FALSE(prSample.first.bExtended);
EXPECT_EQ(prSample.first.eDirection, asc::SCanMessage::EDirection::rx);
EXPECT_EQ(prSample.first.uiLength, 5ul);
EXPECT_EQ(prSample.first.rguiData[0], 0x06);
EXPECT_EQ(prSample.first.rguiData[1], 0x06);
EXPECT_EQ(prSample.first.rguiData[2], 0x80);
EXPECT_EQ(prSample.first.rguiData[3], 0x00);
EXPECT_EQ(prSample.first.rguiData[4], 0xc8);
EXPECT_EQ(prSample.first.rguiData[5], 0x00);
}
TEST(CAscReaderTest, NormalPlayback)
{
asc::CAscReader reader;
EXPECT_TRUE(reader.Read(GetExecDirectory() / "asc_reader_test.asc"));
// Do measurement
asc::SCanMessage sMsg{};
reader.StartPlayback([&](const asc::SCanMessage& rsMsg) { sMsg = rsMsg; }, false);
EXPECT_TRUE(reader.PlaybackRunning());
std::this_thread::sleep_for(std::chrono::milliseconds(250));
reader.StopPlayback();
// Last sent message is the one before the current message.
--reader;
auto prSample = reader.Get();
EXPECT_TRUE(prSample.second);
EXPECT_EQ(prSample.first.dTimestamp, sMsg.dTimestamp);
EXPECT_EQ(prSample.first.uiChannel, sMsg.uiChannel);
EXPECT_EQ(prSample.first.uiId, sMsg.uiId);
EXPECT_EQ(prSample.first.bExtended, sMsg.bExtended);
EXPECT_EQ(prSample.first.eDirection, sMsg.eDirection);
EXPECT_EQ(prSample.first.uiLength, sMsg.uiLength);
EXPECT_EQ(prSample.first.rguiData[0], sMsg.rguiData[0]);
EXPECT_EQ(prSample.first.rguiData[1], sMsg.rguiData[1]);
EXPECT_EQ(prSample.first.rguiData[2], sMsg.rguiData[2]);
EXPECT_EQ(prSample.first.rguiData[3], sMsg.rguiData[3]);
EXPECT_EQ(prSample.first.rguiData[4], sMsg.rguiData[4]);
EXPECT_EQ(prSample.first.rguiData[5], sMsg.rguiData[5]);
EXPECT_EQ(prSample.first.rguiData[6], sMsg.rguiData[6]);
EXPECT_EQ(prSample.first.rguiData[7], sMsg.rguiData[7]);
EXPECT_EQ(prSample.first.rguiData[8], sMsg.rguiData[8]);
// Time deviation
std::cout << "The current timestamp is " << sMsg.dTimestamp << " (should be somewhat more than 250ms)" << std::endl;
}
TEST(CAscReaderTest, PlaybackRestart)
{
asc::CAscReader reader;
EXPECT_TRUE(reader.Read(GetExecDirectory() / "asc_reader_test.asc"));
// Do first measurement
asc::SCanMessage sMsg1{};
reader.StartPlayback([&](const asc::SCanMessage& rsMsg) { sMsg1 = rsMsg; }, false);
EXPECT_TRUE(reader.PlaybackRunning());
std::this_thread::sleep_for(std::chrono::milliseconds(250));
reader.StopPlayback();
EXPECT_FALSE(reader.IsBOF());
EXPECT_FALSE(reader.IsEOF());
// Last sent message is the one before the current message.
--reader;
auto prSample = reader.Get();
EXPECT_TRUE(prSample.second);
EXPECT_EQ(prSample.first.dTimestamp, sMsg1.dTimestamp);
EXPECT_EQ(prSample.first.uiChannel, sMsg1.uiChannel);
EXPECT_EQ(prSample.first.uiId, sMsg1.uiId);
EXPECT_EQ(prSample.first.bExtended, sMsg1.bExtended);
EXPECT_EQ(prSample.first.eDirection, sMsg1.eDirection);
EXPECT_EQ(prSample.first.uiLength, sMsg1.uiLength);
EXPECT_EQ(prSample.first.rguiData[0], sMsg1.rguiData[0]);
EXPECT_EQ(prSample.first.rguiData[1], sMsg1.rguiData[1]);
EXPECT_EQ(prSample.first.rguiData[2], sMsg1.rguiData[2]);
EXPECT_EQ(prSample.first.rguiData[3], sMsg1.rguiData[3]);
EXPECT_EQ(prSample.first.rguiData[4], sMsg1.rguiData[4]);
EXPECT_EQ(prSample.first.rguiData[5], sMsg1.rguiData[5]);
EXPECT_EQ(prSample.first.rguiData[6], sMsg1.rguiData[6]);
EXPECT_EQ(prSample.first.rguiData[7], sMsg1.rguiData[7]);
EXPECT_EQ(prSample.first.rguiData[8], sMsg1.rguiData[8]);
// Do second measurement
asc::SCanMessage sMsg2{};
reader.StartPlayback([&](const asc::SCanMessage& rsMsg) { sMsg2 = rsMsg; }, false);
std::this_thread::sleep_for(std::chrono::milliseconds(250));
reader.StopPlayback();
// Last sent message is the one before the current message.
--reader;
prSample = reader.Get();
EXPECT_TRUE(prSample.second);
EXPECT_EQ(prSample.first.dTimestamp, sMsg2.dTimestamp);
EXPECT_EQ(prSample.first.uiChannel, sMsg2.uiChannel);
EXPECT_EQ(prSample.first.uiId, sMsg2.uiId);
EXPECT_EQ(prSample.first.bExtended, sMsg2.bExtended);
EXPECT_EQ(prSample.first.eDirection, sMsg2.eDirection);
EXPECT_EQ(prSample.first.uiLength, sMsg2.uiLength);
EXPECT_EQ(prSample.first.rguiData[0], sMsg2.rguiData[0]);
EXPECT_EQ(prSample.first.rguiData[1], sMsg2.rguiData[1]);
EXPECT_EQ(prSample.first.rguiData[2], sMsg2.rguiData[2]);
EXPECT_EQ(prSample.first.rguiData[3], sMsg2.rguiData[3]);
EXPECT_EQ(prSample.first.rguiData[4], sMsg2.rguiData[4]);
EXPECT_EQ(prSample.first.rguiData[5], sMsg2.rguiData[5]);
EXPECT_EQ(prSample.first.rguiData[6], sMsg2.rguiData[6]);
EXPECT_EQ(prSample.first.rguiData[7], sMsg2.rguiData[7]);
EXPECT_EQ(prSample.first.rguiData[8], sMsg2.rguiData[8]);
// The time of message 1 should be less than the time of message 2.
EXPECT_LT(sMsg1.dTimestamp, sMsg2.dTimestamp);
}
TEST(CAscReaderTest, PlaybackReset)
{
asc::CAscReader reader;
EXPECT_TRUE(reader.Read(GetExecDirectory() / "asc_reader_test.asc"));
// Do first measurement
asc::SCanMessage sMsg1{};
reader.StartPlayback([&](const asc::SCanMessage& rsMsg) { sMsg1 = rsMsg; }, false);
EXPECT_TRUE(reader.PlaybackRunning());
std::this_thread::sleep_for(std::chrono::milliseconds(250));
reader.StopPlayback();
EXPECT_FALSE(reader.IsBOF());
EXPECT_FALSE(reader.IsEOF());
// Last sent message is the one before the current message.
--reader;
auto prSample = reader.Get();
EXPECT_TRUE(prSample.second);
EXPECT_EQ(prSample.first.dTimestamp, sMsg1.dTimestamp);
EXPECT_EQ(prSample.first.uiChannel, sMsg1.uiChannel);
EXPECT_EQ(prSample.first.uiId, sMsg1.uiId);
EXPECT_EQ(prSample.first.bExtended, sMsg1.bExtended);
EXPECT_EQ(prSample.first.eDirection, sMsg1.eDirection);
EXPECT_EQ(prSample.first.uiLength, sMsg1.uiLength);
EXPECT_EQ(prSample.first.rguiData[0], sMsg1.rguiData[0]);
EXPECT_EQ(prSample.first.rguiData[1], sMsg1.rguiData[1]);
EXPECT_EQ(prSample.first.rguiData[2], sMsg1.rguiData[2]);
EXPECT_EQ(prSample.first.rguiData[3], sMsg1.rguiData[3]);
EXPECT_EQ(prSample.first.rguiData[4], sMsg1.rguiData[4]);
EXPECT_EQ(prSample.first.rguiData[5], sMsg1.rguiData[5]);
EXPECT_EQ(prSample.first.rguiData[6], sMsg1.rguiData[6]);
EXPECT_EQ(prSample.first.rguiData[7], sMsg1.rguiData[7]);
EXPECT_EQ(prSample.first.rguiData[8], sMsg1.rguiData[8]);
// Do second measurement
asc::SCanMessage sMsg2{};
reader.ResetPlayback();
reader.StartPlayback([&](const asc::SCanMessage& rsMsg) { sMsg2 = rsMsg; }, false);
std::this_thread::sleep_for(std::chrono::milliseconds(125));
reader.StopPlayback();
// Last sent message is the one before the current message.
--reader;
prSample = reader.Get();
EXPECT_TRUE(prSample.second);
EXPECT_EQ(prSample.first.dTimestamp, sMsg2.dTimestamp);
EXPECT_EQ(prSample.first.uiChannel, sMsg2.uiChannel);
EXPECT_EQ(prSample.first.uiId, sMsg2.uiId);
EXPECT_EQ(prSample.first.bExtended, sMsg2.bExtended);
EXPECT_EQ(prSample.first.eDirection, sMsg2.eDirection);
EXPECT_EQ(prSample.first.uiLength, sMsg2.uiLength);
EXPECT_EQ(prSample.first.rguiData[0], sMsg2.rguiData[0]);
EXPECT_EQ(prSample.first.rguiData[1], sMsg2.rguiData[1]);
EXPECT_EQ(prSample.first.rguiData[2], sMsg2.rguiData[2]);
EXPECT_EQ(prSample.first.rguiData[3], sMsg2.rguiData[3]);
EXPECT_EQ(prSample.first.rguiData[4], sMsg2.rguiData[4]);
EXPECT_EQ(prSample.first.rguiData[5], sMsg2.rguiData[5]);
EXPECT_EQ(prSample.first.rguiData[6], sMsg2.rguiData[6]);
EXPECT_EQ(prSample.first.rguiData[7], sMsg2.rguiData[7]);
EXPECT_EQ(prSample.first.rguiData[8], sMsg2.rguiData[8]);
// The time of message 1 should be more than the time of message 2.
EXPECT_GT(sMsg1.dTimestamp, sMsg2.dTimestamp);
}
TEST(CAscReaderTest, FinishPlayback)
{
asc::CAscReader reader;
EXPECT_TRUE(reader.Read(GetExecDirectory() / "asc_reader_test.asc"));
// Do measurement
reader.JumpEnd();
for (size_t n = 0; n < 150; n++)
--reader;
asc::SCanMessage sMsg{};
reader.StartPlayback([&](const asc::SCanMessage& rsMsg) { sMsg = rsMsg; }, false);
EXPECT_TRUE(reader.PlaybackRunning());
std::this_thread::sleep_for(std::chrono::milliseconds(250));
EXPECT_FALSE(reader.PlaybackRunning());
reader.StopPlayback(); // Just in case...
EXPECT_TRUE(reader.IsEOF());
// Last sent message is the one before the current message.
--reader;
auto prSample = reader.Get();
EXPECT_TRUE(prSample.second);
EXPECT_EQ(prSample.first.dTimestamp, sMsg.dTimestamp);
EXPECT_EQ(prSample.first.uiChannel, sMsg.uiChannel);
EXPECT_EQ(prSample.first.uiId, sMsg.uiId);
EXPECT_EQ(prSample.first.bExtended, sMsg.bExtended);
EXPECT_EQ(prSample.first.eDirection, sMsg.eDirection);
EXPECT_EQ(prSample.first.uiLength, sMsg.uiLength);
EXPECT_EQ(prSample.first.rguiData[0], sMsg.rguiData[0]);
EXPECT_EQ(prSample.first.rguiData[1], sMsg.rguiData[1]);
EXPECT_EQ(prSample.first.rguiData[2], sMsg.rguiData[2]);
EXPECT_EQ(prSample.first.rguiData[3], sMsg.rguiData[3]);
EXPECT_EQ(prSample.first.rguiData[4], sMsg.rguiData[4]);
EXPECT_EQ(prSample.first.rguiData[5], sMsg.rguiData[5]);
EXPECT_EQ(prSample.first.rguiData[6], sMsg.rguiData[6]);
EXPECT_EQ(prSample.first.rguiData[7], sMsg.rguiData[7]);
EXPECT_EQ(prSample.first.rguiData[8], sMsg.rguiData[8]);
}
TEST(CAscReaderTest, RepeatPlayback)
{
asc::CAscReader reader;
EXPECT_TRUE(reader.Read(GetExecDirectory() / "asc_reader_test.asc"));
// Do a measurement startin at the end
reader.JumpEnd();
for (size_t n = 0; n < 20; n++)
--reader;
asc::SCanMessage sMsgStart = reader.Get().first;
asc::SCanMessage sMsgCurrent{};
reader.StartPlayback([&](const asc::SCanMessage& rsMsg) { sMsgCurrent = rsMsg; }, true);
EXPECT_TRUE(reader.PlaybackRunning());
std::this_thread::sleep_for(std::chrono::milliseconds(250));
reader.StopPlayback();
// Last sent message is the one before the current message.
--reader;
auto prSample = reader.Get();
EXPECT_TRUE(prSample.second);
EXPECT_EQ(prSample.first.dTimestamp, sMsgCurrent.dTimestamp);
EXPECT_EQ(prSample.first.uiChannel, sMsgCurrent.uiChannel);
EXPECT_EQ(prSample.first.uiId, sMsgCurrent.uiId);
EXPECT_EQ(prSample.first.bExtended, sMsgCurrent.bExtended);
EXPECT_EQ(prSample.first.eDirection, sMsgCurrent.eDirection);
EXPECT_EQ(prSample.first.uiLength, sMsgCurrent.uiLength);
EXPECT_EQ(prSample.first.rguiData[0], sMsgCurrent.rguiData[0]);
EXPECT_EQ(prSample.first.rguiData[1], sMsgCurrent.rguiData[1]);
EXPECT_EQ(prSample.first.rguiData[2], sMsgCurrent.rguiData[2]);
EXPECT_EQ(prSample.first.rguiData[3], sMsgCurrent.rguiData[3]);
EXPECT_EQ(prSample.first.rguiData[4], sMsgCurrent.rguiData[4]);
EXPECT_EQ(prSample.first.rguiData[5], sMsgCurrent.rguiData[5]);
EXPECT_EQ(prSample.first.rguiData[6], sMsgCurrent.rguiData[6]);
EXPECT_EQ(prSample.first.rguiData[7], sMsgCurrent.rguiData[7]);
EXPECT_EQ(prSample.first.rguiData[8], sMsgCurrent.rguiData[8]);
// The time of start message should be more than the time of the current message.
EXPECT_GT(sMsgStart.dTimestamp, sMsgCurrent.dTimestamp);
}
TEST(CAscReaderTest, RepeatPlaybackCheckLoopExecution)
{
asc::CAscReader readerOneLoop;
EXPECT_TRUE(readerOneLoop.Read(GetExecDirectory() / "asc_reader_timing_test.asc"));
asc::SCanMessage sMsgOneLoop{};
readerOneLoop.StartPlayback([&](const asc::SCanMessage& rsMsg) { sMsgOneLoop = rsMsg; }, false);
EXPECT_TRUE(readerOneLoop.PlaybackRunning());
std::this_thread::sleep_for(std::chrono::milliseconds(400));
readerOneLoop.StopPlayback();
EXPECT_TRUE(readerOneLoop.GetLoopCount() == 1);
asc::CAscReader reader;
EXPECT_TRUE(reader.Read(GetExecDirectory() / "asc_reader_timing_test.asc"));
asc::SCanMessage sMsg{};
reader.StartPlayback([&](const asc::SCanMessage& rsMsg) { sMsg = rsMsg; }, true);
EXPECT_TRUE(reader.PlaybackRunning());
std::this_thread::sleep_for(std::chrono::milliseconds(400));
reader.StopPlayback();
// Second loop must run in the same speed, therfore LoopCount = 2, not mmore
EXPECT_TRUE((readerOneLoop.GetLoopCount() + 1) == reader.GetLoopCount());
}
TEST(CAscReaderTest, ExtendedId)
{
asc::CAscReader reader;
EXPECT_TRUE(reader.Read(GetExecDirectory() / "asc_reader_ext_id_test.asc"));
// First value
EXPECT_TRUE(reader.IsBOF());
EXPECT_FALSE(reader.IsEOF());
auto prSample = reader.Get();
EXPECT_TRUE(prSample.second);
EXPECT_EQ(prSample.first.dTimestamp, 0.590000);
EXPECT_EQ(prSample.first.uiChannel, 1ul);
EXPECT_EQ(prSample.first.uiId, 0x539ul);
EXPECT_FALSE(prSample.first.bExtended);
EXPECT_EQ(prSample.first.eDirection, asc::SCanMessage::EDirection::rx);
EXPECT_EQ(prSample.first.uiLength, 1ul);
EXPECT_EQ(prSample.first.rguiData[0], 0x03);
EXPECT_EQ(prSample.first.rguiData[1], 0x00);
// Next value
++reader;
EXPECT_FALSE(reader.IsBOF());
EXPECT_FALSE(reader.IsEOF());
prSample = reader.Get();
EXPECT_TRUE(prSample.second);
EXPECT_EQ(prSample.first.dTimestamp, 0.619000);
EXPECT_EQ(prSample.first.uiChannel, 1ul);
EXPECT_EQ(prSample.first.uiId, 0x71ul);
EXPECT_TRUE(prSample.first.bExtended);
EXPECT_EQ(prSample.first.eDirection, asc::SCanMessage::EDirection::rx);
EXPECT_EQ(prSample.first.uiLength, 1ul);
EXPECT_EQ(prSample.first.rguiData[0], 0x42);
EXPECT_EQ(prSample.first.rguiData[1], 0x00);
}
TEST(CAscReaderTest, CAN_FD)
{
asc::CAscReader reader;
EXPECT_TRUE(reader.Read(GetExecDirectory() / "asc_reader_canfd_test.asc"));
EXPECT_TRUE(reader.IsBOF());
EXPECT_FALSE(reader.IsEOF());
// Skip two values
++reader;
++reader;
// third value
EXPECT_FALSE(reader.IsBOF());
EXPECT_FALSE(reader.IsEOF());
auto prSample = reader.Get();
EXPECT_TRUE(prSample.second);
EXPECT_EQ(prSample.first.dTimestamp, 3.36716);
EXPECT_EQ(prSample.first.uiChannel, 1ul);
EXPECT_EQ(prSample.first.uiId, 0xB4323ul);
EXPECT_TRUE(prSample.first.bExtended);
EXPECT_FALSE(prSample.first.bCanFd);
EXPECT_EQ(prSample.first.eDirection, asc::SCanMessage::EDirection::rx);
EXPECT_EQ(prSample.first.uiLength, 8ul);
EXPECT_EQ(prSample.first.rguiData[0], 0x73);
EXPECT_EQ(prSample.first.rguiData[1], 0xe5);
EXPECT_EQ(prSample.first.rguiData[2], 0xe9);
EXPECT_EQ(prSample.first.rguiData[3], 0x24);
EXPECT_EQ(prSample.first.rguiData[4], 0xe2);
EXPECT_EQ(prSample.first.rguiData[5], 0x00);
EXPECT_EQ(prSample.first.rguiData[6], 0x00);
EXPECT_EQ(prSample.first.rguiData[7], 0x00);
EXPECT_EQ(prSample.first.rguiData[8], 0x00);
// Next value
++reader;
EXPECT_FALSE(reader.IsBOF());
EXPECT_FALSE(reader.IsEOF());
prSample = reader.Get();
EXPECT_TRUE(prSample.second);
EXPECT_EQ(prSample.first.dTimestamp, 3.36722);
EXPECT_EQ(prSample.first.uiChannel, 15ul);
EXPECT_EQ(prSample.first.uiId, 0x86ul);
EXPECT_FALSE(prSample.first.bExtended);
EXPECT_TRUE(prSample.first.bCanFd);
EXPECT_EQ(prSample.first.eDirection, asc::SCanMessage::EDirection::rx);
EXPECT_EQ(prSample.first.uiLength, 8ul);
EXPECT_EQ(prSample.first.rguiData[0], 0x48);
EXPECT_EQ(prSample.first.rguiData[1], 0x75);
EXPECT_EQ(prSample.first.rguiData[2], 0x6d);
EXPECT_EQ(prSample.first.rguiData[3], 0x61);
EXPECT_EQ(prSample.first.rguiData[4], 0x6e);
EXPECT_EQ(prSample.first.rguiData[5], 0x69);
EXPECT_EQ(prSample.first.rguiData[6], 0x73);
EXPECT_EQ(prSample.first.rguiData[7], 0x6d);
EXPECT_EQ(prSample.first.rguiData[8], 0x00);
}

15
tests/unit_tests/asc_format/asc_reader_timing_test.asc Normal file
View File

@@ -0,0 +1,15 @@
date Wed Jul 28 06:47:19 pm 2010
base hex timestamps absolute
internal events logged
// version 7.0.1
Begin Triggerblock Wed Jul 28 06:47:19 pm 2010
0.000000 Start of measurement
0.005502 CAN 1 Status:chip status error active
0.005675 CAN 2 Status:chip status error active
0.007096 1 B6 Rx d 5 06 06 80 00 C8
0.007123 2 85 Rx d 8 00 00 00 00 FF FF F3 1D
0.007333 1 19E Rx d 8 00 EC EF FC FF 0C 00 85
0.110300 2 D8 Rx d 8 01 80 00 FF F8 7F 05 34
0.210421 1 A8 Rx d 8 EE 45 01 00 00 00 00 00
0.310541 2 E3 Rx d 8 00 80 10 00 FE 7F 05 24
End TriggerBlock

224
tests/unit_tests/asc_format/asc_writer_test.cpp Normal file
View File

@@ -0,0 +1,224 @@
#include "../../include/gtest_custom.h"
#include "../../../global/ascformat/ascwriter.cpp"
#include <iostream>
#include <fstream>
#include "../../../global/exec_dir_helper.h"
#include <support/sdv_test_macro.h>
TEST(CAscWriterTest, AddSamplesDirect)
{
asc::CAscReader readerGroundThruth;
EXPECT_TRUE(readerGroundThruth.Read(GetExecDirectory() / "asc_reader_test.asc"));
// Add 20 samples
asc::CAscWriter writer;
for (size_t n = 0; n < 20; n++)
{
auto prSample = readerGroundThruth.Get();
EXPECT_TRUE(prSample.second);
writer.AddSample(prSample.first);
++readerGroundThruth;
}
// Write the samples
writer.Write(GetExecDirectory() / "asc_writer_test.asc");
// Read the samples
asc::CAscReader readerGenerate;
EXPECT_TRUE(readerGenerate.Read(GetExecDirectory() / "asc_writer_test.asc"));
// Check whether the 20 samples correspond to the original samples
readerGroundThruth.JumpBegin();
while (!readerGenerate.IsEOF())
{
auto prSampleGroundTruth = readerGroundThruth.Get();
EXPECT_TRUE(prSampleGroundTruth.second);
auto prSampleGenerated = readerGenerate.Get();
EXPECT_EQ(prSampleGroundTruth.first.dTimestamp, prSampleGenerated.first.dTimestamp);
EXPECT_EQ(prSampleGroundTruth.first.uiChannel, prSampleGenerated.first.uiChannel);
EXPECT_EQ(prSampleGroundTruth.first.uiId, prSampleGenerated.first.uiId);
EXPECT_EQ(prSampleGroundTruth.first.bExtended, prSampleGenerated.first.bExtended);
EXPECT_EQ(prSampleGroundTruth.first.eDirection, prSampleGenerated.first.eDirection);
EXPECT_EQ(prSampleGroundTruth.first.uiLength, prSampleGenerated.first.uiLength);
for (size_t nIndex = 0; nIndex < 64; nIndex++)
EXPECT_EQ(prSampleGroundTruth.first.rguiData[nIndex], prSampleGenerated.first.rguiData[nIndex]);
++readerGroundThruth;
++readerGenerate;
}
}
TEST(CAscWriterTest, AddTimedSamples)
{
asc::CAscReader readerGroundThruth;
EXPECT_TRUE(readerGroundThruth.Read(GetExecDirectory() / "asc_reader_test.asc"));
// Skip 100 samples
for (size_t n = 0; n < 100; n++)
++readerGroundThruth;
EXPECT_FALSE(readerGroundThruth.IsBOF());
EXPECT_FALSE(readerGroundThruth.IsEOF());
// Start the timer
asc::CAscWriter writer;
writer.StartTimer();
// Add 250ms of samples
readerGroundThruth.StartPlayback([&](const asc::SCanMessage& rsSample)
{
asc::SCanMessage sSampleCopy(rsSample);
sSampleCopy.dTimestamp = 0.000;
writer.AddSample(sSampleCopy);
}, false);
std::this_thread::sleep_for(std::chrono::milliseconds(250));
readerGroundThruth.StopPlayback();
// Write the samples
writer.Write(GetExecDirectory() / "asc_writer_test.asc");
// Read the samples
asc::CAscReader readerGenerate;
EXPECT_TRUE(readerGenerate.Read(GetExecDirectory() / "asc_writer_test.asc"));
// Start at the 101st sample
readerGroundThruth.JumpBegin();
for (size_t n = 0; n < 100; n++)
++readerGroundThruth;
auto fnRound = [](double dTimestamp) { return std::round(dTimestamp * 1000.0) / 1000.0; };
// Check whether the samples correspond to the original samples, except for the generated timestamp
double dLastTSGroundThruth = fnRound(readerGroundThruth.Get().first.dTimestamp);
double dLastTSGenerated = fnRound(readerGenerate.Get().first.dTimestamp);
++readerGroundThruth;
++readerGenerate;
while (!readerGenerate.IsEOF())
{
auto prSampleGroundTruth = readerGroundThruth.Get();
EXPECT_TRUE(prSampleGroundTruth.second);
auto prSampleGenerated = readerGenerate.Get();
// Delta timestamp should not differ more than +/- 2 ms.
double dDeltaTSGroundThruth = fnRound(readerGroundThruth.Get().first.dTimestamp) - dLastTSGroundThruth;
dLastTSGroundThruth = fnRound(readerGroundThruth.Get().first.dTimestamp);
double dDeltaTSGenerated = fnRound(readerGenerate.Get().first.dTimestamp) - dLastTSGenerated;
dLastTSGenerated = fnRound(readerGenerate.Get().first.dTimestamp);
if (dDeltaTSGenerated < dDeltaTSGroundThruth - 0.002)
{
if(SDV_IS_RUNNING_TESTS_WITH_CMAKE_BUILD)
SDV_TIMING_EXPECT_GE(dDeltaTSGenerated, dDeltaTSGroundThruth - 0.002, sdv::TEST::WarningLevel::WARNING_REDUCED);
else
SDV_TIMING_EXPECT_GE(dDeltaTSGenerated, dDeltaTSGroundThruth - 0.002, sdv::TEST::WarningLevel::WARNING_ENABLED);
}
if (dDeltaTSGenerated > dDeltaTSGroundThruth + 0.002)
{
if(SDV_IS_RUNNING_TESTS_WITH_CMAKE_BUILD)
SDV_TIMING_EXPECT_LE(dDeltaTSGenerated, dDeltaTSGroundThruth + 0.002, sdv::TEST::WarningLevel::WARNING_REDUCED);
else
SDV_TIMING_EXPECT_LE(dDeltaTSGenerated, dDeltaTSGroundThruth + 0.002, sdv::TEST::WarningLevel::WARNING_ENABLED);
}
std::cout << "TIMING: Expected generated timestamp <= ground truth + 2ms (generated=" << dDeltaTSGenerated << "ms, ground truth=" << dDeltaTSGroundThruth << ")..." << std::endl;
EXPECT_EQ(prSampleGroundTruth.first.uiChannel, prSampleGenerated.first.uiChannel);
EXPECT_EQ(prSampleGroundTruth.first.uiId, prSampleGenerated.first.uiId);
EXPECT_EQ(prSampleGroundTruth.first.bExtended, prSampleGenerated.first.bExtended);
EXPECT_EQ(prSampleGroundTruth.first.eDirection, prSampleGenerated.first.eDirection);
EXPECT_EQ(prSampleGroundTruth.first.uiLength, prSampleGenerated.first.uiLength);
for (size_t nIndex = 0; nIndex < 64; nIndex++)
EXPECT_EQ(prSampleGroundTruth.first.rguiData[nIndex], prSampleGenerated.first.rguiData[nIndex]);
++readerGroundThruth;
++readerGenerate;
}
}
TEST(CAscWriterTest, ExtendedID)
{
asc::CAscReader readerGroundThruth;
SDV_EXPECT_TRUE(readerGroundThruth.Read(GetExecDirectory() / "asc_reader_ext_id_test.asc"), sdv::TEST::WarningLevel::WARNING_REDUCED);
// Add all samples
asc::CAscWriter writer;
while (!readerGroundThruth.IsEOF())
{
auto prSample = readerGroundThruth.Get();
EXPECT_TRUE(prSample.second);
writer.AddSample(prSample.first);
++readerGroundThruth;
}
// Write the samples
writer.Write(GetExecDirectory() / "asc_writer_test.asc");
// Read the samples
asc::CAscReader readerGenerate;
EXPECT_TRUE(readerGenerate.Read(GetExecDirectory() / "asc_writer_test.asc"));
// Check whether the samples correspond to the original samples
readerGroundThruth.JumpBegin();
while (!readerGenerate.IsEOF())
{
auto prSampleGroundTruth = readerGroundThruth.Get();
EXPECT_TRUE(prSampleGroundTruth.second);
auto prSampleGenerated = readerGenerate.Get();
EXPECT_EQ(prSampleGroundTruth.first.dTimestamp, prSampleGenerated.first.dTimestamp);
EXPECT_EQ(prSampleGroundTruth.first.uiChannel, prSampleGenerated.first.uiChannel);
EXPECT_EQ(prSampleGroundTruth.first.uiId, prSampleGenerated.first.uiId);
EXPECT_EQ(prSampleGroundTruth.first.bExtended, prSampleGenerated.first.bExtended);
EXPECT_EQ(prSampleGroundTruth.first.eDirection, prSampleGenerated.first.eDirection);
EXPECT_EQ(prSampleGroundTruth.first.uiLength, prSampleGenerated.first.uiLength);
for (size_t nIndex = 0; nIndex < 64; nIndex++)
EXPECT_EQ(prSampleGroundTruth.first.rguiData[nIndex], prSampleGenerated.first.rguiData[nIndex]);
++readerGroundThruth;
++readerGenerate;
}
}
TEST(CAscWriterTest, CAN_FD)
{
asc::CAscReader readerGroundThruth;
EXPECT_TRUE(readerGroundThruth.Read(GetExecDirectory() / "asc_reader_canfd_test.asc"));
// Add all samples
asc::CAscWriter writer;
while (!readerGroundThruth.IsEOF())
{
auto prSample = readerGroundThruth.Get();
EXPECT_TRUE(prSample.second);
writer.AddSample(prSample.first);
++readerGroundThruth;
}
// Write the samples
writer.Write(GetExecDirectory() / "asc_writer_test.asc");
// Read the samples
asc::CAscReader readerGenerate;
EXPECT_TRUE(readerGenerate.Read(GetExecDirectory() / "asc_writer_test.asc"));
// Check whether the samples correspond to the original samples
readerGroundThruth.JumpBegin();
while (!readerGenerate.IsEOF())
{
auto prSampleGroundTruth = readerGroundThruth.Get();
EXPECT_TRUE(prSampleGroundTruth.second);
auto prSampleGenerated = readerGenerate.Get();
EXPECT_EQ(prSampleGroundTruth.first.dTimestamp, prSampleGenerated.first.dTimestamp);
EXPECT_EQ(prSampleGroundTruth.first.uiChannel, prSampleGenerated.first.uiChannel);
EXPECT_EQ(prSampleGroundTruth.first.uiId, prSampleGenerated.first.uiId);
EXPECT_EQ(prSampleGroundTruth.first.bExtended, prSampleGenerated.first.bExtended);
EXPECT_EQ(prSampleGroundTruth.first.bCanFd, prSampleGenerated.first.bCanFd);
EXPECT_EQ(prSampleGroundTruth.first.eDirection, prSampleGenerated.first.eDirection);
EXPECT_EQ(prSampleGroundTruth.first.uiLength, prSampleGenerated.first.uiLength);
for (size_t nIndex = 0; nIndex < 64; nIndex++)
EXPECT_EQ(prSampleGroundTruth.first.rguiData[nIndex], prSampleGenerated.first.rguiData[nIndex]);
++readerGroundThruth;
++readerGenerate;
}
}

19
tests/unit_tests/asc_format/main.cpp Normal file
View File

@@ -0,0 +1,19 @@
#include <gtest/gtest.h>
#include "../../../global/process_watchdog.h"
#include "../../../global/localmemmgr.h"
/**
* @brief Main function
*/
#if defined(_WIN32) && defined(_UNICODE)
extern "C" int wmain(int argc, wchar_t* argv[])
#else
extern "C" int main(int argc, char* argv[])
#endif
{
CProcessWatchdog watchdog;
CLocalMemMgr memmgr;
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}