Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-06-23 01:21:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

[datalog] Translate unit tests to catch2 (#9002)

Browse Source
This commit is contained in:
Peter Johnson
2026-06-21 13:51:49 -07:00
committed by GitHub
parent 3d6df4a50e
commit 7dcb70cfcd
6 changed files with 247 additions and 214 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
datalog/BUILD.bazel
View File

@@ -148,7 +148,7 @@ cc_test(
],
deps = [
":datalog",
"//thirdparty/googletest",
"//thirdparty/catch2",
"//wpiutil:wpiutil-testlib",
],
)

4
datalog/CMakeLists.txt
View File

@@ -40,8 +40,8 @@ if(WITH_TESTS)
add_library(datalog_testlib INTERFACE ${datalog_test_src})
target_include_directories(datalog_testlib INTERFACE src/test/native/include)
wpilib_add_test(datalog src/test/native/cpp)
target_link_libraries(datalog_test datalog googletest datalog_testlib wpiutil)
wpilib_add_test_catch2(datalog src/test/native/cpp)
target_link_libraries(datalog_test datalog datalog_testlib wpiutil)
if(MSVC)
target_compile_options(datalog_test PRIVATE /utf-8)
endif()

1
datalog/build.gradle
View File

@@ -6,6 +6,7 @@ ext {
nativeName = 'datalog'
devMain = 'org.wpilib.datalog.DevMain'
nativeTestSuiteName = "${nativeName}Catch2Test"
}
apply from: "${rootDir}/shared/jni/setupBuild.gradle"

421
datalog/src/test/native/cpp/DataLogTest.cpp
View File

