diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h index 7707fab84..07c6882be 100644 --- a/datapoollocal/HasLocalDataPoolIF.h +++ b/datapoollocal/HasLocalDataPoolIF.h @@ -4,6 +4,7 @@ #include "locPoolDefinitions.h" #include "../datapool/PoolEntryIF.h" +#include "../serviceinterface/ServiceInterface.h" #include "../ipc/MessageQueueSenderIF.h" #include "../housekeeping/HousekeepingMessage.h" @@ -92,6 +93,9 @@ public: #if FSFW_CPP_OSTREAM_ENABLED == 1 sif::warning << "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden" << ". Returning nullptr!" << std::endl; +#else + fsfw::printWarning("HasLocalDataPoolIF::getPoolObjectHandle: " + "Not overriden. Returning nullptr!\n"); #endif return nullptr; } diff --git a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp index 4cea3ed15..2c797505e 100644 --- a/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp +++ b/unittest/tests/datapoollocal/LocalPoolManagerTest.cpp @@ -3,6 +3,7 @@ #include #include #include +#include #include @@ -17,12 +18,49 @@ TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") { MessageQueueMockBase* mqMock = poolOwner->getMockQueueHandle(); REQUIRE(mqMock != nullptr); - poolOwner->subscribeWrapperSetUpdate(); + 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->hkManager.performHkOperation() == retval::CATCH_OK); REQUIRE(mqMock->wasMessageSent() == true); + CommandMessage messageSent; + uint8_t messagesSent = 0; + 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->hkManager.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)); + + // now subscribe for set update HK as well. + REQUIRE(poolOwner->subscribeWrapperSetUpdateHk() == retval::CATCH_OK); + poolOwner->dataset.setChanged(true); + REQUIRE(poolOwner->hkManager.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)); + CommandMessageCleaner::clearCommandMessage(&messageSent); } } diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h index c211801a0..5ff146983 100644 --- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h +++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h @@ -18,6 +18,8 @@ static constexpr lp_id_t uint16Vec3Id = 3; static constexpr lp_id_t int64Vec2Id = 4; static constexpr uint32_t testSetId = 0; +static const sid_t testSid = sid_t(objects::TEST_LOCAL_POOL_OWNER_BASE, + testSetId); } @@ -123,12 +125,27 @@ public: return &dataset; } + virtual LocalPoolObjectBase* getPoolObjectHandle( + lp_id_t localPoolId) override { + return &testUint8; + } + MessageQueueMockBase* getMockQueueHandle() const { return dynamic_cast(messageQueue); } - void subscribeWrapperSetUpdate() { - hkManager.subscribeForSetUpdateMessages(lpool::testSetId, + ReturnValue_t subscribeWrapperSetUpdate() { + return hkManager.subscribeForSetUpdateMessages(lpool::testSetId, + objects::NO_OBJECT, MessageQueueIF::NO_QUEUE, false); + } + + ReturnValue_t subscribeWrapperSetUpdateHk(bool diagnostics = false) { + return hkManager.subscribeForUpdatePackets(lpool::testSid, diagnostics, + false, objects::HK_RECEIVER_MOCK); + } + + ReturnValue_t subscribeWrapperVariableUpdate() { + return hkManager.subscribeForSetUpdateMessages(lpool::testSetId, objects::NO_OBJECT, MessageQueueIF::NO_QUEUE, false); } diff --git a/unittest/tests/mocks/HkReceiverMock.h b/unittest/tests/mocks/HkReceiverMock.h new file mode 100644 index 000000000..e7509c592 --- /dev/null +++ b/unittest/tests/mocks/HkReceiverMock.h @@ -0,0 +1,20 @@ +#ifndef FSFW_UNITTEST_TESTS_MOCKS_HKRECEIVERMOCK_H_ +#define FSFW_UNITTEST_TESTS_MOCKS_HKRECEIVERMOCK_H_ + +#include +#include + +class HkReceiverMock: public SystemObject, public AcceptsHkPacketsIF { +public: + HkReceiverMock(object_id_t objectId): SystemObject(objectId) { + + } + + MessageQueueId_t getHkQueue() const { + return MessageQueueIF::NO_QUEUE; + } +}; + + + +#endif /* FSFW_UNITTEST_TESTS_MOCKS_HKRECEIVERMOCK_H_ */ diff --git a/unittest/tests/mocks/MessageQueueMockBase.h b/unittest/tests/mocks/MessageQueueMockBase.h index 5a1573297..4792772fe 100644 --- a/unittest/tests/mocks/MessageQueueMockBase.h +++ b/unittest/tests/mocks/MessageQueueMockBase.h @@ -6,68 +6,81 @@ #include #include +#include class MessageQueueMockBase: public MessageQueueIF { public: - MessageQueueId_t myQueueId = 0; + MessageQueueId_t myQueueId = tconst::testQueueId; + uint8_t messageSentCounter = 0; bool defaultDestSet = false; bool messageSent = false; - bool wasMessageSent() { + bool wasMessageSent(uint8_t* messageSentCounter = nullptr, + bool resetCounter = true) { bool tempMessageSent = messageSent; messageSent = false; + if(messageSentCounter != nullptr) { + *messageSentCounter = this->messageSentCounter; + } + if(resetCounter) { + this->messageSentCounter = 0; + } return tempMessageSent; } virtual ReturnValue_t reply( MessageQueueMessageIF* message ) { - messageSent = true; - lastMessage = *(dynamic_cast(message)); + //messageSent = true; + //lastMessage = *(dynamic_cast(message)); + return sendMessage(myQueueId, message); return HasReturnvaluesIF::RETURN_OK; }; virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message, MessageQueueId_t *receivedFrom) { - (*message) = lastMessage; - lastMessage.clear(); - return HasReturnvaluesIF::RETURN_OK; + return receiveMessage(message); } virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) { - std::memcpy(message->getBuffer(), lastMessage.getBuffer(), + std::memcpy(message->getBuffer(), messagesSentQueue.front().getBuffer(), message->getMessageSize()); - lastMessage.clear(); + messagesSentQueue.pop(); return HasReturnvaluesIF::RETURN_OK; } virtual ReturnValue_t flush(uint32_t* count) { return HasReturnvaluesIF::RETURN_OK; } virtual MessageQueueId_t getLastPartner() const { - return tconst::testQueueId; + return myQueueId; } virtual MessageQueueId_t getId() const { - return tconst::testQueueId; + return myQueueId; } virtual ReturnValue_t sendMessageFrom( MessageQueueId_t sendTo, MessageQueueMessageIF* message, MessageQueueId_t sentFrom, bool ignoreFault = false ) { - messageSent = true; - lastMessage = *(dynamic_cast(message)); - return HasReturnvaluesIF::RETURN_OK; + //messageSent = true; + //lastMessage = *(dynamic_cast(message)); + //return HasReturnvaluesIF::RETURN_OK; + return sendMessage(sendTo, message); + } + virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message, + MessageQueueId_t sentFrom, bool ignoreFault = false ) { + //messageSent = true; + //lastMessage = *(dynamic_cast(message)); + //return HasReturnvaluesIF::RETURN_OK; + return sendMessage(myQueueId, message); + } + virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message ) { + //messageSent = true; + //lastMessage = *(dynamic_cast(message)); + return sendMessage(myQueueId, message); } virtual ReturnValue_t sendMessage( MessageQueueId_t sendTo, MessageQueueMessageIF* message, bool ignoreFault = false ) override { messageSent = true; - lastMessage = *(dynamic_cast(message)); - return HasReturnvaluesIF::RETURN_OK; - } - virtual ReturnValue_t sendToDefaultFrom( MessageQueueMessageIF* message, - MessageQueueId_t sentFrom, bool ignoreFault = false ) { - messageSent = true; - lastMessage = *(dynamic_cast(message)); - return HasReturnvaluesIF::RETURN_OK; - } - virtual ReturnValue_t sendToDefault( MessageQueueMessageIF* message ) { - messageSent = true; - lastMessage = *(dynamic_cast(message)); + messageSentCounter++; + MessageQueueMessage& messageRef = *( + dynamic_cast(message)); + messagesSentQueue.push(messageRef); return HasReturnvaluesIF::RETURN_OK; } virtual void setDefaultDestination(MessageQueueId_t defaultDestination) { @@ -81,9 +94,16 @@ public: virtual bool isDefaultDestinationSet() const { return defaultDestSet; } -private: - MessageQueueMessage lastMessage; + void clearMessages() { + while(not messagesSentQueue.empty()) { + messagesSentQueue.pop(); + } + } + +private: + std::queue messagesSentQueue; + //MessageQueueMessage lastMessage; }; diff --git a/unittest/user/testcfg/objects/systemObjectList.h b/unittest/user/testcfg/objects/systemObjectList.h index da95617cc..88b92131c 100644 --- a/unittest/user/testcfg/objects/systemObjectList.h +++ b/unittest/user/testcfg/objects/systemObjectList.h @@ -21,6 +21,7 @@ namespace objects { TEST_ECHO_COM_IF = 20, TEST_DEVICE = 21, + HK_RECEIVER_MOCK = 22, TEST_LOCAL_POOL_OWNER_BASE = 25 }; }