added first unit tests for hk manager

datapool/PoolDataSetBase.cpp

@@ -214,6 +214,10 @@ void PoolDataSetBase::setContainer(PoolVariableIF **variablesContainer) {
     this->registeredVariables = variablesContainer;
 }
 
+PoolVariableIF** PoolDataSetBase::getContainer() const {
+	return registeredVariables;
+}
+
 void PoolDataSetBase::setReadCommitProtectionBehaviour(
 		bool protectEveryReadCommit, uint32_t mutexTimeout) {
 	this->protectEveryReadCommitCall = protectEveryReadCommit;

datapool/PoolDataSetBase.h

@@ -157,6 +157,7 @@ protected:
 	const size_t maxFillCount = 0;
 
 	void setContainer(PoolVariableIF** variablesContainer);
+	PoolVariableIF** getContainer() const;
 
 private:
 	bool protectEveryReadCommitCall = false;

datapoollocal/LocalDataPoolManager.cpp

@@ -308,8 +308,8 @@ void LocalDataPoolManager::handleChangeResetLogic(
         // config error!
         return;
     }
-
+    HkUpdateResetList& listRef = *hkUpdateResetList;
-    for(auto& changeInfo: *hkUpdateResetList) {
+    for(auto& changeInfo: listRef) {
         if(changeInfo.dataType != type) {
             continue;
         }
@@ -636,7 +636,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
     }
 
     if(hkQueue == nullptr) {
-        // error, all destinations invalid
+        // error, no queue available to send packet with.
     	printWarningOrError(fsfw::OutputTypes::OUT_WARNING,
     			"generateHousekeepingPacket",
     			QUEUE_OR_DESTINATION_INVALID);

unittest/tests/action/TestActionHelper.cpp

@@ -4,6 +4,7 @@
 
 #include <fsfw/action/ActionHelper.h>
 #include <fsfw/ipc/CommandMessage.h>
+#include <fsfw/unittest/tests/mocks/MessageQueueMockBase.h>
 
 #include <catch2/catch_test_macros.hpp>
 

unittest/tests/action/TestActionHelper.h

@@ -48,85 +48,4 @@ public:
 };
 
 
-class MessageQueueMockBase: public MessageQueueIF {
-public:
-	MessageQueueId_t myQueueId = 0;
-	bool defaultDestSet = false;
-	bool messageSent = false;
-
-
-
-	bool wasMessageSent() {
-		bool tempMessageSent = messageSent;
-		messageSent = false;
-		return tempMessageSent;
-	}
-
-	virtual ReturnValue_t reply( MessageQueueMessageIF* message ) {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		return HasReturnvaluesIF::RETURN_OK;
-	};
-	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
-			MessageQueueId_t *receivedFrom) {
-		(*message) = lastMessage;
-		lastMessage.clear();
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) {
-		memcpy(message->getBuffer(), lastMessage.getBuffer(),
-				message->getMessageSize());
-		lastMessage.clear();
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t flush(uint32_t* count) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual MessageQueueId_t getLastPartner() const {
-		return tconst::testQueueId;
-	}
-	virtual MessageQueueId_t getId() const {
-		return tconst::testQueueId;
-	}
-	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-			bool ignoreFault = false ) {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
-			MessageQueueMessageIF* message, bool ignoreFault = false ) override {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
-			MessageQueueId_t sentFrom, bool ignoreFault = false ) {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message ) {
-		messageSent = true;
-		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) {
-		myQueueId = defaultDestination;
-		defaultDestSet = true;
-	}
-
-	virtual MessageQueueId_t getDefaultDestination() const {
-		return myQueueId;
-	}
-	virtual bool isDefaultDestinationSet() const {
-		return defaultDestSet;
-	}
-private:
-	MessageQueueMessage lastMessage;
-
-};
-
-
 #endif /* UNITTEST_TESTFW_NEWTESTS_TESTACTIONHELPER_H_ */

unittest/tests/datapoollocal/CMakeLists.txt

@@ -2,4 +2,5 @@ target_sources(${TARGET_NAME} PRIVATE
 	LocalPoolVariableTest.cpp
 	LocalPoolVectorTest.cpp
 	DataSetTest.cpp
+	LocalPoolManagerTest.cpp
 )

unittest/tests/datapoollocal/LocalPoolManagerTest.cpp

@@ -0,0 +1,28 @@
+#include "LocalPoolOwnerBase.h"
+
+#include <catch2/catch_test_macros.hpp>
+#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <unittest/core/CatchDefinitions.h>
+
+
+TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
+	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);
+	REQUIRE(poolOwner->dataset.assignPointers() == retval::CATCH_OK);
+	MessageQueueMockBase* mqMock = poolOwner->getMockQueueHandle();
+	REQUIRE(mqMock != nullptr);
+
+	poolOwner->subscribeWrapperSetUpdate();
+	SECTION("BasicTest") {
+		poolOwner->dataset.setChanged(true);
+		REQUIRE(poolOwner->hkManager.performHkOperation() == retval::CATCH_OK);
+		REQUIRE(mqMock->wasMessageSent() == true);
+
+	}
+}
+

