action
container
contrib
controller
coordinates
datalinklayer
datapool
datapoollocal
defaultcfg
devicehandlers
doc
events
fdir
globalfunctions
health
housekeeping
internalError
ipc
logo
memory
modes
monitoring
objectmanager
osal
parameters
power
pus
returnvalues
rmap
serialize
serviceinterface
storagemanager
subsystem
tasks
tcdistribution
thermal
timemanager
tmstorage
tmtcpacket
tmtcservices
unittest
internal
tests
action
container
datapoollocal
CMakeLists.txt
DataSetTest.cpp
LocalPoolManagerTest.cpp
LocalPoolOwnerBase.h
LocalPoolVariableTest.cpp
LocalPoolVectorTest.cpp
globalfunctions
mocks
osal
serialize
storagemanager
CMakeLists.txt
tests.mk
user
CMakeLists.txt
README.md
lcov.sh
.gitignore
.gitmodules
CHANGELOG
CMakeLists.txt
FSFWVersion.h
LICENSE
NOTICE
README.md
fsfw.mk
124 lines
5.1 KiB
C++
124 lines
5.1 KiB
C++
#include "LocalPoolOwnerBase.h"
|
|
|
|
#include <catch2/catch_test_macros.hpp>
|
|
#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
|
|
#include <unittest/core/CatchDefinitions.h>
|
|
|
|
|
|
TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
|
|
LocalPoolOwnerBase* poolOwner = objectManager->
|
|
get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
|
|
REQUIRE(poolOwner != nullptr);
|
|
REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
|
|
REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
|
|
== retval::CATCH_OK);
|
|
|
|
SECTION("Basic Tests") {
|
|
/* very basic test. */
|
|
lp_var_t<uint8_t> testVariable = lp_var_t<uint8_t>(
|
|
objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);
|
|
REQUIRE(testVariable.read() == retval::CATCH_OK);
|
|
CHECK(testVariable.value == 0);
|
|
testVariable.value = 5;
|
|
REQUIRE(testVariable.commit() == retval::CATCH_OK);
|
|
REQUIRE(testVariable.read() == retval::CATCH_OK);
|
|
REQUIRE(testVariable.value == 5);
|
|
CHECK(not testVariable.isValid());
|
|
testVariable.setValid(true);
|
|
CHECK(testVariable.isValid());
|
|
CHECK(testVariable.commit(true) == retval::CATCH_OK);
|
|
|
|
testVariable.setReadWriteMode(pool_rwm_t::VAR_READ);
|
|
CHECK(testVariable.getReadWriteMode() == pool_rwm_t::VAR_READ);
|
|
testVariable.setReadWriteMode(pool_rwm_t::VAR_READ_WRITE);
|
|
|
|
testVariable.setDataPoolId(22);
|
|
CHECK(testVariable.getDataPoolId() == 22);
|
|
testVariable.setDataPoolId(lpool::uint8VarId);
|
|
|
|
testVariable.setChanged(true);
|
|
CHECK(testVariable.hasChanged());
|
|
testVariable.setChanged(false);
|
|
|
|
gp_id_t globPoolId(objects::TEST_LOCAL_POOL_OWNER_BASE,
|
|
lpool::uint8VarId);
|
|
lp_var_t<uint8_t> testVariable2 = lp_var_t<uint8_t>(globPoolId);
|
|
REQUIRE(testVariable2.read() == retval::CATCH_OK);
|
|
CHECK(testVariable2 == 5);
|
|
CHECK(testVariable == testVariable2);
|
|
testVariable = 10;
|
|
CHECK(testVariable != 5);
|
|
//CHECK(not testVariable != testVariable2);
|
|
uint8_t variableRaw = 0;
|
|
uint8_t* varPtr = &variableRaw;
|
|
size_t maxSize = testVariable.getSerializedSize();
|
|
CHECK(maxSize == 1);
|
|
size_t serSize = 0;
|
|
CHECK(testVariable.serialize(&varPtr, &serSize, maxSize,
|
|
SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
|
|
CHECK(variableRaw == 10);
|
|
const uint8_t* varConstPtr = &variableRaw;
|
|
testVariable = 5;
|
|
CHECK(testVariable.deSerialize(&varConstPtr, &serSize,
|
|
SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
|
|
CHECK(testVariable == 10);
|
|
CHECK(testVariable != testVariable2);
|
|
CHECK(testVariable2 < testVariable);
|
|
CHECK(testVariable2 < 10);
|
|
CHECK(testVariable > 5);
|
|
CHECK(testVariable > testVariable2);
|
|
variableRaw = static_cast<uint8_t>(testVariable2);
|
|
CHECK(variableRaw == 5);
|
|
|
|
CHECK(testVariable == 10);
|
|
testVariable = testVariable2;
|
|
CHECK(testVariable == 5);
|
|
}
|
|
|
|
SECTION("ErrorHandling") {
|
|
|
|
/* now try to use a local pool variable which does not exist */
|
|
lp_var_t<uint8_t> invalidVariable = lp_var_t<uint8_t>(
|
|
objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff);
|
|
REQUIRE(invalidVariable.read() ==
|
|
static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
|
|
|
|
REQUIRE(invalidVariable.commit() ==
|
|
static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
|
|
/* now try to access with wrong type */
|
|
lp_var_t<int8_t> invalidVariable2 = lp_var_t<int8_t>(
|
|
objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);
|
|
REQUIRE(invalidVariable2.read() ==
|
|
static_cast<int>(localpool::POOL_ENTRY_TYPE_CONFLICT));
|
|
|
|
lp_var_t<uint8_t> readOnlyVar = lp_var_t<uint8_t>(
|
|
objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId,
|
|
nullptr, pool_rwm_t::VAR_READ);
|
|
REQUIRE(readOnlyVar.commit() ==
|
|
static_cast<int>(PoolVariableIF::INVALID_READ_WRITE_MODE));
|
|
lp_var_t<uint8_t> writeOnlyVar = lp_var_t<uint8_t>(
|
|
objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId,
|
|
nullptr, pool_rwm_t::VAR_WRITE);
|
|
REQUIRE(writeOnlyVar.read() == static_cast<int>(
|
|
PoolVariableIF::INVALID_READ_WRITE_MODE));
|
|
|
|
lp_var_t<uint32_t> uint32tVar = lp_var_t<uint32_t>(
|
|
objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint32VarId);
|
|
#if FSFW_CPP_OSTREAM_ENABLED == 1
|
|
sif::info << "LocalPoolVariable printout: " <<uint32tVar << std::endl;
|
|
#endif
|
|
|
|
/* for code coverage. If program does not crash -> OK */
|
|
lp_var_t<uint8_t> invalidObjectVar = lp_var_t<uint8_t>(
|
|
0xffffffff, lpool::uint8VarId);
|
|
gp_id_t globPoolId(0xffffffff,
|
|
lpool::uint8VarId);
|
|
lp_var_t<uint8_t> invalidObjectVar2 = lp_var_t<uint8_t>(globPoolId);
|
|
lp_var_t<uint8_t> invalidObjectVar3 = lp_var_t<uint8_t>(nullptr,
|
|
lpool::uint8VarId);
|
|
}
|
|
|
|
}
|
|
|
|
|