fsfw/unittests/internalerror/TestInternalErrorReporter.cpp

121 lines
5.4 KiB
C++
Raw Normal View History

2022-02-22 13:42:56 +01:00
#include <fsfw/housekeeping/HousekeepingSnapshot.h>
#include <fsfw/internalerror/InternalErrorReporter.h>
2022-02-18 19:08:06 +01:00
#include <fsfw/ipc/MessageQueueIF.h>
#include <fsfw/ipc/QueueFactory.h>
#include <fsfw/objectmanager/ObjectManager.h>
#include <fsfw/timemanager/CCSDSTime.h>
#include <array>
#include <catch2/catch_test_macros.hpp>
2022-07-18 16:08:06 +02:00
#include "CatchDefinitions.h"
2022-02-18 19:08:06 +01:00
#include "fsfw/action/ActionMessage.h"
#include "fsfw/ipc/CommandMessage.h"
#include "fsfw/ipc/MessageQueueMessage.h"
#include "fsfw/objectmanager/frameworkObjects.h"
2022-07-18 11:58:55 +02:00
#include "mocks/PeriodicTaskIFMock.h"
2022-02-18 19:08:06 +01:00
TEST_CASE("Internal Error Reporter", "[TestInternalError]") {
2022-05-30 12:12:07 +02:00
PeriodicTaskMock task(10, nullptr);
2022-02-22 13:42:56 +01:00
ObjectManagerIF* manager = ObjectManager::instance();
if (manager == nullptr) {
FAIL();
}
2022-07-18 11:58:55 +02:00
auto* internalErrorReporter = dynamic_cast<InternalErrorReporter*>(
2022-02-22 13:42:56 +01:00
ObjectManager::instance()->get<InternalErrorReporterIF>(objects::INTERNAL_ERROR_REPORTER));
if (internalErrorReporter == nullptr) {
FAIL();
}
task.addComponent(objects::INTERNAL_ERROR_REPORTER);
2022-05-30 12:12:07 +02:00
// This calls the initializeAfterTaskCreation function
task.startTask();
2022-02-22 13:42:56 +01:00
MessageQueueIF* testQueue = QueueFactory::instance()->createMessageQueue(1);
MessageQueueIF* hkQueue = QueueFactory::instance()->createMessageQueue(1);
internalErrorReporter->getSubscriptionInterface()->subscribeForSetUpdateMessage(
InternalErrorDataset::ERROR_SET_ID, objects::NO_OBJECT, hkQueue->getId(), true);
StorageManagerIF* ipcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
SECTION("MessageQueueFull") {
CommandMessage message;
ActionMessage::setCompletionReply(&message, 10, true);
auto result = hkQueue->sendMessage(testQueue->getId(), &message);
2022-08-15 20:28:16 +02:00
REQUIRE(result == returnvalue::OK);
2022-02-22 13:42:56 +01:00
uint32_t queueHits = 0;
uint32_t lostTm = 0;
uint32_t storeHits = 0;
/* We don't know if another test caused a queue Hit so we will enforce one,
then remeber the queueHit count and force another hit */
internalErrorReporter->queueMessageNotSent();
internalErrorReporter->performOperation(0);
{
CommandMessage hkMessage;
result = hkQueue->receiveMessage(&hkMessage);
2022-08-15 20:28:16 +02:00
REQUIRE(result == returnvalue::OK);
2022-02-22 13:42:56 +01:00
REQUIRE(hkMessage.getCommand() == HousekeepingMessage::UPDATE_SNAPSHOT_SET);
store_address_t storeAddress;
gp_id_t gpid =
HousekeepingMessage::getUpdateSnapshotVariableCommand(&hkMessage, &storeAddress);
REQUIRE(gpid.objectId == objects::INTERNAL_ERROR_REPORTER);
// We need the object ID of the reporter here (NO_OBJECT)
InternalErrorDataset dataset(objects::INTERNAL_ERROR_REPORTER);
CCSDSTime::CDS_short time;
ConstAccessorPair data = ipcStore->getData(storeAddress);
2022-08-15 20:28:16 +02:00
REQUIRE(data.first == returnvalue::OK);
2022-02-22 13:42:56 +01:00
HousekeepingSnapshot hkSnapshot(&time, &dataset);
const uint8_t* buffer = data.second.data();
size_t size = data.second.size();
result = hkSnapshot.deSerialize(&buffer, &size, SerializeIF::Endianness::MACHINE);
2022-08-15 20:28:16 +02:00
REQUIRE(result == returnvalue::OK);
2022-02-22 13:42:56 +01:00
// Remember the amount of queueHits before to see the increase
queueHits = dataset.queueHits.value;
lostTm = dataset.tmHits.value;
storeHits = dataset.storeHits.value;
}
2022-02-22 13:42:56 +01:00
result = hkQueue->sendMessage(testQueue->getId(), &message);
REQUIRE(result == MessageQueueIF::FULL);
internalErrorReporter->lostTm();
internalErrorReporter->storeFull();
{
internalErrorReporter->performOperation(0);
CommandMessage hkMessage;
result = hkQueue->receiveMessage(&hkMessage);
2022-08-15 20:28:16 +02:00
REQUIRE(result == returnvalue::OK);
2022-02-22 13:42:56 +01:00
REQUIRE(hkMessage.getCommand() == HousekeepingMessage::UPDATE_SNAPSHOT_SET);
store_address_t storeAddress;
gp_id_t gpid =
HousekeepingMessage::getUpdateSnapshotVariableCommand(&hkMessage, &storeAddress);
REQUIRE(gpid.objectId == objects::INTERNAL_ERROR_REPORTER);
ConstAccessorPair data = ipcStore->getData(storeAddress);
2022-08-15 20:28:16 +02:00
REQUIRE(data.first == returnvalue::OK);
2022-02-22 13:42:56 +01:00
CCSDSTime::CDS_short time;
// We need the object ID of the reporter here (NO_OBJECT)
InternalErrorDataset dataset(objects::INTERNAL_ERROR_REPORTER);
HousekeepingSnapshot hkSnapshot(&time, &dataset);
const uint8_t* buffer = data.second.data();
size_t size = data.second.size();
result = hkSnapshot.deSerialize(&buffer, &size, SerializeIF::Endianness::MACHINE);
2022-08-15 20:28:16 +02:00
REQUIRE(result == returnvalue::OK);
2022-02-22 13:42:56 +01:00
// Test that we had one more queueHit
REQUIRE(dataset.queueHits.value == (queueHits + 1));
REQUIRE(dataset.tmHits.value == (lostTm + 1));
REQUIRE(dataset.storeHits.value == (storeHits + 1));
2022-02-18 19:08:06 +01:00
}
2022-02-23 12:12:49 +01:00
// Complete Coverage
internalErrorReporter->setDiagnosticPrintout(true);
internalErrorReporter->setMutexTimeout(MutexIF::TimeoutType::BLOCKING, 0);
{
// Message Queue Id
MessageQueueId_t id = internalErrorReporter->getCommandQueue();
REQUIRE(id != MessageQueueIF::NO_QUEUE);
CommandMessage message;
sid_t sid(objects::INTERNAL_ERROR_REPORTER, InternalErrorDataset::ERROR_SET_ID);
HousekeepingMessage::setToggleReportingCommand(&message, sid, true, false);
result = hkQueue->sendMessage(id, &message);
2022-08-15 20:28:16 +02:00
REQUIRE(result == returnvalue::OK);
2022-02-23 12:12:49 +01:00
internalErrorReporter->performOperation(0);
}
2022-02-22 13:42:56 +01:00
}
QueueFactory::instance()->deleteMessageQueue(testQueue);
QueueFactory::instance()->deleteMessageQueue(hkQueue);
2022-05-30 12:12:07 +02:00
}