unittest/tests/datapoollocal/LocalPoolOwnerBase.h

@@ -7,6 +7,8 @@
 #include <fsfw/datapoollocal/LocalPoolVector.h>
 #include <fsfw/ipc/QueueFactory.h>
 #include <testcfg/objects/systemObjectList.h>
+#include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <fsfw/unittest/tests/mocks/MessageQueueMockBase.h>
 
 namespace lpool {
 static constexpr lp_id_t uint8VarId = 0;
@@ -14,16 +16,45 @@ static constexpr lp_id_t floatVarId = 1;
 static constexpr lp_id_t uint32VarId = 2;
 static constexpr lp_id_t uint16Vec3Id = 3;
 static constexpr lp_id_t int64Vec2Id = 4;
+
+static constexpr uint32_t testSetId = 0;
 }
 
 
+class LocalPoolTestDataSet: public StaticLocalDataSet<3> {
+public:
+	LocalPoolTestDataSet(HasLocalDataPoolIF* owner, uint32_t setId):
+		StaticLocalDataSet(owner, setId) {
+	}
+
+	ReturnValue_t assignPointers() {
+		PoolVariableIF** rawVarArray = getContainer();
+		localPoolVarUint8 = dynamic_cast<lp_var_t<uint8_t>*>(rawVarArray[0]);
+		localPoolVarFloat = dynamic_cast<lp_var_t<float>*>(rawVarArray[1]);
+		localPoolUint16Vec = dynamic_cast<lp_vec_t<uint16_t, 3>*>(
+				rawVarArray[2]);
+		if(localPoolVarUint8 == nullptr or  localPoolVarFloat == nullptr or
+				localPoolUint16Vec == nullptr) {
+			return HasReturnvaluesIF::RETURN_FAILED;
+		}
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+
+	lp_var_t<uint8_t>* localPoolVarUint8 = nullptr;
+	lp_var_t<float>* localPoolVarFloat = nullptr;
+	lp_vec_t<uint16_t, 3>* localPoolUint16Vec = nullptr;
+
+private:
+};
+
 
 class LocalPoolOwnerBase: public SystemObject, public HasLocalDataPoolIF {
 public:
 	LocalPoolOwnerBase(
 			object_id_t objectId = objects::TEST_LOCAL_POOL_OWNER_BASE):
-		SystemObject(objectId), hkManager(this, messageQueue)  {
+		SystemObject(objectId), hkManager(this, messageQueue),
-		messageQueue = QueueFactory::instance()->createMessageQueue(10);
+		dataset(this, lpool::testSetId) {
+		messageQueue = new MessageQueueMockBase();
 	}
 
 	~LocalPoolOwnerBase() {
@@ -89,22 +120,34 @@ public:
 	 * @return
 	 */
 	virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override  {
-		// empty for now
+		return &dataset;
-		return nullptr;
 	}
+
+	MessageQueueMockBase* getMockQueueHandle() const {
+		return dynamic_cast<MessageQueueMockBase*>(messageQueue);
+	}
+
+	void subscribeWrapperSetUpdate() {
+		hkManager.subscribeForSetUpdateMessages(lpool::testSetId,
+				objects::NO_OBJECT, MessageQueueIF::NO_QUEUE, false);
+	}
+
+	LocalDataPoolManager hkManager;
+	LocalPoolTestDataSet dataset;
 private:
 
-	lp_var_t<uint8_t> testUint8 = lp_var_t<uint8_t>(this, lpool::uint8VarId);
+	lp_var_t<uint8_t> testUint8 = lp_var_t<uint8_t>(this, lpool::uint8VarId,
-	lp_var_t<float> testFloat = lp_var_t<float>(this, lpool::floatVarId);
+			&dataset);
+	lp_var_t<float> testFloat = lp_var_t<float>(this, lpool::floatVarId,
+			&dataset);
 	lp_var_t<uint32_t> testUint32 = lp_var_t<uint32_t>(this, lpool::uint32VarId);
 
 	lp_vec_t<uint16_t, 3> testUint16Vec = lp_vec_t<uint16_t, 3>(this,
-			lpool::uint16Vec3Id);
+			lpool::uint16Vec3Id, &dataset);
 	lp_vec_t<int64_t, 2> testInt64Vec = lp_vec_t<int64_t, 2>(this,
 			lpool::int64Vec2Id);
 
 	MessageQueueIF* messageQueue = nullptr;
-	LocalDataPoolManager hkManager;
 
 	bool initialized = false;
 	bool initializedAfterTaskCreation = false;

unittest/tests/mocks/MessageQueueMockBase.h

@@ -0,0 +1,90 @@
+#ifndef FSFW_UNITTEST_TESTS_MOCKS_MESSAGEQUEUEMOCKBASE_H_
+#define FSFW_UNITTEST_TESTS_MOCKS_MESSAGEQUEUEMOCKBASE_H_
+
+#include <fsfw/ipc/MessageQueueIF.h>
+#include <fsfw/ipc/MessageQueueMessage.h>
+#include <unittest/core/CatchDefinitions.h>
+#include <cstring>
+
+
+class MessageQueueMockBase: public MessageQueueIF {
+public:
+	MessageQueueId_t myQueueId = 0;
+	bool defaultDestSet = false;
+	bool messageSent = false;
+
+
+	bool wasMessageSent() {
+		bool tempMessageSent = messageSent;
+		messageSent = false;
+		return tempMessageSent;
+	}
+
+	virtual ReturnValue_t reply( MessageQueueMessageIF* message ) {
+		messageSent = true;
+		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return HasReturnvaluesIF::RETURN_OK;
+	};
+	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
+			MessageQueueId_t *receivedFrom) {
+		(*message) = lastMessage;
+		lastMessage.clear();
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) {
+		std::memcpy(message->getBuffer(), lastMessage.getBuffer(),
+				message->getMessageSize());
+		lastMessage.clear();
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t flush(uint32_t* count) {
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual MessageQueueId_t getLastPartner() const {
+		return tconst::testQueueId;
+	}
+	virtual MessageQueueId_t getId() const {
+		return tconst::testQueueId;
+	}
+	virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+			bool ignoreFault = false ) {
+		messageSent = true;
+		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo,
+			MessageQueueMessageIF* message, bool ignoreFault = false ) override {
+		messageSent = true;
+		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message,
+			MessageQueueId_t sentFrom, bool ignoreFault = false ) {
+		messageSent = true;
+		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message ) {
+		messageSent = true;
+		lastMessage = *(dynamic_cast<MessageQueueMessage*>(message));
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+	virtual void setDefaultDestination(MessageQueueId_t defaultDestination) {
+		myQueueId = defaultDestination;
+		defaultDestSet = true;
+	}
+
+	virtual MessageQueueId_t getDefaultDestination() const {
+		return myQueueId;
+	}
+	virtual bool isDefaultDestinationSet() const {
+		return defaultDestSet;
+	}
+private:
+	MessageQueueMessage lastMessage;
+
+};
+
+
+#endif /* FSFW_UNITTEST_TESTS_MOCKS_MESSAGEQUEUEMOCKBASE_H_ */