From 20d42add0348941baba7b079f03ba0ff57bfd083 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Tue, 30 Aug 2022 12:07:09 +0200 Subject: [PATCH 01/10] add new data wrapper helper type --- src/fsfw/util/dataWrapper.h | 52 +++++++++++++++++++++++++++++++++++++ 1 file changed, 52 insertions(+) create mode 100644 src/fsfw/util/dataWrapper.h diff --git a/src/fsfw/util/dataWrapper.h b/src/fsfw/util/dataWrapper.h new file mode 100644 index 000000000..f5dab447a --- /dev/null +++ b/src/fsfw/util/dataWrapper.h @@ -0,0 +1,52 @@ +#ifndef FSFW_UTIL_DATAWRAPPER_H +#define FSFW_UTIL_DATAWRAPPER_H + +#include +#include +#include + +#include "fsfw/serialize.h" + +namespace util { + +struct RawData { + const uint8_t* data; + size_t len; +}; + +enum DataTypes { RAW, SERIALIZABLE }; + +union DataUnion { + RawData raw; + SerializeIF* serializable; +}; + +struct DataWrapper { + DataTypes type; + DataUnion dataUnion; + using BufPairT = std::pair; + + [[nodiscard]] size_t getLength() const { + if (type == DataTypes::RAW) { + return dataUnion.raw.len; + } else if (type == DataTypes::SERIALIZABLE and dataUnion.serializable != nullptr) { + return dataUnion.serializable->getSerializedSize(); + } + return 0; + } + + void setRawData(BufPairT bufPair) { + type = DataTypes::RAW; + dataUnion.raw.data = bufPair.first; + dataUnion.raw.len = bufPair.second; + } + + void setSerializable(SerializeIF& serializable) { + type = DataTypes::SERIALIZABLE; + dataUnion.serializable = &serializable; + } +}; + +} // namespace util + +#endif // FSFW_UTIL_DATAWRAPPER_H -- 2.34.1 From 0f27c7e7e707fd3c901a43ac6de4ce072758d918 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Tue, 30 Aug 2022 13:24:29 +0200 Subject: [PATCH 02/10] extend data wrapper --- src/fsfw/util/dataWrapper.h | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-) diff --git a/src/fsfw/util/dataWrapper.h b/src/fsfw/util/dataWrapper.h index f5dab447a..5ae2c0432 100644 --- a/src/fsfw/util/dataWrapper.h +++ b/src/fsfw/util/dataWrapper.h @@ -10,19 +10,19 @@ namespace util { struct RawData { - const uint8_t* data; - size_t len; + const uint8_t* data = nullptr; + size_t len = 0; }; -enum DataTypes { RAW, SERIALIZABLE }; +enum DataTypes { NONE, RAW, SERIALIZABLE }; union DataUnion { RawData raw; - SerializeIF* serializable; + SerializeIF* serializable = nullptr; }; struct DataWrapper { - DataTypes type; + DataTypes type = DataTypes::NONE; DataUnion dataUnion; using BufPairT = std::pair; @@ -35,6 +35,14 @@ struct DataWrapper { return 0; } + [[nodiscard]] bool isNull() const { + if (type == DataTypes::RAW and dataUnion.raw.data == nullptr or + (type == DataTypes::SERIALIZABLE and dataUnion.serializable == nullptr) or + (type == DataTypes::NONE)) { + return true; + } + return false; + } void setRawData(BufPairT bufPair) { type = DataTypes::RAW; dataUnion.raw.data = bufPair.first; -- 2.34.1 From 3a47062f2a5432be95bdce8f380eaab7347e03fd Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Tue, 30 Aug 2022 13:39:21 +0200 Subject: [PATCH 03/10] refactored dhb TM handler --- src/fsfw/devicehandlers/DeviceHandlerBase.cpp | 38 ++++++++++--------- src/fsfw/devicehandlers/DeviceHandlerBase.h | 6 +-- .../DeviceTmReportingWrapper.cpp | 33 +++++++++------- .../devicehandlers/DeviceTmReportingWrapper.h | 26 +++++++------ 4 files changed, 57 insertions(+), 46 deletions(-) diff --git a/src/fsfw/devicehandlers/DeviceHandlerBase.cpp b/src/fsfw/devicehandlers/DeviceHandlerBase.cpp index 525a3dcc5..66b673c82 100644 --- a/src/fsfw/devicehandlers/DeviceHandlerBase.cpp +++ b/src/fsfw/devicehandlers/DeviceHandlerBase.cpp @@ -1257,30 +1257,40 @@ ReturnValue_t DeviceHandlerBase::letChildHandleMessage(CommandMessage* message) return returnvalue::FAILED; } -void DeviceHandlerBase::handleDeviceTM(SerializeIF* dataSet, DeviceCommandId_t replyId, +void DeviceHandlerBase::handleDeviceTm(util::DataWrapper dataWrapper, DeviceCommandId_t replyId, bool forceDirectTm) { - if (dataSet == nullptr) { + if (dataWrapper.isNull()) { return; } - DeviceReplyMap::iterator iter = deviceReplyMap.find(replyId); + auto iter = deviceReplyMap.find(replyId); if (iter == deviceReplyMap.end()) { triggerEvent(DEVICE_UNKNOWN_REPLY, replyId); return; } - /* Regular replies to a command */ + auto reportData = [&](MessageQueueId_t queueId) { + if (dataWrapper.type == util::DataTypes::SERIALIZABLE) { + return actionHelper.reportData(queueId, replyId, dataWrapper.dataUnion.serializable); + } else if (dataWrapper.type == util::DataTypes::RAW) { + return actionHelper.reportData(queueId, replyId, dataWrapper.dataUnion.raw.data, + dataWrapper.dataUnion.raw.len); + } + return returnvalue::FAILED; + }; + + // Regular replies to a command if (iter->second.command != deviceCommandMap.end()) { MessageQueueId_t queueId = iter->second.command->second.sendReplyTo; + // This may fail, but we'll ignore the fault. if (queueId != NO_COMMANDER) { - /* This may fail, but we'll ignore the fault. */ - actionHelper.reportData(queueId, replyId, dataSet); + reportData(queueId); } - /* This check should make sure we get any TM but don't get anything doubled. */ + // This check should make sure we get any TM but don't get anything doubled. if (wiretappingMode == TM && (requestedRawTraffic != queueId)) { - DeviceTmReportingWrapper wrapper(getObjectId(), replyId, dataSet); + DeviceTmReportingWrapper wrapper(getObjectId(), replyId, dataWrapper); actionHelper.reportData(requestedRawTraffic, replyId, &wrapper); } @@ -1289,22 +1299,16 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* dataSet, DeviceCommandId_t r // hiding of sender needed so the service will handle it as // unexpected Data, no matter what state (progress or completed) // it is in - actionHelper.reportData(defaultRawReceiver, replyId, dataSet, true); + reportData(defaultRawReceiver); } } - /* Unrequested or aperiodic replies */ + // Unrequested or aperiodic replies else { - DeviceTmReportingWrapper wrapper(getObjectId(), replyId, dataSet); + DeviceTmReportingWrapper wrapper(getObjectId(), replyId, dataWrapper); if (wiretappingMode == TM) { actionHelper.reportData(requestedRawTraffic, replyId, &wrapper); } if (forceDirectTm and defaultRawReceiver != MessageQueueIF::NO_QUEUE) { - // sid_t setSid = sid_t(this->getObjectId(), replyId); - // LocalPoolDataSetBase* dataset = getDataSetHandle(setSid); - // if(dataset != nullptr) { - // poolManager.generateHousekeepingPacket(setSid, dataset, true); - // } - // hiding of sender needed so the service will handle it as // unexpected Data, no matter what state (progress or completed) // it is in diff --git a/src/fsfw/devicehandlers/DeviceHandlerBase.h b/src/fsfw/devicehandlers/DeviceHandlerBase.h index a20eae0ca..48f9fdbf6 100644 --- a/src/fsfw/devicehandlers/DeviceHandlerBase.h +++ b/src/fsfw/devicehandlers/DeviceHandlerBase.h @@ -23,6 +23,7 @@ #include "fsfw/serviceinterface/serviceInterfaceDefintions.h" #include "fsfw/tasks/ExecutableObjectIF.h" #include "fsfw/tasks/PeriodicTaskIF.h" +#include "fsfw/util/dataWrapper.h" namespace Factory { void setStaticFrameworkObjectIds(); @@ -1052,9 +1053,8 @@ class DeviceHandlerBase : public DeviceHandlerIF, bool isAwaitingReply(); - void handleDeviceTM(SerializeIF *dataSet, DeviceCommandId_t replyId, bool forceDirectTm = false); - // void handleDeviceTM(uint8_t* data, size_t dataSize, DeviceCommandId_t replyId, - // bool forceDirectTm); + void handleDeviceTm(util::DataWrapper dataWrapper, DeviceCommandId_t replyId, + bool forceDirectTm = false); virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode, uint32_t *msToReachTheMode); diff --git a/src/fsfw/devicehandlers/DeviceTmReportingWrapper.cpp b/src/fsfw/devicehandlers/DeviceTmReportingWrapper.cpp index dc987e6d1..1f661cd3f 100644 --- a/src/fsfw/devicehandlers/DeviceTmReportingWrapper.cpp +++ b/src/fsfw/devicehandlers/DeviceTmReportingWrapper.cpp @@ -3,10 +3,10 @@ #include "fsfw/serialize/SerializeAdapter.h" DeviceTmReportingWrapper::DeviceTmReportingWrapper(object_id_t objectId, ActionId_t actionId, - SerializeIF* data) - : objectId(objectId), actionId(actionId), data(data) {} + util::DataWrapper data) + : objectId(objectId), actionId(actionId), dataWrapper(data) {} -DeviceTmReportingWrapper::~DeviceTmReportingWrapper() {} +DeviceTmReportingWrapper::~DeviceTmReportingWrapper() = default; ReturnValue_t DeviceTmReportingWrapper::serialize(uint8_t** buffer, size_t* size, size_t maxSize, Endianness streamEndianness) const { @@ -19,22 +19,27 @@ ReturnValue_t DeviceTmReportingWrapper::serialize(uint8_t** buffer, size_t* size if (result != returnvalue::OK) { return result; } - return data->serialize(buffer, size, maxSize, streamEndianness); + if (dataWrapper.isNull()) { + return returnvalue::FAILED; + } + if (dataWrapper.type == util::DataTypes::SERIALIZABLE) { + return dataWrapper.dataUnion.serializable->serialize(buffer, size, maxSize, streamEndianness); + } else if (dataWrapper.type == util::DataTypes::RAW) { + if (*size + dataWrapper.dataUnion.raw.len > maxSize) { + return SerializeIF::BUFFER_TOO_SHORT; + } + std::memcpy(*buffer, dataWrapper.dataUnion.raw.data, dataWrapper.dataUnion.raw.len); + *buffer += dataWrapper.dataUnion.raw.len; + *size += dataWrapper.dataUnion.raw.len; + } + return returnvalue::OK; } size_t DeviceTmReportingWrapper::getSerializedSize() const { - return sizeof(objectId) + sizeof(ActionId_t) + data->getSerializedSize(); + return sizeof(objectId) + sizeof(ActionId_t) + dataWrapper.getLength(); } ReturnValue_t DeviceTmReportingWrapper::deSerialize(const uint8_t** buffer, size_t* size, Endianness streamEndianness) { - ReturnValue_t result = SerializeAdapter::deSerialize(&objectId, buffer, size, streamEndianness); - if (result != returnvalue::OK) { - return result; - } - result = SerializeAdapter::deSerialize(&actionId, buffer, size, streamEndianness); - if (result != returnvalue::OK) { - return result; - } - return data->deSerialize(buffer, size, streamEndianness); + return returnvalue::FAILED; } diff --git a/src/fsfw/devicehandlers/DeviceTmReportingWrapper.h b/src/fsfw/devicehandlers/DeviceTmReportingWrapper.h index 71c644534..236e2d1e5 100644 --- a/src/fsfw/devicehandlers/DeviceTmReportingWrapper.h +++ b/src/fsfw/devicehandlers/DeviceTmReportingWrapper.h @@ -1,27 +1,29 @@ #ifndef FSFW_DEVICEHANDLERS_DEVICETMREPORTINGWRAPPER_H_ #define FSFW_DEVICEHANDLERS_DEVICETMREPORTINGWRAPPER_H_ -#include "../action/HasActionsIF.h" -#include "../objectmanager/SystemObjectIF.h" -#include "../serialize/SerializeIF.h" +#include "fsfw/action/HasActionsIF.h" +#include "fsfw/objectmanager/SystemObjectIF.h" +#include "fsfw/serialize/SerializeIF.h" +#include "fsfw/util/dataWrapper.h" class DeviceTmReportingWrapper : public SerializeIF { public: - DeviceTmReportingWrapper(object_id_t objectId, ActionId_t actionId, SerializeIF* data); - virtual ~DeviceTmReportingWrapper(); + DeviceTmReportingWrapper(object_id_t objectId, ActionId_t actionId, util::DataWrapper data); + ~DeviceTmReportingWrapper() override; - virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize, - Endianness streamEndianness) const override; + ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize, + Endianness streamEndianness) const override; - virtual size_t getSerializedSize() const override; - - virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size, - Endianness streamEndianness) override; + [[nodiscard]] size_t getSerializedSize() const override; private: object_id_t objectId; ActionId_t actionId; - SerializeIF* data; + util::DataWrapper dataWrapper; + + // Deserialization forbidden + ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size, + Endianness streamEndianness) override; }; #endif /* FSFW_DEVICEHANDLERS_DEVICETMREPORTINGWRAPPER_H_ */ -- 2.34.1 From c756297e5c1ece6a2e22aa036c9a8c1d5a2e435b Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Tue, 30 Aug 2022 13:39:44 +0200 Subject: [PATCH 04/10] data wrapper update --- src/fsfw/util/dataWrapper.h | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/fsfw/util/dataWrapper.h b/src/fsfw/util/dataWrapper.h index 5ae2c0432..8bb373e64 100644 --- a/src/fsfw/util/dataWrapper.h +++ b/src/fsfw/util/dataWrapper.h @@ -36,9 +36,8 @@ struct DataWrapper { } [[nodiscard]] bool isNull() const { - if (type == DataTypes::RAW and dataUnion.raw.data == nullptr or - (type == DataTypes::SERIALIZABLE and dataUnion.serializable == nullptr) or - (type == DataTypes::NONE)) { + if ((type == DataTypes::NONE) or (type == DataTypes::RAW and dataUnion.raw.data == nullptr) or + (type == DataTypes::SERIALIZABLE and dataUnion.serializable == nullptr)) { return true; } return false; -- 2.34.1 From bdd79d060df5ddde24da71b3a7df83ffbf486be9 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Tue, 30 Aug 2022 14:02:58 +0200 Subject: [PATCH 05/10] basic data wrapper unittests --- src/fsfw/util/dataWrapper.h | 5 ++-- unittests/util/CMakeLists.txt | 1 + unittests/util/testDataWrapper.cpp | 31 ++++++++++++++++++++++++ unittests/util/testUnsignedByteField.cpp | 2 +- 4 files changed, 36 insertions(+), 3 deletions(-) create mode 100644 unittests/util/testDataWrapper.cpp diff --git a/src/fsfw/util/dataWrapper.h b/src/fsfw/util/dataWrapper.h index 8bb373e64..440f95013 100644 --- a/src/fsfw/util/dataWrapper.h +++ b/src/fsfw/util/dataWrapper.h @@ -10,6 +10,7 @@ namespace util { struct RawData { + RawData() = default; const uint8_t* data = nullptr; size_t len = 0; }; @@ -17,8 +18,8 @@ struct RawData { enum DataTypes { NONE, RAW, SERIALIZABLE }; union DataUnion { - RawData raw; - SerializeIF* serializable = nullptr; + RawData raw{}; + SerializeIF* serializable; }; struct DataWrapper { diff --git a/unittests/util/CMakeLists.txt b/unittests/util/CMakeLists.txt index d4caa4d57..dd9f6dc1a 100644 --- a/unittests/util/CMakeLists.txt +++ b/unittests/util/CMakeLists.txt @@ -1,3 +1,4 @@ target_sources(${FSFW_TEST_TGT} PRIVATE testUnsignedByteField.cpp + testDataWrapper.cpp ) diff --git a/unittests/util/testDataWrapper.cpp b/unittests/util/testDataWrapper.cpp new file mode 100644 index 000000000..5a6b26d7a --- /dev/null +++ b/unittests/util/testDataWrapper.cpp @@ -0,0 +1,31 @@ +#include +#include + +#include "fsfw/util/dataWrapper.h" +#include "mocks/SimpleSerializable.h" + +TEST_CASE("Data Wrapper", "[util]") { + util::DataWrapper wrapper; + SECTION("State") { + REQUIRE(wrapper.isNull()); + } + + SECTION("Set Raw Data") { + REQUIRE(wrapper.isNull()); + std::array data = {1, 2, 3, 4}; + wrapper.setRawData({data.data(), data.size()}); + REQUIRE(not wrapper.isNull()); + REQUIRE(wrapper.type == util::DataTypes::RAW); + REQUIRE(wrapper.dataUnion.raw.data == data.data()); + REQUIRE(wrapper.dataUnion.raw.len == data.size()); + } + + SECTION("Simple Serializable") { + REQUIRE(wrapper.isNull()); + SimpleSerializable serializable; + wrapper.setSerializable(serializable); + REQUIRE(not wrapper.isNull()); + REQUIRE(wrapper.type == util::DataTypes::SERIALIZABLE); + REQUIRE(wrapper.dataUnion.serializable == &serializable); + } +} \ No newline at end of file diff --git a/unittests/util/testUnsignedByteField.cpp b/unittests/util/testUnsignedByteField.cpp index df1ff4836..58a87a7dd 100644 --- a/unittests/util/testUnsignedByteField.cpp +++ b/unittests/util/testUnsignedByteField.cpp @@ -4,7 +4,7 @@ #include "fsfw/util/UnsignedByteField.h" -TEST_CASE("Unsigned Byte Field", "[unsigned-byte-field]") { +TEST_CASE("Unsigned Byte Field", "[util]") { auto testByteField = UnsignedByteField(10); auto u32ByteField = U32ByteField(10); auto u16ByteField = U16ByteField(5); -- 2.34.1 From 192255df1cc9b75559d9bd57d44f467bc49a3b83 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Tue, 30 Aug 2022 14:03:33 +0200 Subject: [PATCH 06/10] additional test --- unittests/util/testDataWrapper.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/unittests/util/testDataWrapper.cpp b/unittests/util/testDataWrapper.cpp index 5a6b26d7a..14ba287ab 100644 --- a/unittests/util/testDataWrapper.cpp +++ b/unittests/util/testDataWrapper.cpp @@ -8,6 +8,7 @@ TEST_CASE("Data Wrapper", "[util]") { util::DataWrapper wrapper; SECTION("State") { REQUIRE(wrapper.isNull()); + REQUIRE(wrapper.type == util::DataTypes::NONE); } SECTION("Set Raw Data") { -- 2.34.1 From 6b8c83be29c683e73ff179f0ad99ebf77e783ccb Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Tue, 30 Aug 2022 14:40:02 +0200 Subject: [PATCH 07/10] update changelog --- CHANGELOG.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 1c78318c9..06c02e963 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -16,6 +16,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/). ## Added +- DHB TM handler `handleDeviceTM` renamed to `handleDeviceTm` and now takes + `util::DataWrapper` as the data input argument. This allows more flexibility in the possible + types of telemetry. + PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/669 - Add new `UnsignedByteField` class PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/660 -- 2.34.1 From d675a789a29c18bf1fd57f5dbc89870da54db31b Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Tue, 30 Aug 2022 14:41:37 +0200 Subject: [PATCH 08/10] update changelog --- CHANGELOG.md | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 1c78318c9..34053f163 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/). # [unreleased] +# [v6.0.0] + ## Changes - Removed `HasReturnvaluesIF` class in favor of `returnvalue` namespace with `OK` and `FAILED` @@ -16,6 +18,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/). ## Added +- Add `util::DataWrapper` class inside the `util` module. This is a tagged union which allows + to specify raw data either as a classic C-style raw pointer and size or as a `SerializeIF` + pointer. + PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/668 - Add new `UnsignedByteField` class PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/660 -- 2.34.1 From 8d1777fa0c7b330fedfdc834fa15da50bcd9df17 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Tue, 30 Aug 2022 16:02:50 +0200 Subject: [PATCH 09/10] additional tests --- src/fsfw/util/dataWrapper.h | 21 +++++++++++-- unittests/util/testDataWrapper.cpp | 47 +++++++++++++++++++++++------- 2 files changed, 56 insertions(+), 12 deletions(-) diff --git a/src/fsfw/util/dataWrapper.h b/src/fsfw/util/dataWrapper.h index 440f95013..ac4404f11 100644 --- a/src/fsfw/util/dataWrapper.h +++ b/src/fsfw/util/dataWrapper.h @@ -9,6 +9,8 @@ namespace util { +using BufPair = std::pair; + struct RawData { RawData() = default; const uint8_t* data = nullptr; @@ -23,9 +25,24 @@ union DataUnion { }; struct DataWrapper { + + + DataWrapper() = default; + + DataWrapper(const uint8_t* data, size_t size): type(DataTypes::RAW) { + setRawData({data, size}); + } + + explicit DataWrapper(BufPair raw): type(DataTypes::RAW) { + setRawData(raw); + } + + explicit DataWrapper(SerializeIF& serializable): type(DataTypes::SERIALIZABLE) { + setSerializable(serializable); + } + DataTypes type = DataTypes::NONE; DataUnion dataUnion; - using BufPairT = std::pair; [[nodiscard]] size_t getLength() const { if (type == DataTypes::RAW) { @@ -43,7 +60,7 @@ struct DataWrapper { } return false; } - void setRawData(BufPairT bufPair) { + void setRawData(BufPair bufPair) { type = DataTypes::RAW; dataUnion.raw.data = bufPair.first; dataUnion.raw.len = bufPair.second; diff --git a/unittests/util/testDataWrapper.cpp b/unittests/util/testDataWrapper.cpp index 14ba287ab..72931d902 100644 --- a/unittests/util/testDataWrapper.cpp +++ b/unittests/util/testDataWrapper.cpp @@ -12,21 +12,48 @@ TEST_CASE("Data Wrapper", "[util]") { } SECTION("Set Raw Data") { + util::DataWrapper* instance = &wrapper; + bool deleteInst = false; REQUIRE(wrapper.isNull()); std::array data = {1, 2, 3, 4}; - wrapper.setRawData({data.data(), data.size()}); - REQUIRE(not wrapper.isNull()); - REQUIRE(wrapper.type == util::DataTypes::RAW); - REQUIRE(wrapper.dataUnion.raw.data == data.data()); - REQUIRE(wrapper.dataUnion.raw.len == data.size()); + SECTION("Setter") { + wrapper.setRawData({data.data(), data.size()}); + } + SECTION("Direct Construction Pair") { + instance = new util::DataWrapper(util::BufPair(data.data(), data.size())); + deleteInst = true; + } + SECTION("Direct Construction Single Args") { + instance = new util::DataWrapper(data.data(), data.size()); + deleteInst = true; + } + REQUIRE(not instance->isNull()); + REQUIRE(instance->type == util::DataTypes::RAW); + REQUIRE(instance->dataUnion.raw.data == data.data()); + REQUIRE(instance->dataUnion.raw.len == data.size()); + if(deleteInst) { + delete instance; + } } SECTION("Simple Serializable") { - REQUIRE(wrapper.isNull()); + util::DataWrapper* instance = &wrapper; + bool deleteInst = false; + REQUIRE(instance->isNull()); SimpleSerializable serializable; - wrapper.setSerializable(serializable); - REQUIRE(not wrapper.isNull()); - REQUIRE(wrapper.type == util::DataTypes::SERIALIZABLE); - REQUIRE(wrapper.dataUnion.serializable == &serializable); + SECTION("Setter") { + wrapper.setSerializable(serializable); + } + SECTION("Direct Construction") { + instance = new util::DataWrapper(serializable); + deleteInst = true; + } + + REQUIRE(not instance->isNull()); + REQUIRE(instance->type == util::DataTypes::SERIALIZABLE); + REQUIRE(instance->dataUnion.serializable == &serializable); + if(deleteInst) { + delete instance; + } } } \ No newline at end of file -- 2.34.1 From 5ff28ff5622bdcd57bbff3c7ce28382eda7edbea Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Tue, 30 Aug 2022 16:04:20 +0200 Subject: [PATCH 10/10] remove newline --- src/fsfw/util/dataWrapper.h | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/fsfw/util/dataWrapper.h b/src/fsfw/util/dataWrapper.h index ac4404f11..6c953281b 100644 --- a/src/fsfw/util/dataWrapper.h +++ b/src/fsfw/util/dataWrapper.h @@ -25,8 +25,7 @@ union DataUnion { }; struct DataWrapper { - - + DataWrapper() = default; DataWrapper(const uint8_t* data, size_t size): type(DataTypes::RAW) { -- 2.34.1