eive/fsfw
15
1
Fork 0
forked from fsfw/fsfw
Code Issues Pull Requests Releases 1 Wiki Activity

Merge branch 'mueller/refactor-tmtc-stack' into mueller/cfdp-routers

Browse Source
This commit is contained in:
Robin Müller
2022-08-22 16:21:41 +02:00
parent 3b33b429e6 10f34e5a48
commit 52f8c5038b
435 changed files with 2880 additions and 3066 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
unittests/mocks/CdsShortTimestamperMock.h
View File

@ -10,13 +10,13 @@ class CdsShortTimestamperMock : public TimeStamperIF, public TimeReaderIF {
public:
unsigned int serializeCallCount = 0;
unsigned int deserializeCallCount = 0;
ReturnValue_t lastDeserializeResult = HasReturnvaluesIF::RETURN_OK;
ReturnValue_t lastSerializeResult = HasReturnvaluesIF::RETURN_OK;
ReturnValue_t lastDeserializeResult = returnvalue::OK;
ReturnValue_t lastSerializeResult = returnvalue::OK;
unsigned int getSizeCallCount = 0;
bool nextSerFails = false;
ReturnValue_t serFailRetval = HasReturnvaluesIF::RETURN_FAILED;
ReturnValue_t serFailRetval = returnvalue::FAILED;
bool nextDeserFails = false;
ReturnValue_t deserFailRetval = HasReturnvaluesIF::RETURN_FAILED;
ReturnValue_t deserFailRetval = returnvalue::FAILED;
std::array<uint8_t, 7> valueToStamp{};
CdsShortTimestamperMock() = default;
@ -36,7 +36,7 @@ class CdsShortTimestamperMock : public TimeStamperIF, public TimeReaderIF {
return lastSerializeResult;
}
std::copy(valueToStamp.begin(), valueToStamp.end(), *buffer);
thisNonConst.lastSerializeResult = HasReturnvaluesIF::RETURN_OK;
thisNonConst.lastSerializeResult = returnvalue::OK;
*buffer += getSerializedSize();
*size += getSerializedSize();
return lastSerializeResult;
@ -69,10 +69,10 @@ class CdsShortTimestamperMock : public TimeStamperIF, public TimeReaderIF {
deserializeCallCount = 0;
nextSerFails = false;
nextDeserFails = false;
lastSerializeResult = HasReturnvaluesIF::RETURN_OK;
lastDeserializeResult = HasReturnvaluesIF::RETURN_OK;
deserFailRetval = HasReturnvaluesIF::RETURN_FAILED;
serFailRetval = HasReturnvaluesIF::RETURN_FAILED;
lastSerializeResult = returnvalue::OK;
lastDeserializeResult = returnvalue::OK;
deserFailRetval = returnvalue::FAILED;
serFailRetval = returnvalue::FAILED;
}
ReturnValue_t readTimeStamp(const uint8_t *buffer, size_t maxSize) override {

12
unittests/mocks/ComIFMock.cpp
View File

@ -6,24 +6,24 @@ ComIFMock::ComIFMock(object_id_t objectId) : SystemObject(objectId) {}
ComIFMock::~ComIFMock() {}
ReturnValue_t ComIFMock::initializeInterface(CookieIF *cookie) { return RETURN_OK; }
ReturnValue_t ComIFMock::initializeInterface(CookieIF *cookie) { return returnvalue::OK; }
ReturnValue_t ComIFMock::sendMessage(CookieIF *cookie, const uint8_t *sendData, size_t sendLen) {
data = *sendData;
return RETURN_OK;
return returnvalue::OK;
}
ReturnValue_t ComIFMock::getSendSuccess(CookieIF *cookie) { return RETURN_OK; }
ReturnValue_t ComIFMock::getSendSuccess(CookieIF *cookie) { return returnvalue::OK; }
ReturnValue_t ComIFMock::requestReceiveMessage(CookieIF *cookie, size_t requestLen) {
return RETURN_OK;
return returnvalue::OK;
}
ReturnValue_t ComIFMock::readReceivedMessage(CookieIF *cookie, uint8_t **buffer, size_t *size) {
switch (testCase) {
case TestCase::MISSED_REPLY: {
*size = 0;
return RETURN_OK;
return returnvalue::OK;
}
case TestCase::SIMPLE_COMMAND_NOMINAL: {
*size = 1;
@ -40,7 +40,7 @@ ReturnValue_t ComIFMock::readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
default:
break;
}
return RETURN_OK;
return returnvalue::OK;
}
void ComIFMock::setTestCase(TestCase testCase_) { testCase = testCase_; }

10
unittests/mocks/DeviceHandlerMock.cpp
View File

@ -36,7 +36,7 @@ ReturnValue_t DeviceHandlerMock::buildCommandFromCommand(DeviceCommandId_t devic
WARN("DeviceHandlerMock::buildCommandFromCommand: Invalid device command");
break;
}
return RETURN_OK;
return returnvalue::OK;
}
ReturnValue_t DeviceHandlerMock::scanForReply(const uint8_t *start, size_t len,
@ -45,19 +45,19 @@ ReturnValue_t DeviceHandlerMock::scanForReply(const uint8_t *start, size_t len,
case SIMPLE_COMMAND_DATA: {
*foundId = SIMPLE_COMMAND;
*foundLen = sizeof(SIMPLE_COMMAND_DATA);
return RETURN_OK;
return returnvalue::OK;
break;
}
case PERIODIC_REPLY_DATA: {
*foundId = PERIODIC_REPLY;
*foundLen = sizeof(PERIODIC_REPLY_DATA);
return RETURN_OK;
return returnvalue::OK;
break;
}
default:
break;
}
return RETURN_FAILED;
return returnvalue::FAILED;
}
ReturnValue_t DeviceHandlerMock::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
@ -70,7 +70,7 @@ ReturnValue_t DeviceHandlerMock::interpretDeviceReply(DeviceCommandId_t id, cons
default:
break;
}
return RETURN_OK;
return returnvalue::OK;
}
void DeviceHandlerMock::fillCommandAndReplyMap() {

14
unittests/mocks/LocalPoolOwnerBase.cpp
View File

@ -13,7 +13,7 @@ ReturnValue_t LocalPoolOwnerBase::initializeHkManager() {
initialized = true;
return poolManager.initialize(&queue);
}
return HasReturnvaluesIF::RETURN_OK;
return returnvalue::OK;
}
ReturnValue_t LocalPoolOwnerBase::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
@ -25,7 +25,7 @@ ReturnValue_t LocalPoolOwnerBase::initializeLocalDataPool(localpool::DataPool &l
localDataPoolMap.emplace(lpool::uint16Vec3Id, &u16VecPoolEntry);
localDataPoolMap.emplace(lpool::int64Vec2Id, &i64VecPoolEntry);
return HasReturnvaluesIF::RETURN_OK;
return returnvalue::OK;
}
LocalPoolObjectBase *LocalPoolOwnerBase::getPoolObjectHandle(lp_id_t localPoolId) {
@ -46,10 +46,10 @@ LocalPoolObjectBase *LocalPoolOwnerBase::getPoolObjectHandle(lp_id_t localPoolId
ReturnValue_t LocalPoolOwnerBase::reset() {
resetSubscriptionList();
ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
ReturnValue_t status = returnvalue::OK;
{
PoolReadGuard readHelper(&dataset);
if (readHelper.getReadResult() != HasReturnvaluesIF::RETURN_OK) {
if (readHelper.getReadResult() != returnvalue::OK) {
status = readHelper.getReadResult();
}
dataset.localPoolVarUint8.value = 0;
@ -62,7 +62,7 @@ ReturnValue_t LocalPoolOwnerBase::reset() {
{
PoolReadGuard readHelper(&testUint32);
if (readHelper.getReadResult() != HasReturnvaluesIF::RETURN_OK) {
if (readHelper.getReadResult() != returnvalue::OK) {
status = readHelper.getReadResult();
}
testUint32.value = 0;
@ -71,7 +71,7 @@ ReturnValue_t LocalPoolOwnerBase::reset() {
{
PoolReadGuard readHelper(&testInt64Vec);
if (readHelper.getReadResult() != HasReturnvaluesIF::RETURN_OK) {
if (readHelper.getReadResult() != returnvalue::OK) {
status = readHelper.getReadResult();
}
testInt64Vec.value[0] = 0;
@ -116,7 +116,7 @@ ReturnValue_t LocalPoolOwnerBase::initializeHkManagerAfterTaskCreation() {
initializedAfterTaskCreation = true;
return poolManager.initializeAfterTaskCreation();
}
return HasReturnvaluesIF::RETURN_OK;
return returnvalue::OK;
}
void LocalPoolOwnerBase::handleChangedPoolVariable(gp_id_t globPoolId, store_address_t storeId,

14
unittests/mocks/MessageQueueMock.cpp
View File

@ -42,7 +42,7 @@ ReturnValue_t MessageQueueMock::clearLastReceivedMessage(bool clearCmdMsg) {
message.clearCommandMessage();
}
receivedMsgs.pop();
return HasReturnvaluesIF::RETURN_OK;
return returnvalue::OK;
}
ReturnValue_t MessageQueueMock::receiveMessage(MessageQueueMessageIF* message) {
@ -51,16 +51,16 @@ ReturnValue_t MessageQueueMock::receiveMessage(MessageQueueMessageIF* message) {
}
std::memcpy(message->getBuffer(), receivedMsgs.front().getBuffer(), message->getMessageSize());
receivedMsgs.pop();
return HasReturnvaluesIF::RETURN_OK;
return returnvalue::OK;
}
ReturnValue_t MessageQueueMock::flush(uint32_t* count) { return HasReturnvaluesIF::RETURN_FAILED; }
ReturnValue_t MessageQueueMock::flush(uint32_t* count) { return returnvalue::FAILED; }
ReturnValue_t MessageQueueMock::sendMessageFrom(MessageQueueId_t sendTo,
MessageQueueMessageIF* message,
MessageQueueId_t sentFrom, bool ignoreFault) {
if (message == nullptr) {
return HasReturnvaluesIF::RETURN_FAILED;
return returnvalue::FAILED;
}
if (nextSendFailsPair.first) {
nextSendFailsPair.first = false;
@ -76,7 +76,7 @@ ReturnValue_t MessageQueueMock::sendMessageFrom(MessageQueueId_t sendTo,
createMsgCopy(messageCopy, *message);
iter->second.msgs.push(messageCopy);
}
return HasReturnvaluesIF::RETURN_OK;
return returnvalue::OK;
}
ReturnValue_t MessageQueueMock::reply(MessageQueueMessageIF* message) {
@ -121,7 +121,7 @@ ReturnValue_t MessageQueueMock::getNextSentMessage(MessageQueueId_t id,
return MessageQueueIF::EMPTY;
}
createMsgCopy(message, iter->second.msgs.front());
return HasReturnvaluesIF::RETURN_OK;
return returnvalue::OK;
}
ReturnValue_t MessageQueueMock::getNextSentMessage(MessageQueueMessageIF& message) {
@ -156,7 +156,7 @@ ReturnValue_t MessageQueueMock::clearLastSentMessage(
}
iter->second.msgs.pop();
iter->second.callCount--;
return HasReturnvaluesIF::RETURN_OK;
return returnvalue::OK;
}
void MessageQueueMock::clearEmptyEntries() {
for (auto it = sendMap.cbegin(); it != sendMap.cend();) {

4
unittests/mocks/PeriodicTaskIFMock.h
View File

@ -16,10 +16,10 @@ class PeriodicTaskMock : public PeriodicTaskBase {
*/
virtual ReturnValue_t startTask() override {
initObjsAfterTaskCreation();
return HasReturnvaluesIF::RETURN_OK;
return returnvalue::OK;
};
virtual ReturnValue_t sleepFor(uint32_t ms) override { return HasReturnvaluesIF::RETURN_OK; };
virtual ReturnValue_t sleepFor(uint32_t ms) override { return returnvalue::OK; };
};
#endif // FSFW_UNITTEST_TESTS_MOCKS_PERIODICTASKMOCK_H_

8
unittests/mocks/PowerSwitcherMock.cpp
View File

@ -16,7 +16,7 @@ ReturnValue_t PowerSwitcherMock::sendSwitchCommand(power::Switch_t switchNr, Ret
info.timesCalledOff++;
}
}
return RETURN_OK;
return returnvalue::OK;
}
ReturnValue_t PowerSwitcherMock::sendFuseOnCommand(uint8_t fuseNr) {
@ -26,7 +26,7 @@ ReturnValue_t PowerSwitcherMock::sendFuseOnCommand(uint8_t fuseNr) {
FuseInfo& info = fuseMap.at(fuseNr);
info.timesCalled++;
}
return RETURN_OK;
return returnvalue::OK;
}
ReturnValue_t PowerSwitcherMock::getSwitchState(power::Switch_t switchNr) const {
@ -35,7 +35,7 @@ ReturnValue_t PowerSwitcherMock::getSwitchState(power::Switch_t switchNr) const
SWITCH_REQUEST_UPDATE_VALUE++;
return info.currentState;
}
return RETURN_FAILED;
return returnvalue::FAILED;
}
ReturnValue_t PowerSwitcherMock::getFuseState(uint8_t fuseNr) const {
@ -44,7 +44,7 @@ ReturnValue_t PowerSwitcherMock::getFuseState(uint8_t fuseNr) const {
} else {
return FUSE_OFF;
}
return RETURN_FAILED;
return returnvalue::FAILED;
}
uint32_t PowerSwitcherMock::getSwitchDelayMs(void) const { return 5000; }

2
unittests/mocks/PusDistributorMock.cpp
View File

@ -8,5 +8,5 @@ PusDistributorMock::PusDistributorMock(object_id_t registeredId)
ReturnValue_t PusDistributorMock::registerService(const AcceptsTelecommandsIF& service) {
registerCallCount++;
registeredServies.push_back(&service);
return HasReturnvaluesIF::RETURN_OK;
return returnvalue::OK;
}

4
unittests/mocks/PusServiceBaseMock.cpp
View File

@ -9,7 +9,7 @@ ReturnValue_t PsbMock::handleRequest(uint8_t subservice) {
handleReqFailPair.first = false;
return handleReqFailPair.second;
}
return HasReturnvaluesIF::RETURN_OK;
return returnvalue::OK;
}
ReturnValue_t PsbMock::performService() {
@ -18,7 +18,7 @@ ReturnValue_t PsbMock::performService() {
performServiceFailPair.first = false;
return performServiceFailPair.second;
}
return HasReturnvaluesIF::RETURN_OK;
return returnvalue::OK;
}
void PsbMock::reset() {

4
unittests/mocks/PusVerificationReporterMock.cpp
View File

@ -33,10 +33,10 @@ void PusVerificationReporterMock::popNextSuccessParams() {
ReturnValue_t PusVerificationReporterMock::sendSuccessReport(VerifSuccessParams params) {
successParams.push(params);
return HasReturnvaluesIF::RETURN_OK;
return returnvalue::OK;
}
ReturnValue_t PusVerificationReporterMock::sendFailureReport(VerifFailureParams params) {
failParams.push(params);
return HasReturnvaluesIF::RETURN_OK;
return returnvalue::OK;
}