From e245f56a4f47d3cde6ce266d981347a6097e56f1 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Sun, 24 Jan 2021 21:18:22 +0100 Subject: [PATCH] updated indentation --- unittest/tests/datapoollocal/DataSetTest.cpp | 22 +- .../datapoollocal/LocalPoolManagerTest.cpp | 196 ++++++------- .../tests/datapoollocal/LocalPoolOwnerBase.h | 266 +++++++++--------- .../datapoollocal/LocalPoolVariableTest.cpp | 194 ++++++------- .../datapoollocal/LocalPoolVectorTest.cpp | 182 ++++++------ 5 files changed, 430 insertions(+), 430 deletions(-) diff --git a/unittest/tests/datapoollocal/DataSetTest.cpp b/unittest/tests/datapoollocal/DataSetTest.cpp index 968a0b3d..5c2428ae 100644 --- a/unittest/tests/datapoollocal/DataSetTest.cpp +++ b/unittest/tests/datapoollocal/DataSetTest.cpp @@ -6,17 +6,17 @@ #include TEST_CASE("LocalDataSet" , "[LocDataSetTest]") { - LocalPoolOwnerBase* poolOwner = objectManager-> - get(objects::TEST_LOCAL_POOL_OWNER_BASE); - REQUIRE(poolOwner != nullptr); - REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK); - REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation() - == retval::CATCH_OK); - const uint32_t setId = 0; - SECTION("BasicTest") { - StaticLocalDataSet<3> localSet = StaticLocalDataSet<3>( - sid_t(objects::TEST_LOCAL_POOL_OWNER_BASE, setId)); - } + LocalPoolOwnerBase* poolOwner = objectManager-> + get(objects::TEST_LOCAL_POOL_OWNER_BASE); + REQUIRE(poolOwner != nullptr); + REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK); + REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation() + == retval::CATCH_OK); + const uint32_t setId = 0; + SECTION("BasicTest") { + StaticLocalDataSet<3> localSet = StaticLocalDataSet<3>( + sid_t(objects::TEST_LOCAL_POOL_OWNER_BASE, setId)); + } } diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp index f550582e..ccd8e70e 100644 --- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp +++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp @@ -8,115 +8,115 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") { - LocalPoolOwnerBase* poolOwner = objectManager-> - get(objects::TEST_LOCAL_POOL_OWNER_BASE); - REQUIRE(poolOwner != nullptr); - REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK); - REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation() - == retval::CATCH_OK); - REQUIRE(poolOwner->dataset.assignPointers() == retval::CATCH_OK); - MessageQueueMockBase* mqMock = poolOwner->getMockQueueHandle(); - REQUIRE(mqMock != nullptr); - CommandMessage messageSent; - uint8_t messagesSent = 0; + LocalPoolOwnerBase* poolOwner = objectManager-> + get(objects::TEST_LOCAL_POOL_OWNER_BASE); + REQUIRE(poolOwner != nullptr); + REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK); + REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation() + == retval::CATCH_OK); + REQUIRE(poolOwner->dataset.assignPointers() == retval::CATCH_OK); + MessageQueueMockBase* mqMock = poolOwner->getMockQueueHandle(); + REQUIRE(mqMock != nullptr); + CommandMessage messageSent; + uint8_t messagesSent = 0; - SECTION("BasicTest") { - // Subscribe for message generation on update. - REQUIRE(poolOwner->subscribeWrapperSetUpdate() == retval::CATCH_OK); - // Subscribe for an update message. - poolOwner->dataset.setChanged(true); - // Now the update message should be generated. - REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK); - REQUIRE(mqMock->wasMessageSent() == true); + SECTION("BasicTest") { + /* Subscribe for message generation on update. */ + REQUIRE(poolOwner->subscribeWrapperSetUpdate() == retval::CATCH_OK); + /* Subscribe for an update message. */ + poolOwner->dataset.setChanged(true); + /* Now the update message should be generated. */ + REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK); + REQUIRE(mqMock->wasMessageSent() == true); - REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK); - CHECK(messageSent.getCommand() == static_cast( - HousekeepingMessage::UPDATE_NOTIFICATION_SET)); + REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK); + CHECK(messageSent.getCommand() == static_cast( + HousekeepingMessage::UPDATE_NOTIFICATION_SET)); - // Should have been reset. - CHECK(poolOwner->dataset.hasChanged() == false); - // Set changed again, result should be the same. - poolOwner->dataset.setChanged(true); - REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK); + /* Should have been reset. */ + CHECK(poolOwner->dataset.hasChanged() == false); + /* Set changed again, result should be the same. */ + poolOwner->dataset.setChanged(true); + REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK); - REQUIRE(mqMock->wasMessageSent(&messagesSent) == true); - CHECK(messagesSent == 1); - REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK); - CHECK(messageSent.getCommand() == static_cast( - HousekeepingMessage::UPDATE_NOTIFICATION_SET)); + REQUIRE(mqMock->wasMessageSent(&messagesSent) == true); + CHECK(messagesSent == 1); + REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK); + CHECK(messageSent.getCommand() == static_cast( + HousekeepingMessage::UPDATE_NOTIFICATION_SET)); - // now subscribe for set update HK as well. - REQUIRE(poolOwner->subscribeWrapperSetUpdateHk() == retval::CATCH_OK); - poolOwner->dataset.setChanged(true); - REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK); - REQUIRE(mqMock->wasMessageSent(&messagesSent) == true); - CHECK(messagesSent == 2); - // first message sent should be the update notification, considering - // the internal list is a vector checked in insertion order. - REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK); - CHECK(messageSent.getCommand() == static_cast( - HousekeepingMessage::UPDATE_NOTIFICATION_SET)); + /* Now subscribe for set update HK as well. */ + REQUIRE(poolOwner->subscribeWrapperSetUpdateHk() == retval::CATCH_OK); + poolOwner->dataset.setChanged(true); + REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK); + REQUIRE(mqMock->wasMessageSent(&messagesSent) == true); + CHECK(messagesSent == 2); + /* first message sent should be the update notification, considering + the internal list is a vector checked in insertion order. */ + REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK); + CHECK(messageSent.getCommand() == static_cast( + HousekeepingMessage::UPDATE_NOTIFICATION_SET)); - REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK); - CHECK(messageSent.getCommand() == static_cast( - HousekeepingMessage::HK_REPORT)); - // clear message to avoid memory leak, our mock won't do it for us (yet) - CommandMessageCleaner::clearCommandMessage(&messageSent); - } + REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK); + CHECK(messageSent.getCommand() == static_cast( + HousekeepingMessage::HK_REPORT)); + /* Clear message to avoid memory leak, our mock won't do it for us (yet) */ + CommandMessageCleaner::clearCommandMessage(&messageSent); + } - SECTION("AdvancedTests") { - // we need to reset the subscription list because the pool owner - // is a global object. - poolOwner->resetSubscriptionList(); - // Subscribe for variable update as well - REQUIRE(not poolOwner->dataset.hasChanged()); - REQUIRE(poolOwner->subscribeWrapperVariableUpdate(lpool::uint8VarId) == - retval::CATCH_OK); - lp_var_t* poolVar = dynamic_cast*>( - poolOwner->getPoolObjectHandle(lpool::uint8VarId)); - REQUIRE(poolVar != nullptr); - poolVar->setChanged(true); - REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK); + SECTION("AdvancedTests") { + /* we need to reset the subscription list because the pool owner + is a global object. */ + poolOwner->resetSubscriptionList(); + /* Subscribe for variable update as well */ + REQUIRE(not poolOwner->dataset.hasChanged()); + REQUIRE(poolOwner->subscribeWrapperVariableUpdate(lpool::uint8VarId) == + retval::CATCH_OK); + lp_var_t* poolVar = dynamic_cast*>( + poolOwner->getPoolObjectHandle(lpool::uint8VarId)); + REQUIRE(poolVar != nullptr); + poolVar->setChanged(true); + REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK); - // Check update notification was sent. - REQUIRE(mqMock->wasMessageSent(&messagesSent) == true); - CHECK(messagesSent == 1); - // Should have been reset. - CHECK(poolVar->hasChanged() == false); - REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK); - CHECK(messageSent.getCommand() == static_cast( - HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE)); + /* Check update notification was sent. */ + REQUIRE(mqMock->wasMessageSent(&messagesSent) == true); + CHECK(messagesSent == 1); + /* Should have been reset. */ + CHECK(poolVar->hasChanged() == false); + REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK); + CHECK(messageSent.getCommand() == static_cast( + HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE)); - // now subscribe for the dataset update (HK and update) again - REQUIRE(poolOwner->subscribeWrapperSetUpdate() == retval::CATCH_OK); - REQUIRE(poolOwner->subscribeWrapperSetUpdateHk() == retval::CATCH_OK); + /* Now subscribe for the dataset update (HK and update) again */ + REQUIRE(poolOwner->subscribeWrapperSetUpdate() == retval::CATCH_OK); + REQUIRE(poolOwner->subscribeWrapperSetUpdateHk() == retval::CATCH_OK); - poolOwner->dataset.setChanged(true); - REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK); - // now two messages should be sent. - REQUIRE(mqMock->wasMessageSent(&messagesSent) == true); - CHECK(messagesSent == 2); - mqMock->clearMessages(true); + poolOwner->dataset.setChanged(true); + REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK); + /* Now two messages should be sent. */ + REQUIRE(mqMock->wasMessageSent(&messagesSent) == true); + CHECK(messagesSent == 2); + mqMock->clearMessages(true); - poolOwner->dataset.setChanged(true); - poolVar->setChanged(true); - REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK); - // now three messages should be sent. - REQUIRE(mqMock->wasMessageSent(&messagesSent) == true); - CHECK(messagesSent == 3); - REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK); - CHECK(messageSent.getCommand() == static_cast( - HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE)); - REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK); - CHECK(messageSent.getCommand() == static_cast( - HousekeepingMessage::UPDATE_NOTIFICATION_SET)); - REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK); - CHECK(messageSent.getCommand() == static_cast( - HousekeepingMessage::HK_REPORT)); - CommandMessageCleaner::clearCommandMessage(&messageSent); - REQUIRE(mqMock->receiveMessage(&messageSent) == - static_cast(MessageQueueIF::EMPTY)); - } + poolOwner->dataset.setChanged(true); + poolVar->setChanged(true); + REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK); + /* Now three messages should be sent. */ + REQUIRE(mqMock->wasMessageSent(&messagesSent) == true); + CHECK(messagesSent == 3); + REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK); + CHECK(messageSent.getCommand() == static_cast( + HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE)); + REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK); + CHECK(messageSent.getCommand() == static_cast( + HousekeepingMessage::UPDATE_NOTIFICATION_SET)); + REQUIRE(mqMock->receiveMessage(&messageSent) == retval::CATCH_OK); + CHECK(messageSent.getCommand() == static_cast( + HousekeepingMessage::HK_REPORT)); + CommandMessageCleaner::clearCommandMessage(&messageSent); + REQUIRE(mqMock->receiveMessage(&messageSent) == + static_cast(MessageQueueIF::EMPTY)); + } } diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h index 916b3e45..737f2613 100644 --- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h +++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h @@ -21,32 +21,32 @@ static constexpr lp_id_t int64Vec2Id = 4; static constexpr uint32_t testSetId = 0; static constexpr uint8_t dataSetMaxVariables = 10; static const sid_t testSid = sid_t(objects::TEST_LOCAL_POOL_OWNER_BASE, - testSetId); + testSetId); } class LocalPoolTestDataSet: public LocalDataSet { public: - LocalPoolTestDataSet(HasLocalDataPoolIF* owner, uint32_t setId): - LocalDataSet(owner, setId, lpool::dataSetMaxVariables) { - } + LocalPoolTestDataSet(HasLocalDataPoolIF* owner, uint32_t setId): + LocalDataSet(owner, setId, lpool::dataSetMaxVariables) { + } - ReturnValue_t assignPointers() { - PoolVariableIF** rawVarArray = getContainer(); - localPoolVarUint8 = dynamic_cast*>(rawVarArray[0]); - localPoolVarFloat = dynamic_cast*>(rawVarArray[1]); - localPoolUint16Vec = dynamic_cast*>( - rawVarArray[2]); - if(localPoolVarUint8 == nullptr or localPoolVarFloat == nullptr or - localPoolUint16Vec == nullptr) { - return HasReturnvaluesIF::RETURN_FAILED; - } - return HasReturnvaluesIF::RETURN_OK; - } + ReturnValue_t assignPointers() { + PoolVariableIF** rawVarArray = getContainer(); + localPoolVarUint8 = dynamic_cast*>(rawVarArray[0]); + localPoolVarFloat = dynamic_cast*>(rawVarArray[1]); + localPoolUint16Vec = dynamic_cast*>( + rawVarArray[2]); + if(localPoolVarUint8 == nullptr or localPoolVarFloat == nullptr or + localPoolUint16Vec == nullptr) { + return HasReturnvaluesIF::RETURN_FAILED; + } + return HasReturnvaluesIF::RETURN_OK; + } - lp_var_t* localPoolVarUint8 = nullptr; - lp_var_t* localPoolVarFloat = nullptr; - lp_vec_t* localPoolUint16Vec = nullptr; + lp_var_t* localPoolVarUint8 = nullptr; + lp_var_t* localPoolVarFloat = nullptr; + lp_vec_t* localPoolUint16Vec = nullptr; private: }; @@ -54,143 +54,143 @@ private: class LocalPoolOwnerBase: public SystemObject, public HasLocalDataPoolIF { public: - LocalPoolOwnerBase( - object_id_t objectId = objects::TEST_LOCAL_POOL_OWNER_BASE): - SystemObject(objectId), poolManager(this, messageQueue), - dataset(this, lpool::testSetId) { - messageQueue = new MessageQueueMockBase(); - } + LocalPoolOwnerBase( + object_id_t objectId = objects::TEST_LOCAL_POOL_OWNER_BASE): + SystemObject(objectId), poolManager(this, messageQueue), + dataset(this, lpool::testSetId) { + messageQueue = new MessageQueueMockBase(); + } - ~LocalPoolOwnerBase() { - QueueFactory::instance()->deleteMessageQueue(messageQueue); - } + ~LocalPoolOwnerBase() { + QueueFactory::instance()->deleteMessageQueue(messageQueue); + } - object_id_t getObjectId() const override { - return SystemObject::getObjectId(); - } + object_id_t getObjectId() const override { + return SystemObject::getObjectId(); + } - ReturnValue_t initializeHkManager() { - if(not initialized) { - initialized = true; - return poolManager.initialize(messageQueue); - } - return HasReturnvaluesIF::RETURN_OK; - } + ReturnValue_t initializeHkManager() { + if(not initialized) { + initialized = true; + return poolManager.initialize(messageQueue); + } + return HasReturnvaluesIF::RETURN_OK; + } - ReturnValue_t initializeHkManagerAfterTaskCreation() { - if(not initializedAfterTaskCreation) { - initializedAfterTaskCreation = true; - return poolManager.initializeAfterTaskCreation(); - } - return HasReturnvaluesIF::RETURN_OK; - } + ReturnValue_t initializeHkManagerAfterTaskCreation() { + if(not initializedAfterTaskCreation) { + initializedAfterTaskCreation = true; + return poolManager.initializeAfterTaskCreation(); + } + return HasReturnvaluesIF::RETURN_OK; + } - /** Command queue for housekeeping messages. */ - MessageQueueId_t getCommandQueue() const override { - return messageQueue->getId(); - } + /** Command queue for housekeeping messages. */ + MessageQueueId_t getCommandQueue() const override { + return messageQueue->getId(); + } - // This is called by initializeAfterTaskCreation of the HK manager. - virtual ReturnValue_t initializeLocalDataPool( - localpool::DataPool& localDataPoolMap, - LocalDataPoolManager& poolManager) { - // Default initialization empty for now. - localDataPoolMap.emplace(lpool::uint8VarId, - new PoolEntry({0})); - localDataPoolMap.emplace(lpool::floatVarId, - new PoolEntry({0})); - localDataPoolMap.emplace(lpool::uint32VarId, - new PoolEntry({0})); + // This is called by initializeAfterTaskCreation of the HK manager. + virtual ReturnValue_t initializeLocalDataPool( + localpool::DataPool& localDataPoolMap, + LocalDataPoolManager& poolManager) { + // Default initialization empty for now. + localDataPoolMap.emplace(lpool::uint8VarId, + new PoolEntry({0})); + localDataPoolMap.emplace(lpool::floatVarId, + new PoolEntry({0})); + localDataPoolMap.emplace(lpool::uint32VarId, + new PoolEntry({0})); - localDataPoolMap.emplace(lpool::uint16Vec3Id, - new PoolEntry({0, 0, 0})); - localDataPoolMap.emplace(lpool::int64Vec2Id, - new PoolEntry({0, 0})); - return HasReturnvaluesIF::RETURN_OK; - } + localDataPoolMap.emplace(lpool::uint16Vec3Id, + new PoolEntry({0, 0, 0})); + localDataPoolMap.emplace(lpool::int64Vec2Id, + new PoolEntry({0, 0})); + return HasReturnvaluesIF::RETURN_OK; + } - LocalDataPoolManager* getHkManagerHandle() override { - return &poolManager; - } + LocalDataPoolManager* getHkManagerHandle() override { + return &poolManager; + } - uint32_t getPeriodicOperationFrequency() const override { - return 0; - } + uint32_t getPeriodicOperationFrequency() const override { + return 0; + } - /** - * This function is used by the pool manager to get a valid dataset + /** + * This function is used by the pool manager to get a valid dataset * from a SID - * @param sid Corresponding structure ID - * @return - */ - virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override { - return &dataset; - } + * @param sid Corresponding structure ID + * @return + */ + virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override { + return &dataset; + } - virtual LocalPoolObjectBase* getPoolObjectHandle( - lp_id_t localPoolId) override { - if(localPoolId == lpool::uint8VarId) { - return &testUint8; - } - else if(localPoolId == lpool::uint16Vec3Id) { - return &testUint16Vec; - } - else if(localPoolId == lpool::floatVarId) { - return &testFloat; - } - else if(localPoolId == lpool::int64Vec2Id) { - return &testInt64Vec; - } - else if(localPoolId == lpool::uint32VarId) { - return &testUint32; - } - else { - return &testUint8; - } - } + virtual LocalPoolObjectBase* getPoolObjectHandle( + lp_id_t localPoolId) override { + if(localPoolId == lpool::uint8VarId) { + return &testUint8; + } + else if(localPoolId == lpool::uint16Vec3Id) { + return &testUint16Vec; + } + else if(localPoolId == lpool::floatVarId) { + return &testFloat; + } + else if(localPoolId == lpool::int64Vec2Id) { + return &testInt64Vec; + } + else if(localPoolId == lpool::uint32VarId) { + return &testUint32; + } + else { + return &testUint8; + } + } - MessageQueueMockBase* getMockQueueHandle() const { - return dynamic_cast(messageQueue); - } + MessageQueueMockBase* getMockQueueHandle() const { + return dynamic_cast(messageQueue); + } - ReturnValue_t subscribeWrapperSetUpdate() { - return poolManager.subscribeForSetUpdateMessages(lpool::testSetId, - objects::NO_OBJECT, MessageQueueIF::NO_QUEUE, false); - } + ReturnValue_t subscribeWrapperSetUpdate() { + return poolManager.subscribeForSetUpdateMessages(lpool::testSetId, + objects::NO_OBJECT, MessageQueueIF::NO_QUEUE, false); + } - ReturnValue_t subscribeWrapperSetUpdateHk(bool diagnostics = false) { - return poolManager.subscribeForUpdatePackets(lpool::testSid, diagnostics, - false, objects::HK_RECEIVER_MOCK); - } + ReturnValue_t subscribeWrapperSetUpdateHk(bool diagnostics = false) { + return poolManager.subscribeForUpdatePackets(lpool::testSid, diagnostics, + false, objects::HK_RECEIVER_MOCK); + } - ReturnValue_t subscribeWrapperVariableUpdate(lp_id_t localPoolId) { - return poolManager.subscribeForVariableUpdateMessages(localPoolId, - MessageQueueIF::NO_QUEUE, objects::NO_OBJECT, false); - } + ReturnValue_t subscribeWrapperVariableUpdate(lp_id_t localPoolId) { + return poolManager.subscribeForVariableUpdateMessages(localPoolId, + MessageQueueIF::NO_QUEUE, objects::NO_OBJECT, false); + } - void resetSubscriptionList() { - poolManager.clearReceiversList(); - } + void resetSubscriptionList() { + poolManager.clearReceiversList(); + } - LocalDataPoolManager poolManager; - LocalPoolTestDataSet dataset; + LocalDataPoolManager poolManager; + LocalPoolTestDataSet dataset; private: - lp_var_t testUint8 = lp_var_t(this, lpool::uint8VarId, - &dataset); - lp_var_t testFloat = lp_var_t(this, lpool::floatVarId, - &dataset); - lp_var_t testUint32 = lp_var_t(this, lpool::uint32VarId); + lp_var_t testUint8 = lp_var_t(this, lpool::uint8VarId, + &dataset); + lp_var_t testFloat = lp_var_t(this, lpool::floatVarId, + &dataset); + lp_var_t testUint32 = lp_var_t(this, lpool::uint32VarId); - lp_vec_t testUint16Vec = lp_vec_t(this, - lpool::uint16Vec3Id, &dataset); - lp_vec_t testInt64Vec = lp_vec_t(this, - lpool::int64Vec2Id); + lp_vec_t testUint16Vec = lp_vec_t(this, + lpool::uint16Vec3Id, &dataset); + lp_vec_t testInt64Vec = lp_vec_t(this, + lpool::int64Vec2Id); - MessageQueueIF* messageQueue = nullptr; + MessageQueueIF* messageQueue = nullptr; - bool initialized = false; - bool initializedAfterTaskCreation = false; + bool initialized = false; + bool initializedAfterTaskCreation = false; }; diff --git a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp index 2e4cb7ec..eb99e58d 100644 --- a/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp +++ b/unittest/tests/datapoollocal/LocalPoolVariableTest.cpp @@ -6,117 +6,117 @@ TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") { - LocalPoolOwnerBase* poolOwner = objectManager-> - get(objects::TEST_LOCAL_POOL_OWNER_BASE); - REQUIRE(poolOwner != nullptr); - REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK); - REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation() - == retval::CATCH_OK); + LocalPoolOwnerBase* poolOwner = objectManager-> + get(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 testVariable = lp_var_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); + SECTION("Basic Tests") { + /* very basic test. */ + lp_var_t testVariable = lp_var_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.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.setDataPoolId(22); + CHECK(testVariable.getDataPoolId() == 22); + testVariable.setDataPoolId(lpool::uint8VarId); - testVariable.setChanged(true); - CHECK(testVariable.hasChanged()); - testVariable.setChanged(false); + testVariable.setChanged(true); + CHECK(testVariable.hasChanged()); + testVariable.setChanged(false); - gp_id_t globPoolId(objects::TEST_LOCAL_POOL_OWNER_BASE, - lpool::uint8VarId); - lp_var_t testVariable2 = lp_var_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(testVariable2); - CHECK(variableRaw == 5); + gp_id_t globPoolId(objects::TEST_LOCAL_POOL_OWNER_BASE, + lpool::uint8VarId); + lp_var_t testVariable2 = lp_var_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(testVariable2); + CHECK(variableRaw == 5); - CHECK(testVariable == 10); - testVariable = testVariable2; - CHECK(testVariable == 5); - } + CHECK(testVariable == 10); + testVariable = testVariable2; + CHECK(testVariable == 5); + } - SECTION("ErrorHandling") { + SECTION("ErrorHandling") { - // not try to use a local pool variable which does not exist - lp_var_t invalidVariable = lp_var_t( - objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff); - REQUIRE(invalidVariable.read() == - static_cast(localpool::POOL_ENTRY_NOT_FOUND)); + /* now try to use a local pool variable which does not exist */ + lp_var_t invalidVariable = lp_var_t( + objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff); + REQUIRE(invalidVariable.read() == + static_cast(localpool::POOL_ENTRY_NOT_FOUND)); - REQUIRE(invalidVariable.commit() == - static_cast(localpool::POOL_ENTRY_NOT_FOUND)); - // now try to access with wrong type - lp_var_t invalidVariable2 = lp_var_t( - objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId); - REQUIRE(invalidVariable2.read() == - static_cast(localpool::POOL_ENTRY_TYPE_CONFLICT)); + REQUIRE(invalidVariable.commit() == + static_cast(localpool::POOL_ENTRY_NOT_FOUND)); + /* now try to access with wrong type */ + lp_var_t invalidVariable2 = lp_var_t( + objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId); + REQUIRE(invalidVariable2.read() == + static_cast(localpool::POOL_ENTRY_TYPE_CONFLICT)); - lp_var_t readOnlyVar = lp_var_t( - objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId, - nullptr, pool_rwm_t::VAR_READ); - REQUIRE(readOnlyVar.commit() == - static_cast(PoolVariableIF::INVALID_READ_WRITE_MODE)); - lp_var_t writeOnlyVar = lp_var_t( - objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId, - nullptr, pool_rwm_t::VAR_WRITE); - REQUIRE(writeOnlyVar.read() == static_cast( - PoolVariableIF::INVALID_READ_WRITE_MODE)); + lp_var_t readOnlyVar = lp_var_t( + objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId, + nullptr, pool_rwm_t::VAR_READ); + REQUIRE(readOnlyVar.commit() == + static_cast(PoolVariableIF::INVALID_READ_WRITE_MODE)); + lp_var_t writeOnlyVar = lp_var_t( + objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId, + nullptr, pool_rwm_t::VAR_WRITE); + REQUIRE(writeOnlyVar.read() == static_cast( + PoolVariableIF::INVALID_READ_WRITE_MODE)); - lp_var_t uint32tVar = lp_var_t( - objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint32VarId); + lp_var_t uint32tVar = lp_var_t( + objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint32VarId); #if FSFW_CPP_OSTREAM_ENABLED == 1 - sif::info << "LocalPoolVariable printout: " < OK - lp_var_t invalidObjectVar = lp_var_t( - 0xffffffff, lpool::uint8VarId); - gp_id_t globPoolId(0xffffffff, - lpool::uint8VarId); - lp_var_t invalidObjectVar2 = lp_var_t(globPoolId); - lp_var_t invalidObjectVar3 = lp_var_t(nullptr, - lpool::uint8VarId); - } + /* for code coverage. If program does not crash -> OK */ + lp_var_t invalidObjectVar = lp_var_t( + 0xffffffff, lpool::uint8VarId); + gp_id_t globPoolId(0xffffffff, + lpool::uint8VarId); + lp_var_t invalidObjectVar2 = lp_var_t(globPoolId); + lp_var_t invalidObjectVar3 = lp_var_t(nullptr, + lpool::uint8VarId); + } } diff --git a/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp b/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp index 7c309bbb..2bc47568 100644 --- a/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp +++ b/unittest/tests/datapoollocal/LocalPoolVectorTest.cpp @@ -5,116 +5,116 @@ #include TEST_CASE("LocalPoolVector" , "[LocPoolVecTest]") { - LocalPoolOwnerBase* poolOwner = objectManager-> - get(objects::TEST_LOCAL_POOL_OWNER_BASE); - REQUIRE(poolOwner != nullptr); - REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK); - REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation() - == retval::CATCH_OK); + LocalPoolOwnerBase* poolOwner = objectManager-> + get(objects::TEST_LOCAL_POOL_OWNER_BASE); + REQUIRE(poolOwner != nullptr); + REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK); + REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation() + == retval::CATCH_OK); - SECTION("BasicTest") { - // very basic test. - lp_vec_t testVector = lp_vec_t( - objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id); - REQUIRE(testVector.read() == retval::CATCH_OK); - testVector.value[0] = 5; - testVector.value[1] = 232; - testVector.value[2] = 32023; + SECTION("BasicTest") { + // very basic test. + lp_vec_t testVector = lp_vec_t( + objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id); + REQUIRE(testVector.read() == retval::CATCH_OK); + testVector.value[0] = 5; + testVector.value[1] = 232; + testVector.value[2] = 32023; - REQUIRE(testVector.commit(true) == retval::CATCH_OK); - CHECK(testVector.isValid()); + REQUIRE(testVector.commit(true) == retval::CATCH_OK); + CHECK(testVector.isValid()); - testVector.value[0] = 0; - testVector.value[1] = 0; - testVector.value[2] = 0; + testVector.value[0] = 0; + testVector.value[1] = 0; + testVector.value[2] = 0; - CHECK(testVector.read() == retval::CATCH_OK); - CHECK(testVector.value[0] == 5); - CHECK(testVector.value[1] == 232); - CHECK(testVector.value[2] == 32023); + CHECK(testVector.read() == retval::CATCH_OK); + CHECK(testVector.value[0] == 5); + CHECK(testVector.value[1] == 232); + CHECK(testVector.value[2] == 32023); - CHECK(testVector[0] == 5); + CHECK(testVector[0] == 5); - // This is invalid access, so the last value will be set instead. - // (we can't throw exceptions) - testVector[4] = 12; - CHECK(testVector[2] == 12); - CHECK(testVector.commit() == retval::CATCH_OK); + /* This is invalid access, so the last value will be set instead. + (we can't throw exceptions) */ + testVector[4] = 12; + CHECK(testVector[2] == 12); + CHECK(testVector.commit() == retval::CATCH_OK); - // Use read-only reference. - const lp_vec_t& roTestVec = testVector; - uint16_t valueOne = roTestVec[0]; - CHECK(valueOne == 5); + /* Use read-only reference. */ + const lp_vec_t& roTestVec = testVector; + uint16_t valueOne = roTestVec[0]; + CHECK(valueOne == 5); - uint16_t lastVal = roTestVec[25]; - CHECK(lastVal == 12); + uint16_t lastVal = roTestVec[25]; + CHECK(lastVal == 12); - size_t maxSize = testVector.getSerializedSize(); - CHECK(maxSize == 6); + size_t maxSize = testVector.getSerializedSize(); + CHECK(maxSize == 6); - uint16_t serializedVector[3]; - uint8_t* vecPtr = reinterpret_cast(serializedVector); - size_t serSize = 0; - REQUIRE(testVector.serialize(&vecPtr, &serSize, - maxSize, SerializeIF::Endianness::MACHINE) == retval::CATCH_OK); + uint16_t serializedVector[3]; + uint8_t* vecPtr = reinterpret_cast(serializedVector); + size_t serSize = 0; + REQUIRE(testVector.serialize(&vecPtr, &serSize, + maxSize, SerializeIF::Endianness::MACHINE) == retval::CATCH_OK); - CHECK(serSize == 6); - CHECK(serializedVector[0] == 5); - CHECK(serializedVector[1] == 232); - CHECK(serializedVector[2] == 12); + CHECK(serSize == 6); + CHECK(serializedVector[0] == 5); + CHECK(serializedVector[1] == 232); + CHECK(serializedVector[2] == 12); - maxSize = 1; - REQUIRE(testVector.serialize(&vecPtr, &serSize, - maxSize, SerializeIF::Endianness::MACHINE) == - static_cast(SerializeIF::BUFFER_TOO_SHORT)); + maxSize = 1; + REQUIRE(testVector.serialize(&vecPtr, &serSize, + maxSize, SerializeIF::Endianness::MACHINE) == + static_cast(SerializeIF::BUFFER_TOO_SHORT)); - serializedVector[0] = 16; - serializedVector[1] = 7832; - serializedVector[2] = 39232; + serializedVector[0] = 16; + serializedVector[1] = 7832; + serializedVector[2] = 39232; - const uint8_t* constVecPtr = reinterpret_cast( - serializedVector); - REQUIRE(testVector.deSerialize(&constVecPtr, &serSize, - SerializeIF::Endianness::MACHINE) == retval::CATCH_OK); - CHECK(testVector[0] == 16); - CHECK(testVector[1] == 7832); - CHECK(testVector[2] == 39232); + const uint8_t* constVecPtr = reinterpret_cast( + serializedVector); + REQUIRE(testVector.deSerialize(&constVecPtr, &serSize, + SerializeIF::Endianness::MACHINE) == retval::CATCH_OK); + CHECK(testVector[0] == 16); + CHECK(testVector[1] == 7832); + CHECK(testVector[2] == 39232); - serSize = 1; - REQUIRE(testVector.deSerialize(&constVecPtr, &serSize, - SerializeIF::Endianness::MACHINE) == - static_cast(SerializeIF::STREAM_TOO_SHORT)); - } + serSize = 1; + REQUIRE(testVector.deSerialize(&constVecPtr, &serSize, + SerializeIF::Endianness::MACHINE) == + static_cast(SerializeIF::STREAM_TOO_SHORT)); + } - SECTION("ErrorHandling") { - // not try to use a local pool variable which does not exist - lp_vec_t invalidVector = lp_vec_t( - objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff); - REQUIRE(invalidVector.read() == - static_cast(localpool::POOL_ENTRY_NOT_FOUND)); - REQUIRE(invalidVector.commit() == - static_cast(localpool::POOL_ENTRY_NOT_FOUND)); + SECTION("ErrorHandling") { + /* Now try to use a local pool variable which does not exist */ + lp_vec_t invalidVector = lp_vec_t( + objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff); + REQUIRE(invalidVector.read() == + static_cast(localpool::POOL_ENTRY_NOT_FOUND)); + REQUIRE(invalidVector.commit() == + static_cast(localpool::POOL_ENTRY_NOT_FOUND)); - // now try to access with wrong type - lp_vec_t invalidVector2 = lp_vec_t( - objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id); - REQUIRE(invalidVector2.read() == - static_cast(localpool::POOL_ENTRY_TYPE_CONFLICT)); - REQUIRE(invalidVector2.commit() == - static_cast(localpool::POOL_ENTRY_TYPE_CONFLICT)); + /* Now try to access with wrong type */ + lp_vec_t invalidVector2 = lp_vec_t( + objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id); + REQUIRE(invalidVector2.read() == + static_cast(localpool::POOL_ENTRY_TYPE_CONFLICT)); + REQUIRE(invalidVector2.commit() == + static_cast(localpool::POOL_ENTRY_TYPE_CONFLICT)); - lp_vec_t writeOnlyVec = lp_vec_t( - objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id, - nullptr, pool_rwm_t::VAR_WRITE); - REQUIRE(writeOnlyVec.read() == - static_cast(PoolVariableIF::INVALID_READ_WRITE_MODE)); + lp_vec_t writeOnlyVec = lp_vec_t( + objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id, + nullptr, pool_rwm_t::VAR_WRITE); + REQUIRE(writeOnlyVec.read() == + static_cast(PoolVariableIF::INVALID_READ_WRITE_MODE)); - lp_vec_t readOnlyVec = lp_vec_t( - objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id, - nullptr, pool_rwm_t::VAR_READ); - REQUIRE(readOnlyVec.commit() == - static_cast(PoolVariableIF::INVALID_READ_WRITE_MODE)); - } + lp_vec_t readOnlyVec = lp_vec_t( + objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id, + nullptr, pool_rwm_t::VAR_READ); + REQUIRE(readOnlyVec.commit() == + static_cast(PoolVariableIF::INVALID_READ_WRITE_MODE)); + } }