@@ -7,7 +7,7 @@
#include <string>
#include <vector>
#include <gtest/gtest.h>
#include <catch2/catch_test_macros.hpp>
#include "wpi/datalog/DataLogWriter.hpp"
#include "wpi/util/Logger.hpp"
@@ -127,7 +127,7 @@ static_assert(wpi::util::StructSerializable<ThingC>);
static_assert(wpi::util::StructSerializable<ThingC, Info1>);
static_assert(wpi::util::StructSerializable<ThingC, Info2>);
class DataLogTest : public ::testing::Test {
class DataLogTest {
public:
wpi::util::Logger msglog;
std::vector<uint8_t> data;
@@ -135,380 +135,405 @@ class DataLogTest : public ::testing::Test {
msglog, std::make_unique<wpi::util::raw_uvector_ostream>(data)};
};
TEST_F(DataLogTest, SimpleInt) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest SimpleInt", "[datalog][data-log]") {
int entry = log.Start("test", "int64", "", 1);
log.AppendInteger(entry, 1, 2);
log.Flush();
ASSERT_EQ(data.size(), 54u);
REQUIRE(data.size() == 54u);
}
TEST_F(DataLogTest, BooleanAppend) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest BooleanAppend",
"[datalog][data-log]") {
wpi::log::BooleanLogEntry entry{log, "a", 5};
entry.Append(false, 7);
log.Flush();
ASSERT_EQ(data.size(), 46u);
REQUIRE(data.size() == 46u);
}
TEST_F(DataLogTest, BooleanUpdate) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest BooleanUpdate",
"[datalog][data-log]") {
wpi::log::BooleanLogEntry entry{log, "a", 5};
ASSERT_FALSE(entry.GetLastValue().has_value());
REQUIRE_FALSE(entry.GetLastValue().has_value());
entry.Update(false, 7);
log.Flush();
ASSERT_EQ(data.size(), 46u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), false);
REQUIRE(data.size() == 46u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == false);
entry.Update(false, 8);
log.Flush();
ASSERT_EQ(data.size(), 46u);
REQUIRE(data.size() == 46u);
entry.Update(true, 9);
log.Flush();
ASSERT_EQ(data.size(), 51u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), true);
REQUIRE(data.size() == 51u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == true);
}
TEST_F(DataLogTest, IntegerAppend) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest IntegerAppend",
"[datalog][data-log]") {
wpi::log::IntegerLogEntry entry{log, "a", 5};
entry.Append(5, 7);
log.Flush();
ASSERT_EQ(data.size(), 51u);
REQUIRE(data.size() == 51u);
}
TEST_F(DataLogTest, IntegerUpdate) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest IntegerUpdate",
"[datalog][data-log]") {
wpi::log::IntegerLogEntry entry{log, "a", 5};
ASSERT_FALSE(entry.GetLastValue().has_value());
REQUIRE_FALSE(entry.GetLastValue().has_value());
entry.Update(0, 7);
log.Flush();
ASSERT_EQ(data.size(), 51u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), 0);
REQUIRE(data.size() == 51u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == 0);
entry.Update(0, 8);
log.Flush();
ASSERT_EQ(data.size(), 51u);
REQUIRE(data.size() == 51u);
entry.Update(2, 9);
log.Flush();
ASSERT_EQ(data.size(), 63u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), 2);
REQUIRE(data.size() == 63u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == 2);
}
TEST_F(DataLogTest, FloatAppend) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest FloatAppend",
"[datalog][data-log]") {
wpi::log::FloatLogEntry entry{log, "a", 5};
entry.Append(5.0, 7);
log.Flush();
ASSERT_EQ(data.size(), 47u);
REQUIRE(data.size() == 47u);
}
TEST_F(DataLogTest, FloatUpdate) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest FloatUpdate",
"[datalog][data-log]") {
wpi::log::FloatLogEntry entry{log, "a", 5};
ASSERT_FALSE(entry.GetLastValue().has_value());
REQUIRE_FALSE(entry.GetLastValue().has_value());
entry.Update(0.0f, 7);
log.Flush();
ASSERT_EQ(data.size(), 47u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), 0.0f);
REQUIRE(data.size() == 47u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == 0.0f);
entry.Update(0.0f, 8);
log.Flush();
ASSERT_EQ(data.size(), 47u);
REQUIRE(data.size() == 47u);
entry.Update(0.1f, 9);
log.Flush();
ASSERT_EQ(data.size(), 55u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), 0.1f);
REQUIRE(data.size() == 55u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == 0.1f);
}
TEST_F(DataLogTest, DoubleAppend) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest DoubleAppend",
"[datalog][data-log]") {
wpi::log::DoubleLogEntry entry{log, "a", 5};
entry.Append(5.0, 7);
log.Flush();
ASSERT_EQ(data.size(), 52u);
REQUIRE(data.size() == 52u);
}
TEST_F(DataLogTest, DoubleUpdate) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest DoubleUpdate",
"[datalog][data-log]") {
wpi::log::DoubleLogEntry entry{log, "a", 5};
ASSERT_FALSE(entry.GetLastValue().has_value());
REQUIRE_FALSE(entry.GetLastValue().has_value());
entry.Update(0.0, 7);
log.Flush();
ASSERT_EQ(data.size(), 52u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), 0.0);
REQUIRE(data.size() == 52u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == 0.0);
entry.Update(0.0, 8);
log.Flush();
ASSERT_EQ(data.size(), 52u);
REQUIRE(data.size() == 52u);
entry.Update(0.1, 9);
log.Flush();
ASSERT_EQ(data.size(), 64u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), 0.1);
REQUIRE(data.size() == 64u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == 0.1);
}
TEST_F(DataLogTest, StringAppend) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest StringAppend",
"[datalog][data-log]") {
wpi::log::StringLogEntry entry{log, "a", 5};
entry.Append("x", 7);
log.Flush();
ASSERT_EQ(data.size(), 45u);
REQUIRE(data.size() == 45u);
}
TEST_F(DataLogTest, StringUpdate) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest StringUpdate",
"[datalog][data-log]") {
wpi::log::StringLogEntry entry{log, "a", 5};
ASSERT_FALSE(entry.HasLastValue());
REQUIRE_FALSE(entry.HasLastValue());
entry.Update("x", 7);
log.Flush();
ASSERT_EQ(data.size(), 45u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), "x");
REQUIRE(data.size() == 45u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == "x");
entry.Update("x", 8);
log.Flush();
ASSERT_EQ(data.size(), 45u);
REQUIRE(data.size() == 45u);
entry.Update("y", 9);
log.Flush();
ASSERT_EQ(data.size(), 50u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), "y");
REQUIRE(data.size() == 50u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == "y");
entry.Update("yy", 10);
log.Flush();
ASSERT_EQ(data.size(), 56u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), "yy");
REQUIRE(data.size() == 56u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == "yy");
entry.Update("", 11);
log.Flush();
ASSERT_EQ(data.size(), 60u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), "");
REQUIRE(data.size() == 60u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == "");
}
TEST_F(DataLogTest, RawAppend) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest RawAppend", "[datalog][data-log]") {
wpi::log::RawLogEntry entry{log, "a", 5};
entry.Append({{5}}, 7);
log.Flush();
ASSERT_EQ(data.size(), 42u);
REQUIRE(data.size() == 42u);
}
TEST_F(DataLogTest, RawUpdate) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest RawUpdate", "[datalog][data-log]") {
wpi::log::RawLogEntry entry{log, "a", 5};
ASSERT_FALSE(entry.HasLastValue());
REQUIRE_FALSE(entry.HasLastValue());
entry.Update({{5}}, 7);
log.Flush();
ASSERT_EQ(data.size(), 42u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), std::vector<uint8_t>{5});
REQUIRE(data.size() == 42u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == std::vector<uint8_t>{5});
entry.Update({{5}}, 8);
log.Flush();
ASSERT_EQ(data.size(), 42u);
REQUIRE(data.size() == 42u);
entry.Update({{6}}, 9);
log.Flush();
ASSERT_EQ(data.size(), 47u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), std::vector<uint8_t>{6});
REQUIRE(data.size() == 47u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == std::vector<uint8_t>{6});
entry.Update({{6, 6}}, 9);
log.Flush();
ASSERT_EQ(data.size(), 53u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), (std::vector<uint8_t>{6, 6}));
REQUIRE(data.size() == 53u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == (std::vector<uint8_t>{6, 6}));
entry.Update(std::span<const uint8_t>{}, 10);
log.Flush();
ASSERT_EQ(data.size(), 57u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), std::vector<uint8_t>{});
REQUIRE(data.size() == 57u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == std::vector<uint8_t>{});
}
TEST_F(DataLogTest, BooleanArrayAppendEmpty) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest BooleanArrayAppendEmpty",
"[datalog][data-log]") {
wpi::log::BooleanArrayLogEntry entry{log, "a", 5};
entry.Append(std::span<const bool>{}, 7);
log.Flush();
ASSERT_EQ(data.size(), 47u);
REQUIRE(data.size() == 47u);
}
TEST_F(DataLogTest, BooleanArrayAppend) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest BooleanArrayAppend",
"[datalog][data-log]") {
wpi::log::BooleanArrayLogEntry entry{log, "a", 5};
entry.Append({false}, 7);
log.Flush();
ASSERT_EQ(data.size(), 48u);
REQUIRE(data.size() == 48u);
}
TEST_F(DataLogTest, BooleanArrayUpdate) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest BooleanArrayUpdate",
"[datalog][data-log]") {
wpi::log::BooleanArrayLogEntry entry{log, "a", 5};
ASSERT_FALSE(entry.GetLastValue().has_value());
REQUIRE_FALSE(entry.GetLastValue().has_value());
entry.Update({false}, 7);
log.Flush();
ASSERT_EQ(data.size(), 48u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), std::vector<int>{false});
REQUIRE(data.size() == 48u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == std::vector<int>{false});
entry.Update({false}, 8);
log.Flush();
ASSERT_EQ(data.size(), 48u);
REQUIRE(data.size() == 48u);
entry.Update({true}, 9);
log.Flush();
ASSERT_EQ(data.size(), 53u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), std::vector<int>{true});
REQUIRE(data.size() == 53u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == std::vector<int>{true});
entry.Update(std::span<const bool>{}, 10);
log.Flush();
ASSERT_EQ(data.size(), 57u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), std::vector<int>{});
REQUIRE(data.size() == 57u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == std::vector<int>{});
}
TEST_F(DataLogTest, IntegerArrayAppendEmpty) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest IntegerArrayAppendEmpty",
"[datalog][data-log]") {
wpi::log::IntegerArrayLogEntry entry{log, "a", 5};
entry.Append(std::span<const int64_t>{}, 7);
log.Flush();
ASSERT_EQ(data.size(), 45u);
REQUIRE(data.size() == 45u);
}
TEST_F(DataLogTest, IntegerArrayAppend) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest IntegerArrayAppend",
"[datalog][data-log]") {
wpi::log::IntegerArrayLogEntry entry{log, "a", 5};
entry.Append({1}, 7);
log.Flush();
ASSERT_EQ(data.size(), 53u);
REQUIRE(data.size() == 53u);
}
TEST_F(DataLogTest, IntegerArrayUpdate) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest IntegerArrayUpdate",
"[datalog][data-log]") {
wpi::log::IntegerArrayLogEntry entry{log, "a", 5};
ASSERT_FALSE(entry.GetLastValue().has_value());
REQUIRE_FALSE(entry.GetLastValue().has_value());
entry.Update({1}, 7);
log.Flush();
ASSERT_EQ(data.size(), 53u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), std::vector<int64_t>{1});
REQUIRE(data.size() == 53u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == std::vector<int64_t>{1});
entry.Update({1}, 8);
log.Flush();
ASSERT_EQ(data.size(), 53u);
REQUIRE(data.size() == 53u);
entry.Update({2}, 9);
log.Flush();
ASSERT_EQ(data.size(), 65u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), std::vector<int64_t>{2});
REQUIRE(data.size() == 65u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == std::vector<int64_t>{2});
entry.Update(std::span<const int64_t>{}, 10);
log.Flush();
ASSERT_EQ(data.size(), 69u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), std::vector<int64_t>{});
REQUIRE(data.size() == 69u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == std::vector<int64_t>{});
}
TEST_F(DataLogTest, DoubleArrayAppendEmpty) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest DoubleArrayAppendEmpty",
"[datalog][data-log]") {
wpi::log::DoubleArrayLogEntry entry{log, "a", 5};
entry.Append(std::span<const double>{}, 7);
log.Flush();
ASSERT_EQ(data.size(), 46u);
REQUIRE(data.size() == 46u);
}
TEST_F(DataLogTest, DoubleArrayAppend) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest DoubleArrayAppend",
"[datalog][data-log]") {
wpi::log::DoubleArrayLogEntry entry{log, "a", 5};
entry.Append({1.0}, 7);
log.Flush();
ASSERT_EQ(data.size(), 54u);
REQUIRE(data.size() == 54u);
}
TEST_F(DataLogTest, DoubleArrayUpdate) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest DoubleArrayUpdate",
"[datalog][data-log]") {
wpi::log::DoubleArrayLogEntry entry{log, "a", 5};
ASSERT_FALSE(entry.GetLastValue().has_value());
REQUIRE_FALSE(entry.GetLastValue().has_value());
entry.Update({1.0}, 7);
log.Flush();
ASSERT_EQ(data.size(), 54u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), std::vector<double>{1.0});
REQUIRE(data.size() == 54u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == std::vector<double>{1.0});
entry.Update({1.0}, 8);
log.Flush();
ASSERT_EQ(data.size(), 54u);
REQUIRE(data.size() == 54u);
entry.Update({2.0}, 9);
log.Flush();
ASSERT_EQ(data.size(), 66u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), std::vector<double>{2});
REQUIRE(data.size() == 66u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == std::vector<double>{2});
entry.Update(std::span<const double>{}, 10);
log.Flush();
ASSERT_EQ(data.size(), 70u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), std::vector<double>{});
REQUIRE(data.size() == 70u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == std::vector<double>{});
}
TEST_F(DataLogTest, FloatArrayAppendEmpty) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest FloatArrayAppendEmpty",
"[datalog][data-log]") {
wpi::log::FloatArrayLogEntry entry{log, "a", 5};
entry.Append(std::span<const float>{}, 7);
log.Flush();
ASSERT_EQ(data.size(), 45u);
REQUIRE(data.size() == 45u);
}
TEST_F(DataLogTest, FloatArrayAppend) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest FloatArrayAppend",
"[datalog][data-log]") {
wpi::log::FloatArrayLogEntry entry{log, "a", 5};
entry.Append({1.0f}, 7);
log.Flush();
ASSERT_EQ(data.size(), 49u);
REQUIRE(data.size() == 49u);
}
TEST_F(DataLogTest, FloatArrayUpdate) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest FloatArrayUpdate",
"[datalog][data-log]") {
wpi::log::FloatArrayLogEntry entry{log, "a", 5};
ASSERT_FALSE(entry.GetLastValue().has_value());
REQUIRE_FALSE(entry.GetLastValue().has_value());
entry.Update({1.0f}, 7);
log.Flush();
ASSERT_EQ(data.size(), 49u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), std::vector<float>{1.0f});
REQUIRE(data.size() == 49u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == std::vector<float>{1.0f});
entry.Update({1.0f}, 8);
log.Flush();
ASSERT_EQ(data.size(), 49u);
REQUIRE(data.size() == 49u);
entry.Update({2.0f}, 9);
log.Flush();
ASSERT_EQ(data.size(), 57u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), std::vector<float>{2.0f});
REQUIRE(data.size() == 57u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == std::vector<float>{2.0f});
entry.Update(std::span<const float>{}, 10);
log.Flush();
ASSERT_EQ(data.size(), 61u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), std::vector<float>{});
REQUIRE(data.size() == 61u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == std::vector<float>{});
}
TEST_F(DataLogTest, StringArrayAppendEmpty) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest StringArrayAppendEmpty",
"[datalog][data-log]") {
wpi::log::StringArrayLogEntry entry{log, "a", 5};
entry.Append(std::span<const std::string>{}, 7);
entry.Append(std::span<const std::string_view>{}, 7);
log.Flush();
ASSERT_EQ(data.size(), 58u);
REQUIRE(data.size() == 58u);
}
TEST_F(DataLogTest, StringArrayAppend) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest StringArrayAppend",
"[datalog][data-log]") {
wpi::log::StringArrayLogEntry entry{log, "a", 5};
entry.Append({"x"}, 7);
log.Flush();
ASSERT_EQ(data.size(), 55u);
REQUIRE(data.size() == 55u);
}
TEST_F(DataLogTest, StringArrayUpdate) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest StringArrayUpdate",
"[datalog][data-log]") {
wpi::log::StringArrayLogEntry entry{log, "a", 5};
ASSERT_FALSE(entry.GetLastValue().has_value());
REQUIRE_FALSE(entry.GetLastValue().has_value());
entry.Update({"x"}, 7);
log.Flush();
ASSERT_EQ(data.size(), 55u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), std::vector<std::string>{"x"});
REQUIRE(data.size() == 55u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == std::vector<std::string>{"x"});
entry.Update({"x"}, 8);
log.Flush();
ASSERT_EQ(data.size(), 55u);
REQUIRE(data.size() == 55u);
entry.Update({"y"}, 9);
log.Flush();
ASSERT_EQ(data.size(), 68u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), std::vector<std::string>{"y"});
REQUIRE(data.size() == 68u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == std::vector<std::string>{"y"});
entry.Update(std::span<const std::string_view>{}, 10);
log.Flush();
ASSERT_EQ(data.size(), 76u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), std::vector<std::string>{});
REQUIRE(data.size() == 76u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == std::vector<std::string>{});
}
TEST_F(DataLogTest, StructA) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest StructA", "[datalog][data-log]") {
[[maybe_unused]]
wpi::log::StructLogEntry<ThingA> entry0;
wpi::log::StructLogEntry<ThingA> entry{log, "a", 5};
@@ -516,28 +541,30 @@ TEST_F(DataLogTest, StructA) {
entry.Append(ThingA{}, 7);
}
TEST_F(DataLogTest, StructUpdate) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest StructUpdate",
"[datalog][data-log]") {
wpi::log::StructLogEntry<ThingA> entry{log, "a", 5};
ASSERT_FALSE(entry.GetLastValue().has_value());
REQUIRE_FALSE(entry.GetLastValue().has_value());
entry.Update(ThingA{}, 7);
log.Flush();
ASSERT_EQ(data.size(), 122u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), ThingA{});
REQUIRE(data.size() == 122u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == ThingA{});
entry.Update(ThingA{}, 8);
log.Flush();
ASSERT_EQ(data.size(), 122u);
REQUIRE(data.size() == 122u);
entry.Update(ThingA{.x = 1}, 9);
log.Flush();
ASSERT_EQ(data.size(), 127u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), ThingA{.x = 1});
REQUIRE(data.size() == 127u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == ThingA{.x = 1});
}
TEST_F(DataLogTest, StructArrayA) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest StructArrayA",
"[datalog][data-log]") {
[[maybe_unused]]
wpi::log::StructArrayLogEntry<ThingA> entry0;
wpi::log::StructArrayLogEntry<ThingA> entry{log, "a", 5};
@@ -545,36 +572,38 @@ TEST_F(DataLogTest, StructArrayA) {
entry.Append({{ThingA{}, ThingA{}}}, 7);
}
TEST_F(DataLogTest, StructArrayUpdate) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest StructArrayUpdate",
"[datalog][data-log]") {
wpi::log::StructArrayLogEntry<ThingA> entry{log, "a", 5};
ASSERT_FALSE(entry.GetLastValue().has_value());
REQUIRE_FALSE(entry.GetLastValue().has_value());
entry.Update({{ThingA{}, ThingA{.x = 1}}}, 7);
log.Flush();
ASSERT_EQ(data.size(), 125u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(),
(std::vector<ThingA>{ThingA{}, ThingA{.x = 1}}));
REQUIRE(data.size() == 125u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() ==
(std::vector<ThingA>{ThingA{}, ThingA{.x = 1}}));
entry.Update({{ThingA{}, ThingA{.x = 1}}}, 8);
log.Flush();
ASSERT_EQ(data.size(), 125u);
REQUIRE(data.size() == 125u);
entry.Update({{ThingA{}, ThingA{.x = 2}}}, 9);
log.Flush();
ASSERT_EQ(data.size(), 131u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(),
(std::vector<ThingA>{ThingA{}, ThingA{.x = 2}}));
REQUIRE(data.size() == 131u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() ==
(std::vector<ThingA>{ThingA{}, ThingA{.x = 2}}));
entry.Update(std::span<const ThingA>{}, 10);
log.Flush();
ASSERT_EQ(data.size(), 135u);
ASSERT_TRUE(entry.GetLastValue().has_value());
ASSERT_EQ(entry.GetLastValue().value(), std::vector<ThingA>{});
REQUIRE(data.size() == 135u);
REQUIRE(entry.GetLastValue().has_value());
REQUIRE(entry.GetLastValue().value() == std::vector<ThingA>{});
}
TEST_F(DataLogTest, StructFixedArrayA) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest StructFixedArrayA",
"[datalog][data-log]") {
[[maybe_unused]]
wpi::log::StructArrayLogEntry<std::array<ThingA, 2>> entry0;
wpi::log::StructLogEntry<std::array<ThingA, 2>> entry{log, "a", 5};
@@ -583,7 +612,7 @@ TEST_F(DataLogTest, StructFixedArrayA) {
entry.Append(arr, 7);
}
TEST_F(DataLogTest, StructB) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest StructB", "[datalog][data-log]") {
Info1 info;
[[maybe_unused]]
wpi::log::StructLogEntry<ThingB, Info1> entry0;
@@ -592,7 +621,8 @@ TEST_F(DataLogTest, StructB) {
entry.Append(ThingB{}, 7);
}
TEST_F(DataLogTest, StructArrayB) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest StructArrayB",
"[datalog][data-log]") {
Info1 info;
[[maybe_unused]]
wpi::log::StructArrayLogEntry<ThingB, Info1> entry0;
@@ -601,7 +631,8 @@ TEST_F(DataLogTest, StructArrayB) {
entry.Append({{ThingB{}, ThingB{}}}, 7);
}
TEST_F(DataLogTest, StructFixedArrayB) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest StructFixedArrayB",
"[datalog][data-log]") {
Info1 info;
wpi::log::StructLogEntry<std::array<ThingB, 2>, Info1> entry{log, "a", info,
5};
@@ -610,7 +641,7 @@ TEST_F(DataLogTest, StructFixedArrayB) {
entry.Append(arr, 7);
}
TEST_F(DataLogTest, StructC) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest StructC", "[datalog][data-log]") {
{
wpi::log::StructLogEntry<ThingC> entry{log, "c", 5};
entry.Append(ThingC{});
@@ -630,7 +661,8 @@ TEST_F(DataLogTest, StructC) {
}
}
TEST_F(DataLogTest, StructArrayC) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest StructArrayC",
"[datalog][data-log]") {
{
wpi::log::StructArrayLogEntry<ThingC> entry{log, "c", 5};
entry.Append({{ThingC{}, ThingC{}}});
@@ -650,7 +682,8 @@ TEST_F(DataLogTest, StructArrayC) {
}
}
TEST_F(DataLogTest, StructFixedArrayC) {
TEST_CASE_METHOD(DataLogTest, "DataLogTest StructFixedArrayC",
"[datalog][data-log]") {
std::array<ThingC, 2> arr;
{
wpi::log::StructLogEntry<std::array<ThingC, 2>> entry{log, "c", 5};

27
datalog/src/test/native/cpp/FileLoggerTest.cpp
View File

@@ -8,36 +8,36 @@
#include <string_view>
#include <vector>
#include <gtest/gtest.h>
#include <catch2/catch_test_macros.hpp>
TEST(FileLoggerTest, BufferSingleLine) {
TEST_CASE("FileLoggerTest BufferSingleLine", "[datalog][file-logger]") {
std::vector<std::string> buf;
auto func = wpi::log::FileLogger::Buffer(
[&buf](std::string_view line) { buf.emplace_back(line); });
func("qwertyuiop\n");
EXPECT_EQ("qwertyuiop", buf[0]);
CHECK("qwertyuiop" == buf[0]);
}
TEST(FileLoggerTest, BufferMultiLine) {
TEST_CASE("FileLoggerTest BufferMultiLine", "[datalog][file-logger]") {
std::vector<std::string> buf;
auto func = wpi::log::FileLogger::Buffer(
[&buf](std::string_view line) { buf.emplace_back(line); });
func("line 1\nline 2\nline 3\n");
EXPECT_EQ("line 1\nline 2\nline 3", buf[0]);
CHECK("line 1\nline 2\nline 3" == buf[0]);
}
TEST(FileLoggerTest, BufferPartials) {
TEST_CASE("FileLoggerTest BufferPartials", "[datalog][file-logger]") {
std::vector<std::string> buf;
auto func = wpi::log::FileLogger::Buffer(
[&buf](std::string_view line) { buf.emplace_back(line); });
func("part 1");
func("part 2\npart 3");
EXPECT_EQ("part 1part 2", buf[0]);
CHECK("part 1part 2" == buf[0]);
func("\n");
EXPECT_EQ("part 3", buf[1]);
CHECK("part 3" == buf[1]);
}
TEST(FileLoggerTest, BufferMultiplePartials) {
TEST_CASE("FileLoggerTest BufferMultiplePartials", "[datalog][file-logger]") {
std::vector<std::string> buf;
auto func = wpi::log::FileLogger::Buffer(
[&buf](std::string_view line) { buf.emplace_back(line); });
@@ -45,15 +45,16 @@ TEST(FileLoggerTest, BufferMultiplePartials) {
func("part 2");
func("part 3");
func("part 4\n");
EXPECT_EQ("part 1part 2part 3part 4", buf[0]);
CHECK("part 1part 2part 3part 4" == buf[0]);
}
TEST(FileLoggerTest, BufferMultipleMultiLinePartials) {
TEST_CASE("FileLoggerTest BufferMultipleMultiLinePartials",
"[datalog][file-logger]") {
std::vector<std::string> buf;
auto func = wpi::log::FileLogger::Buffer(
[&buf](std::string_view line) { buf.emplace_back(line); });
func("part 1");
func("part 2\npart 3");
func("part 4\n");
EXPECT_EQ("part 1part 2", buf[0]);
EXPECT_EQ("part 3part 4", buf[1]);
CHECK("part 1part 2" == buf[0]);
CHECK("part 3part 4" == buf[1]);
}

6
datalog/src/test/native/cpp/main.cpp
View File

@@ -2,10 +2,8 @@
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
#include <gtest/gtest.h>
#include <catch2/catch_session.hpp>
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
int ret = RUN_ALL_TESTS();
return ret;
return Catch::Session().run(argc, argv);
}