diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index e9c63b78060a66d19fee0b59c83f59e4fa916454..2afbb623502a0f027af9f76d921738bd98747e05 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -11,15 +11,15 @@
<option name="SPACE_BEFORE_REFERENCE_IN_DECLARATION" value="false" />
<option name="SPACE_AFTER_REFERENCE_IN_DECLARATION" value="true" />
</Objective-C>
- <Objective-C-extensions>
+ <clangFormatSettings>
+ <option name="ENABLED" value="true" />
+ </clangFormatSettings>
+ <files>
<extensions>
<pair source="cpp" header="hpp" fileNamingConvention="PASCAL_CASE" />
<pair source="c" header="h" fileNamingConvention="NONE" />
</extensions>
- </Objective-C-extensions>
- <clangFormatSettings>
- <option name="ENABLED" value="true" />
- </clangFormatSettings>
+ </files>
<codeStyleSettings language="ObjectiveC">
<option name="ALIGN_MULTILINE_CHAINED_METHODS" value="true" />
<option name="ALIGN_MULTILINE_FOR" value="false" />
diff --git a/inc/ECSS_Definitions.hpp b/inc/ECSS_Definitions.hpp
index 48fbf0f1fcf8de14059e94cec4f983f444096e34..866213d2fd6442baa9b43341c0b3521570c86dbe 100644
--- a/inc/ECSS_Definitions.hpp
+++ b/inc/ECSS_Definitions.hpp
@@ -182,7 +182,7 @@ inline const uint8_t ECSSMaxReportTypeDefinitions = 20;
* configuration
* @see RealTimeForwardingControlService
*/
-inline const uint8_t ECSSMaxServiceTypeDefinitions = 15;
+inline const uint8_t ECSSMaxServiceTypeDefinitions = 10;
/**
* The max number of event definition IDs per event report blocking type definition in the event report blocking
diff --git a/inc/Helpers/AllMessageTypes.hpp b/inc/Helpers/AllMessageTypes.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..33c6941db3cb72740cb0a393160bf9390dbdcfdb
--- /dev/null
+++ b/inc/Helpers/AllMessageTypes.hpp
@@ -0,0 +1,76 @@
+#ifndef ECSS_SERVICES_ALLMESSAGETYPES_HPP
+#define ECSS_SERVICES_ALLMESSAGETYPES_HPP
+
+#include "Services/RequestVerificationService.hpp"
+#include "Services/HousekeepingService.hpp"
+#include "Services/ParameterStatisticsService.hpp"
+#include "Services/EventReportService.hpp"
+#include "Services/MemoryManagementService.hpp"
+#include "Services/TimeBasedSchedulingService.hpp"
+#include "Services/LargePacketTransferService.hpp"
+#include "Services/RealTimeForwardingControlService.hpp"
+#include "Services/TestService.hpp"
+#include "Services/EventActionService.hpp"
+#include "Services/ParameterService.hpp"
+
+class AllMessageTypes {
+public:
+ etl::vector<uint8_t, 15> st01Messages = {RequestVerificationService::MessageType::FailedAcceptanceReport,
+ RequestVerificationService::MessageType::FailedCompletionOfExecution,
+ RequestVerificationService::MessageType::FailedProgressOfExecution,
+ RequestVerificationService::MessageType::FailedRoutingReport,
+ RequestVerificationService::MessageType::FailedStartOfExecution,
+ RequestVerificationService::MessageType::SuccessfulAcceptanceReport,
+ RequestVerificationService::MessageType::SuccessfulCompletionOfExecution,
+ RequestVerificationService::MessageType::SuccessfulProgressOfExecution,
+ RequestVerificationService::MessageType::SuccessfulStartOfExecution};
+
+ etl::vector<uint8_t, 15> st03Messages = {
+ HousekeepingService::MessageType::DisablePeriodicHousekeepingParametersReport,
+ HousekeepingService::MessageType::EnablePeriodicHousekeepingParametersReport,
+ HousekeepingService::MessageType::GenerateOneShotHousekeepingReport,
+ HousekeepingService::MessageType::HousekeepingParametersReport,
+ HousekeepingService::MessageType::HousekeepingPeriodicPropertiesReport,
+ HousekeepingService::MessageType::HousekeepingStructuresReport};
+
+ etl::vector<uint8_t, 15> st04Messages = {
+ ParameterStatisticsService::MessageType::ParameterStatisticsDefinitionsReport,
+ ParameterStatisticsService::MessageType::ParameterStatisticsReport,
+ };
+
+ etl::vector<uint8_t, 15> st05Messages = {EventReportService::MessageType::HighSeverityAnomalyReport,
+ EventReportService::MessageType::DisabledListEventReport,
+ EventReportService::MessageType::InformativeEventReport,
+ EventReportService::MessageType::LowSeverityAnomalyReport,
+ EventReportService::MessageType::MediumSeverityAnomalyReport};
+
+ etl::vector<uint8_t, 15> st06Messages = {MemoryManagementService::MessageType::CheckRawMemoryDataReport,
+ MemoryManagementService::MessageType::DumpRawMemoryDataReport};
+
+ etl::vector<uint8_t, 15> st11Messages = {TimeBasedSchedulingService::MessageType::TimeBasedScheduledSummaryReport};
+
+ etl::vector<uint8_t, 15> st13Messages = {LargePacketTransferService::MessageType::FirstDownlinkPartReport,
+ LargePacketTransferService::MessageType::InternalDownlinkPartReport,
+ LargePacketTransferService::MessageType::LastDownlinkPartReport};
+
+ etl::vector<uint8_t, 15> st17Messages = {TestService::MessageType::AreYouAliveTestReport,
+ TestService::MessageType::OnBoardConnectionTestReport};
+
+ etl::vector<uint8_t, 15> st19Messages = {EventActionService::MessageType::EventActionStatusReport};
+
+ etl::vector<uint8_t, 15> st20Messages = {ParameterService::MessageType::ParameterValuesReport};
+
+ etl::map<uint8_t, etl::vector<uint8_t, 15>, 100> messagesOfService = {
+ {RequestVerificationService::ServiceType, st01Messages},
+ {HousekeepingService::ServiceType, st03Messages},
+ {ParameterStatisticsService::ServiceType, st04Messages},
+ {EventReportService::ServiceType, st05Messages},
+ {MemoryManagementService::ServiceType, st06Messages},
+ {TimeBasedSchedulingService::ServiceType, st11Messages},
+ {LargePacketTransferService::ServiceType, st13Messages},
+ {TestService::ServiceType, st17Messages},
+ {EventActionService::ServiceType, st19Messages},
+ {ParameterService::ServiceType, st20Messages}};
+};
+
+#endif
diff --git a/inc/Helpers/ForwardControlConfiguration.hpp b/inc/Helpers/ForwardControlConfiguration.hpp
index c542450b670a91984fdd86cf2f56230ce7df018b..00656cbeb1306e202e8004f66945ed9023d2715a 100644
--- a/inc/Helpers/ForwardControlConfiguration.hpp
+++ b/inc/Helpers/ForwardControlConfiguration.hpp
@@ -46,17 +46,25 @@ public:
typedef etl::vector<uint8_t, ECSSMaxReportTypeDefinitions> reportTypeDefinitions;
/**
- * Map containing the Service Type definitions. Each Service Type definition is accessed via its key-name, of type
- * uint8, for example '20' for the Parameter Management service. Each Service Type definition, contains the
- * list of its own Report Type definitions.
+ * This is the key for the application process configuration map. It contains a pair with the applicationID and
+ * the serviceType.
*/
- typedef etl::map<uint8_t, reportTypeDefinitions, ECSSMaxServiceTypeDefinitions> serviceTypeDefinitions;
+ typedef std::pair<uint8_t, uint8_t> key;
+
+ // /**
+ // * Map containing the Service Type definitions. Each Service Type definition is accessed via its key-name, of
+ //type
+ // * uint8, for example '20' for the Parameter Management service. Each Service Type definition, contains the
+ // * list of its own Report Type definitions.
+ // */
+ // typedef etl::map<uint8_t, reportTypeDefinitions, ECSSMaxServiceTypeDefinitions> serviceTypeDefinitions;
/**
* Map containing the Application Process definitions. Each application has its own ID. The ID is used as a
* key to provide access to the list of Service Type definitions, included by the application.
*/
- etl::map<uint8_t, serviceTypeDefinitions, ECSSMaxControlledApplicationProcesses> definitions;
+ etl::map<key, reportTypeDefinitions, ECSSMaxControlledApplicationProcesses * ECSSMaxServiceTypeDefinitions>
+ definitions;
ApplicationProcess() = default;
};
diff --git a/inc/Services/RealTimeForwardingControlService.hpp b/inc/Services/RealTimeForwardingControlService.hpp
index 58361defc81891b4bc30d532db9ff1fa326c81e9..ef95db113b718c1ba2880b2b9fdde26422476b11 100644
--- a/inc/Services/RealTimeForwardingControlService.hpp
+++ b/inc/Services/RealTimeForwardingControlService.hpp
@@ -6,6 +6,7 @@
#include "ErrorHandler.hpp"
#include "etl/vector.h"
#include "Helpers/ForwardControlConfiguration.hpp"
+#include "Helpers/AllMessageTypes.hpp"
/**
* Implementation of the ST[14] 'Real Time Forwarding Control Service' as defined in ECSS-E-ST-70-41C.
@@ -37,6 +38,11 @@ public:
RealTimeForwardingControlService() = default;
+ /**
+ * All the message types of every service type.
+ */
+ AllMessageTypes allMessageTypes;
+
/**
* Contains the Application IDs, controlled by the Service.
*/
@@ -60,6 +66,17 @@ public:
ForwardControlConfiguration::EventReportBlocking eventReportBlockingConfiguration;
private:
+ /**
+ * Counts the number of service types, stored for the specified application process.
+ */
+ uint8_t countServicesOfApplication(uint8_t applicationID);
+
+ /**
+ *
+ * Counts the number of report types, stored for the specified service type.
+ */
+ uint8_t countReportsOfService(uint8_t applicationID, uint8_t serviceType);
+
/**
* Checks whether the specified message type already exists in the specified application process and service
* type definition.
diff --git a/src/Services/RealTimeForwardingControlService.cpp b/src/Services/RealTimeForwardingControlService.cpp
index a47bf769cb564aef55544e7a08bbdc575133c08d..3e9c0ebf589c17199c0712130424eb201daa66a6 100644
--- a/src/Services/RealTimeForwardingControlService.cpp
+++ b/src/Services/RealTimeForwardingControlService.cpp
@@ -1,5 +1,21 @@
+#include <iostream>
#include "Services/RealTimeForwardingControlService.hpp"
+uint8_t RealTimeForwardingControlService::countServicesOfApplication(uint8_t applicationID) {
+ uint8_t serviceCounter = 0;
+ for (auto& definition : applicationProcessConfiguration.definitions) {
+ auto& pair = definition.first;
+ if (pair.first == applicationID) {
+ serviceCounter++;
+ }
+ }
+ return serviceCounter;
+}
+
+uint8_t RealTimeForwardingControlService::countReportsOfService(uint8_t applicationID, uint8_t serviceType) {
+ return applicationProcessConfiguration.definitions[std::make_pair(applicationID, serviceType)].size();
+}
+
bool RealTimeForwardingControlService::appIsControlled(Message& request, uint8_t applicationId) {
if (std::find(controlledApplications.begin(), controlledApplications.end(), applicationId) ==
controlledApplications.end()) {
@@ -23,8 +39,7 @@ bool RealTimeForwardingControlService::checkApplicationOfAppProcessConfig(Messag
}
bool RealTimeForwardingControlService::allServiceTypesAllowed(Message& request, uint8_t applicationID) {
- if (applicationProcessConfiguration.definitions[applicationID].empty() and
- not applicationProcessConfiguration.notEmpty[applicationID].empty()) {
+ if (countServicesOfApplication(applicationID) >= ECSSMaxServiceTypeDefinitions) {
ErrorHandler::reportError(request, ErrorHandler::ExecutionStartErrorType::AllServiceTypesAlreadyAllowed);
return true;
}
@@ -32,7 +47,8 @@ bool RealTimeForwardingControlService::allServiceTypesAllowed(Message& request,
}
bool RealTimeForwardingControlService::maxServiceTypesReached(Message& request, uint8_t applicationID) {
- if (applicationProcessConfiguration.definitions[applicationID].size() >= ECSSMaxServiceTypeDefinitions) {
+ if (countServicesOfApplication(applicationID) >= ECSSMaxServiceTypeDefinitions) {
+// std::cout<<"err22\n";
ErrorHandler::reportError(request, ErrorHandler::ExecutionStartErrorType::MaxServiceTypesReached);
return true;
}
@@ -50,8 +66,9 @@ bool RealTimeForwardingControlService::checkService(Message& request, uint8_t ap
bool RealTimeForwardingControlService::allReportTypesAllowed(Message& request, uint8_t applicationID,
uint8_t serviceType) {
- if (applicationProcessConfiguration.definitions[applicationID][serviceType].empty() and
- applicationProcessConfiguration.notEmpty[applicationID][serviceType]) {
+// std::cout<<"num mess= "<<static_cast<int>(countReportsOfService(applicationID, serviceType))<<"\n";
+ if (countReportsOfService(applicationID, serviceType) >= allMessageTypes.messagesOfService[serviceType].size()) {
+// std::cout<<"err23\n";
ErrorHandler::reportError(request, ErrorHandler::ExecutionStartErrorType::AllReportTypesAlreadyAllowed);
return true;
}
@@ -60,8 +77,7 @@ bool RealTimeForwardingControlService::allReportTypesAllowed(Message& request, u
bool RealTimeForwardingControlService::maxReportTypesReached(Message& request, uint8_t applicationID,
uint8_t serviceType) {
- if (applicationProcessConfiguration.definitions[applicationID][serviceType].size() >=
- ECSSMaxReportTypeDefinitions) {
+ if (countReportsOfService(applicationID, serviceType) >= allMessageTypes.messagesOfService[serviceType].size()) {
ErrorHandler::reportError(request, ErrorHandler::ExecutionStartErrorType::MaxReportTypesReached);
return true;
}
@@ -79,52 +95,60 @@ bool RealTimeForwardingControlService::checkMessage(Message& request, uint8_t ap
bool RealTimeForwardingControlService::reportExistsInAppProcessConfiguration(uint8_t applicationID, uint8_t serviceType,
uint8_t messageType) {
- return std::find(applicationProcessConfiguration.definitions[applicationID][serviceType].begin(),
- applicationProcessConfiguration.definitions[applicationID][serviceType].end(),
- messageType) != applicationProcessConfiguration.definitions[applicationID][serviceType].end();
+ auto appServicePair = std::make_pair(applicationID, serviceType);
+ return std::find(applicationProcessConfiguration.definitions[appServicePair].begin(),
+ applicationProcessConfiguration.definitions[appServicePair].end(),
+ messageType) != applicationProcessConfiguration.definitions[appServicePair].end();
}
void RealTimeForwardingControlService::addReportTypesToAppProcessConfiguration(Message& request) {
request.assertTC(ServiceType, MessageType::AddReportTypesToAppProcessConfiguration);
uint8_t numOfApplications = request.readUint8();
+// std::cout << static_cast<int>(numOfApplications) << "\n";
for (uint8_t i = 0; i < numOfApplications; i++) {
uint8_t applicationID = request.readUint8();
uint8_t numOfServices = request.readUint8();
+// std::cout << "app= " << static_cast<int>(applicationID) << "\n";
if (not checkApplicationOfAppProcessConfig(request, applicationID, numOfServices)) {
+// std::cout << "err1\n";
continue;
}
- if (numOfServices == 0) {
- applicationProcessConfiguration.definitions[applicationID].clear();
- continue;
- }
+ // if (numOfServices == 0) {
+ // applicationProcessConfiguration.definitions[applicationID].clear();
+ // continue;
+ // }
for (uint8_t j = 0; j < numOfServices; j++) {
// todo: check if service type is valid.
uint8_t serviceType = request.readUint8();
uint8_t numOfMessages = request.readUint8();
+// std::cout << "serv= " << static_cast<int>(serviceType) << "\n";
+// std::cout << "size= " << static_cast<int>(countServicesOfApplication(applicationID)) << "\n";
if (not checkService(request, applicationID, serviceType, numOfMessages)) {
+// std::cout << "err2\n";
continue;
}
- if (numOfMessages == 0) {
- applicationProcessConfiguration.definitions[applicationID][serviceType].clear();
- continue;
- }
+ // if (numOfMessages == 0) {
+ // applicationProcessConfiguration.definitions[applicationID][serviceType].clear();
+ // continue;
+ // }
for (uint8_t k = 0; k < numOfMessages; k++) {
uint8_t messageType = request.readUint8();
+// std::cout << "mess= " << static_cast<int>(messageType) << "\n";
if (not checkMessage(request, applicationID, serviceType, messageType)) {
+// std::cout << "err3\n";
continue;
}
-
// todo: check if message type is valid.
- applicationProcessConfiguration.definitions[applicationID][serviceType].push_back(messageType);
- applicationProcessConfiguration.notEmpty[applicationID][serviceType] = true;
+ applicationProcessConfiguration.definitions[std::make_pair(applicationID, serviceType)].push_back(
+ messageType);
}
}
}
diff --git a/test/Services/RealTimeForwardingControl.cpp b/test/Services/RealTimeForwardingControl.cpp
index ebf08f414cd1d4aea538a3d4d3d4e9106c78a6dd..ffb6f702f9459f74cc0cb26c53a2a26140f24946 100644
--- a/test/Services/RealTimeForwardingControl.cpp
+++ b/test/Services/RealTimeForwardingControl.cpp
@@ -9,8 +9,8 @@ RealTimeForwardingControlService& realTimeForwarding = Services.realTimeForwardi
uint8_t applications[] = {1};
uint8_t services[] = {3, 5};
-uint8_t allServices[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
-uint8_t redundantServices[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17};
+uint8_t allServices[] = {1, 3, 4, 5, 6, 11, 13, 17, 19, 20};
+uint8_t redundantServices[] = {1, 3, 4, 5, 6, 11, 13, 17, 19, 20, 1, 3};
uint8_t messages1[] = {HousekeepingService::MessageType::HousekeepingPeriodicPropertiesReport,
HousekeepingService::MessageType::DisablePeriodicHousekeepingParametersReport};
@@ -73,7 +73,7 @@ void validInvalidReportTypes(Message& request) {
for (uint8_t i = 0; i < numOfApplications; i++) {
request.appendUint8(applications2[i]);
- uint8_t numOfServicesPerApp = (i == 0) ? 17 : 2;
+ uint8_t numOfServicesPerApp = (i == 0) ? 12 : 2;
uint8_t* servicesToPick = (i == 0) ? redundantServices : services;
request.appendUint8(numOfServicesPerApp);
@@ -199,31 +199,24 @@ TEST_CASE("Add report types to the Application Process Configuration") {
CHECK(ServiceTests::count() == 0);
auto& applicationProcesses = realTimeForwarding.applicationProcessConfiguration.definitions;
- REQUIRE(applicationProcesses.size() == 1);
+ REQUIRE(applicationProcesses.size() == 2);
for (auto appID : applications) {
- REQUIRE(applicationProcesses.find(appID) != applicationProcesses.end());
- REQUIRE(applicationProcesses[appID].size() == 2);
-
for (uint8_t j = 0; j < 2; j++) {
uint8_t serviceType = services[j];
- REQUIRE(applicationProcesses[appID].find(serviceType) != applicationProcesses[appID].end());
- REQUIRE(applicationProcesses[appID][serviceType].size() == 2);
+ auto appServicePair = std::make_pair(appID, serviceType);
+ REQUIRE(applicationProcesses.find(appServicePair) != applicationProcesses.end());
+ REQUIRE(applicationProcesses[appServicePair].size() == 2);
uint8_t* messages = (j == 0) ? messages1 : messages2;
for (uint8_t k = 0; k < 2; k++) {
- REQUIRE(std::find(applicationProcesses[appID][serviceType].begin(),
- applicationProcesses[appID][serviceType].end(),
- messages[k]) != applicationProcesses[appID][serviceType].end());
+ REQUIRE(std::find(applicationProcesses[appServicePair].begin(),
+ applicationProcesses[appServicePair].end(),
+ messages[k]) != applicationProcesses[appServicePair].end());
}
}
}
- auto& servicesAllowed = realTimeForwarding.applicationProcessConfiguration.notEmpty;
- REQUIRE(servicesAllowed[applicationID].size() == 2);
- REQUIRE(servicesAllowed[applicationID][services[0]] == true);
- REQUIRE(servicesAllowed[applicationID][services[1]] == true);
-
resetAppProcessConfiguration();
ServiceTests::reset();
Services.reset();
@@ -258,16 +251,17 @@ TEST_CASE("Add report types to the Application Process Configuration") {
realTimeForwarding.controlledApplications.push_back(applicationID);
validReportTypes(request);
- realTimeForwarding.applicationProcessConfiguration.definitions[applicationID].clear();
- CHECK(realTimeForwarding.applicationProcessConfiguration.definitions[applicationID].empty());
- realTimeForwarding.applicationProcessConfiguration.notEmpty[applicationID][services[0]] = true;
+ for (uint8_t i = 1; i < ECSSMaxServiceTypeDefinitions + 1; i++) {
+ realTimeForwarding.applicationProcessConfiguration.definitions[std::make_pair(applicationID, i)];
+ }
+ CHECK(realTimeForwarding.applicationProcessConfiguration.definitions.size() == ECSSMaxServiceTypeDefinitions);
MessageParser::execute(request);
CHECK(ServiceTests::count() == 1);
CHECK(ServiceTests::countThrownErrors(ErrorHandler::ExecutionStartErrorType::AllServiceTypesAlreadyAllowed) ==
1);
- REQUIRE(realTimeForwarding.applicationProcessConfiguration.definitions[applicationID].empty());
+ REQUIRE(realTimeForwarding.applicationProcessConfiguration.definitions.size() == ECSSMaxServiceTypeDefinitions);
resetAppProcessConfiguration();
ServiceTests::reset();
@@ -280,24 +274,24 @@ TEST_CASE("Add report types to the Application Process Configuration") {
Message::TC, 1);
uint8_t applicationID = 1;
+ uint8_t serviceType1 = services[0]; // st03
+ uint8_t serviceType2 = services[1]; // st05
+
realTimeForwarding.controlledApplications.push_back(applicationID);
validReportTypes(request);
- auto& applicationProcessConfig = realTimeForwarding.applicationProcessConfiguration;
+ auto& applicationProcessConfig = realTimeForwarding.applicationProcessConfiguration.definitions;
- for (auto service : allServices) {
- applicationProcessConfig.definitions[applicationID][service].clear();
- applicationProcessConfig.notEmpty[applicationID][service] = true;
+ for (uint8_t i = 100; i < ECSSMaxServiceTypeDefinitions + 99; i++) {
+ applicationProcessConfig[std::make_pair(applicationID, i)];
}
- REQUIRE(applicationProcessConfig.definitions[applicationID].size() == 15);
- REQUIRE(applicationProcessConfig.notEmpty[applicationID].size() == 15);
+ CHECK(applicationProcessConfig.size() == ECSSMaxServiceTypeDefinitions - 1);
MessageParser::execute(request);
- CHECK(ServiceTests::count() == 2);
- CHECK(ServiceTests::countThrownErrors(ErrorHandler::ExecutionStartErrorType::MaxServiceTypesReached) == 2);
- REQUIRE(applicationProcessConfig.definitions[applicationID].size() == 15);
- REQUIRE(applicationProcessConfig.notEmpty[applicationID].size() == 15);
+ CHECK(ServiceTests::count() == 1);
+ CHECK(ServiceTests::countThrownErrors(ErrorHandler::ExecutionStartErrorType::MaxServiceTypesReached) == 1);
+ REQUIRE(applicationProcessConfig.size() == ECSSMaxServiceTypeDefinitions);
resetAppProcessConfiguration();
ServiceTests::reset();
@@ -310,20 +304,23 @@ TEST_CASE("Add report types to the Application Process Configuration") {
Message::TC, 1);
uint8_t applicationID = 1;
- uint8_t serviceType = services[0];
+ uint8_t serviceType = services[0]; // st03
realTimeForwarding.controlledApplications.push_back(applicationID);
validReportTypes(request);
- realTimeForwarding.applicationProcessConfiguration.definitions[applicationID][serviceType].clear();
- CHECK(realTimeForwarding.applicationProcessConfiguration.definitions[applicationID][serviceType].empty());
- realTimeForwarding.applicationProcessConfiguration.notEmpty[applicationID][serviceType] = true;
+ for (auto message : realTimeForwarding.allMessageTypes.st03Messages) {
+ realTimeForwarding.applicationProcessConfiguration.definitions[std::make_pair(applicationID, serviceType)]
+ .push_back(message);
+ }
MessageParser::execute(request);
CHECK(ServiceTests::count() == 1);
CHECK(ServiceTests::countThrownErrors(ErrorHandler::ExecutionStartErrorType::AllReportTypesAlreadyAllowed) ==
1);
- REQUIRE(realTimeForwarding.applicationProcessConfiguration.definitions[applicationID].size() == 2);
+ REQUIRE(
+ realTimeForwarding.applicationProcessConfiguration.definitions[std::make_pair(applicationID, serviceType)]
+ .size() == realTimeForwarding.allMessageTypes.messagesOfService[serviceType].size());
resetAppProcessConfiguration();
ServiceTests::reset();
@@ -336,31 +333,38 @@ TEST_CASE("Add report types to the Application Process Configuration") {
Message::TC, 1);
uint8_t applicationID = 1;
- uint8_t serviceType = services[0];
+ uint8_t serviceType1 = services[0]; // st03
+ uint8_t serviceType2 = services[1]; // st05
+
realTimeForwarding.controlledApplications.push_back(applicationID);
validReportTypes(request);
auto& applicationProcessConfig = realTimeForwarding.applicationProcessConfiguration;
- applicationProcessConfig.notEmpty[applicationID][serviceType] = true;
- for (uint8_t i = 0; i < ECSSMaxReportTypeDefinitions; i++) {
- applicationProcessConfig.definitions[applicationID][serviceType].push_back(i);
- }
+ auto appServicePair1 = std::make_pair(applicationID, serviceType1);
+ auto appServicePair2 = std::make_pair(applicationID, serviceType2);
+ REQUIRE(applicationProcessConfig.definitions[appServicePair1].empty());
+ REQUIRE(applicationProcessConfig.definitions[appServicePair2].empty());
- REQUIRE(applicationProcessConfig.definitions[applicationID].size() == 1);
- REQUIRE(applicationProcessConfig.notEmpty[applicationID].size() == 1);
- REQUIRE(applicationProcessConfig.definitions[applicationID][serviceType].size() ==
- ECSSMaxReportTypeDefinitions);
+ auto numOfMessages1 = realTimeForwarding.allMessageTypes.messagesOfService[serviceType1].size();
+ auto numOfMessages2 = realTimeForwarding.allMessageTypes.messagesOfService[serviceType2].size();
+
+ for (uint8_t i = 0; i < numOfMessages1 - 1; i++) {
+ applicationProcessConfig.definitions[appServicePair1].push_back(i);
+ }
+ for (uint8_t i = 16; i < numOfMessages2 + 15; i++) {
+ applicationProcessConfig.definitions[appServicePair2].push_back(i);
+ }
+ REQUIRE(applicationProcessConfig.definitions[appServicePair1].size() == numOfMessages1 - 1);
+ REQUIRE(applicationProcessConfig.definitions[appServicePair2].size() == numOfMessages2 - 1);
MessageParser::execute(request);
CHECK(ServiceTests::count() == 2);
CHECK(ServiceTests::countThrownErrors(ErrorHandler::ExecutionStartErrorType::MaxReportTypesReached) == 2);
- REQUIRE(applicationProcessConfig.definitions[applicationID].size() == 2);
- REQUIRE(applicationProcessConfig.notEmpty[applicationID].size() == 2);
- REQUIRE(applicationProcessConfig.definitions[applicationID][services[1]].size() == 2);
- REQUIRE(applicationProcessConfig.definitions[applicationID][serviceType].size() ==
- ECSSMaxReportTypeDefinitions);
+ REQUIRE(applicationProcessConfig.definitions.size() == 2);
+ REQUIRE(applicationProcessConfig.definitions[appServicePair1].size() == numOfMessages1);
+ REQUIRE(applicationProcessConfig.definitions[appServicePair2].size() == numOfMessages2);
resetAppProcessConfiguration();
ServiceTests::reset();
@@ -380,29 +384,19 @@ TEST_CASE("Add report types to the Application Process Configuration") {
CHECK(ServiceTests::count() == 0);
auto& applicationProcesses = realTimeForwarding.applicationProcessConfiguration.definitions;
- REQUIRE(applicationProcesses.size() == 1);
+ REQUIRE(applicationProcesses.size() == 2);
for (auto appID : applications) {
- REQUIRE(applicationProcesses.find(appID) != applicationProcesses.end());
- REQUIRE(applicationProcesses[appID].size() == 2);
-
for (auto& serviceType : services) {
- REQUIRE(applicationProcesses[appID].find(serviceType) != applicationProcesses[appID].end());
- REQUIRE(applicationProcesses[appID][serviceType].size() == 1);
-
- for (uint8_t k = 0; k < 2; k++) {
- REQUIRE(std::find(applicationProcesses[appID][serviceType].begin(),
- applicationProcesses[appID][serviceType].end(),
- messages1[0]) != applicationProcesses[appID][serviceType].end());
- }
+ auto appServicePair = std::make_pair(appID, serviceType);
+ REQUIRE(applicationProcesses.find(appServicePair) != applicationProcesses.end());
+ REQUIRE(applicationProcesses[appServicePair].size() == 1);
+ REQUIRE(std::find(applicationProcesses[appServicePair].begin(),
+ applicationProcesses[appServicePair].end(),
+ messages1[0]) != applicationProcesses[appServicePair].end());
}
}
- auto& servicesAllowed = realTimeForwarding.applicationProcessConfiguration.notEmpty;
- REQUIRE(servicesAllowed[applicationID].size() == 2);
- REQUIRE(servicesAllowed[applicationID][services[0]] == true);
- REQUIRE(servicesAllowed[applicationID][services[1]] == true);
-
resetAppProcessConfiguration();
ServiceTests::reset();
Services.reset();
@@ -412,7 +406,6 @@ TEST_CASE("Add report types to the Application Process Configuration") {
Message request(RealTimeForwardingControlService::ServiceType,
RealTimeForwardingControlService::MessageType::AddReportTypesToAppProcessConfiguration,
Message::TC, 1);
-
uint8_t applicationID1 = 1;
uint8_t applicationID2 = 2;
uint8_t applicationID3 = 3;
@@ -420,102 +413,23 @@ TEST_CASE("Add report types to the Application Process Configuration") {
realTimeForwarding.controlledApplications.push_back(applicationID3);
validInvalidReportTypes(request);
- realTimeForwarding.applicationProcessConfiguration.definitions[applicationID3].clear();
- CHECK(realTimeForwarding.applicationProcessConfiguration.definitions[applicationID3].empty());
- realTimeForwarding.applicationProcessConfiguration.notEmpty[applicationID3][services[0]] = true;
-
- MessageParser::execute(request);
-
- CHECK(ServiceTests::count() == 4);
- CHECK(ServiceTests::countThrownErrors(ErrorHandler::ExecutionStartErrorType::NotControlledApplication) == 1);
- CHECK(ServiceTests::countThrownErrors(ErrorHandler::ExecutionStartErrorType::MaxServiceTypesReached) == 2);
- CHECK(ServiceTests::countThrownErrors(ErrorHandler::ExecutionStartErrorType::AllServiceTypesAlreadyAllowed) ==
- 1);
-
- auto& applicationProcesses = realTimeForwarding.applicationProcessConfiguration.definitions;
- auto& servicesAllowed = realTimeForwarding.applicationProcessConfiguration.notEmpty;
-
- REQUIRE(applicationProcesses.size() == 2);
- REQUIRE(applicationProcesses.find(applicationID2) == applicationProcesses.end());
- REQUIRE(applicationProcesses.find(applicationID1) != applicationProcesses.end());
- REQUIRE(applicationProcesses.find(applicationID3) != applicationProcesses.end());
-
- REQUIRE(applicationProcesses[applicationID1].size() == 15);
- REQUIRE(servicesAllowed[applicationID1].size() == 15);
- for (auto serviceType : allServices) {
- REQUIRE(servicesAllowed[applicationID1][serviceType]);
+ for (uint8_t i = 100; i < ECSSMaxServiceTypeDefinitions + 99; i++) {
+ realTimeForwarding.applicationProcessConfiguration.definitions[std::make_pair(applicationID3, i)];
}
- REQUIRE(applicationProcesses[applicationID3].empty());
-
- for (auto& serviceType : applicationProcesses[applicationID1]) {
- REQUIRE(std::find(std::begin(allServices), std::end(allServices), serviceType.first) !=
- std::end(allServices));
- REQUIRE(serviceType.second.size() == 2);
- auto& messagesToCheck = (serviceType.first == 1) ? messages1 : messages2;
- for (auto message : serviceType.second) {
- REQUIRE(std::find(std::begin(messagesToCheck), std::end(messagesToCheck), message) !=
- std::end(messagesToCheck));
- }
- }
-
- REQUIRE(servicesAllowed[applicationID3].size() == 1);
- REQUIRE(servicesAllowed[applicationID3][services[0]] == true);
-
- resetAppProcessConfiguration();
- ServiceTests::reset();
- Services.reset();
- }
-
- SECTION("Valid addition of all report types of a specified service type") {
- Message request(RealTimeForwardingControlService::ServiceType,
- RealTimeForwardingControlService::MessageType::AddReportTypesToAppProcessConfiguration,
- Message::TC, 1);
- uint8_t applicationID1 = 1;
- realTimeForwarding.controlledApplications.push_back(applicationID1);
- validAllReportsOfService(request);
+ CHECK(realTimeForwarding.applicationProcessConfiguration.definitions.size() ==
+ ECSSMaxServiceTypeDefinitions - 1);
MessageParser::execute(request);
- CHECK(ServiceTests::count() == 0);
- auto& applicationProcesses = realTimeForwarding.applicationProcessConfiguration.definitions;
- REQUIRE(applicationProcesses[applicationID1].size() == 2);
- for (auto serviceType : services) {
- REQUIRE(applicationProcesses[applicationID1].find(serviceType) !=
- applicationProcesses[applicationID1].end());
- REQUIRE(applicationProcesses[applicationID1][serviceType].empty());
- }
-
- resetAppProcessConfiguration();
- ServiceTests::reset();
- Services.reset();
- }
-
- SECTION("Addition of all report types of a service type, combined with invalid requests") {
- Message request(RealTimeForwardingControlService::ServiceType,
- RealTimeForwardingControlService::MessageType::AddReportTypesToAppProcessConfiguration,
- Message::TC, 1);
- uint8_t applicationID1 = 1;
- uint8_t applicationID2 = 2;
- realTimeForwarding.controlledApplications.push_back(applicationID1);
- realTimeForwarding.controlledApplications.push_back(applicationID2);
- validInvalidAllReportsOfService(request);
-
- MessageParser::execute(request);
-
- CHECK(ServiceTests::count() == 3);
+ CHECK(ServiceTests::count() == 7);
CHECK(ServiceTests::countThrownErrors(ErrorHandler::ExecutionStartErrorType::NotControlledApplication) == 1);
- CHECK(ServiceTests::countThrownErrors(ErrorHandler::ExecutionStartErrorType::MaxServiceTypesReached) == 2);
+ CHECK(ServiceTests::countThrownErrors(ErrorHandler::ExecutionStartErrorType::MaxServiceTypesReached) == 3);
+ CHECK(ServiceTests::countThrownErrors(ErrorHandler::ExecutionStartErrorType::MaxReportTypesReached) == 3);
- auto& applicationProcesses = realTimeForwarding.applicationProcessConfiguration.definitions;
- REQUIRE(applicationProcesses.size() == 2);
- REQUIRE(applicationProcesses[applicationID1].size() == 15);
- REQUIRE(applicationProcesses[applicationID2].size() == 2);
-
- for (auto& serviceType : applicationProcesses[applicationID1]) {
- REQUIRE(serviceType.second.empty());
- }
- for (auto& serviceType : applicationProcesses[applicationID2]) {
- REQUIRE(serviceType.second.empty());
+ auto& definitions = realTimeForwarding.applicationProcessConfiguration.definitions;
+ REQUIRE(definitions.size() == 20);
+ for (auto serviceType : allServices) {
+ REQUIRE(definitions.find(std::make_pair(applicationID1, serviceType)) != definitions.end());
}
resetAppProcessConfiguration();
@@ -523,49 +437,107 @@ TEST_CASE("Add report types to the Application Process Configuration") {
Services.reset();
}
- SECTION("Valid addition of all report types of an application process") {
- Message request(RealTimeForwardingControlService::ServiceType,
- RealTimeForwardingControlService::MessageType::AddReportTypesToAppProcessConfiguration,
- Message::TC, 1);
- uint8_t applicationID1 = 1;
- realTimeForwarding.controlledApplications.push_back(applicationID1);
- validAllReportsOfApp(request);
-
- MessageParser::execute(request);
-
- CHECK(ServiceTests::count() == 0);
- auto& applicationProcesses = realTimeForwarding.applicationProcessConfiguration.definitions;
- REQUIRE(applicationProcesses[applicationID1].empty());
-
- resetAppProcessConfiguration();
- ServiceTests::reset();
- Services.reset();
- }
-
- SECTION("Addition of all report types of an application process, combined with invalid request") {
- Message request(RealTimeForwardingControlService::ServiceType,
- RealTimeForwardingControlService::MessageType::AddReportTypesToAppProcessConfiguration,
- Message::TC, 1);
- uint8_t applicationID1 = 1;
- uint8_t applicationID2 = 2;
- realTimeForwarding.controlledApplications.push_back(applicationID1);
- realTimeForwarding.controlledApplications.push_back(applicationID2);
- validInvalidAllReportsOfApp(request);
-
- MessageParser::execute(request);
-
- CHECK(ServiceTests::count() == 1);
- CHECK(ServiceTests::countThrownErrors(ErrorHandler::ExecutionStartErrorType::NotControlledApplication) == 1);
- auto& applicationProcesses = realTimeForwarding.applicationProcessConfiguration.definitions;
-
- REQUIRE(applicationProcesses.find(applicationID1) != applicationProcesses.end());
- REQUIRE(applicationProcesses.find(applicationID2) != applicationProcesses.end());
- REQUIRE(applicationProcesses.find(3) == applicationProcesses.end());
- REQUIRE(applicationProcesses[applicationID1].empty());
- REQUIRE(applicationProcesses[applicationID2].empty());
-
- resetAppProcessConfiguration();
- ServiceTests::reset();
- Services.reset();
- }
+ // SECTION("Valid addition of all report types of a specified service type") {
+ // Message request(RealTimeForwardingControlService::ServiceType,
+ // RealTimeForwardingControlService::MessageType::AddReportTypesToAppProcessConfiguration,
+ // Message::TC, 1);
+ // uint8_t applicationID1 = 1;
+ // realTimeForwarding.controlledApplications.push_back(applicationID1);
+ // validAllReportsOfService(request);
+ //
+ // MessageParser::execute(request);
+ //
+ // CHECK(ServiceTests::count() == 0);
+ // auto& applicationProcesses = realTimeForwarding.applicationProcessConfiguration.definitions;
+ // REQUIRE(applicationProcesses[applicationID1].size() == 2);
+ // for (auto serviceType : services) {
+ // REQUIRE(applicationProcesses[applicationID1].find(serviceType) !=
+ // applicationProcesses[applicationID1].end());
+ // REQUIRE(applicationProcesses[applicationID1][serviceType].empty());
+ // }
+ //
+ // resetAppProcessConfiguration();
+ // ServiceTests::reset();
+ // Services.reset();
+ // }
+ //
+ // SECTION("Addition of all report types of a service type, combined with invalid requests") {
+ // Message request(RealTimeForwardingControlService::ServiceType,
+ // RealTimeForwardingControlService::MessageType::AddReportTypesToAppProcessConfiguration,
+ // Message::TC, 1);
+ // uint8_t applicationID1 = 1;
+ // uint8_t applicationID2 = 2;
+ // realTimeForwarding.controlledApplications.push_back(applicationID1);
+ // realTimeForwarding.controlledApplications.push_back(applicationID2);
+ // validInvalidAllReportsOfService(request);
+ //
+ // MessageParser::execute(request);
+ //
+ // CHECK(ServiceTests::count() == 3);
+ // CHECK(ServiceTests::countThrownErrors(ErrorHandler::ExecutionStartErrorType::NotControlledApplication) ==
+ // 1); CHECK(ServiceTests::countThrownErrors(ErrorHandler::ExecutionStartErrorType::MaxServiceTypesReached) ==
+ // 2);
+ //
+ // auto& applicationProcesses = realTimeForwarding.applicationProcessConfiguration.definitions;
+ // REQUIRE(applicationProcesses.size() == 2);
+ // REQUIRE(applicationProcesses[applicationID1].size() == 15);
+ // REQUIRE(applicationProcesses[applicationID2].size() == 2);
+ //
+ // for (auto& serviceType : applicationProcesses[applicationID1]) {
+ // REQUIRE(serviceType.second.empty());
+ // }
+ // for (auto& serviceType : applicationProcesses[applicationID2]) {
+ // REQUIRE(serviceType.second.empty());
+ // }
+ //
+ // resetAppProcessConfiguration();
+ // ServiceTests::reset();
+ // Services.reset();
+ // }
+ //
+ // SECTION("Valid addition of all report types of an application process") {
+ // Message request(RealTimeForwardingControlService::ServiceType,
+ // RealTimeForwardingControlService::MessageType::AddReportTypesToAppProcessConfiguration,
+ // Message::TC, 1);
+ // uint8_t applicationID1 = 1;
+ // realTimeForwarding.controlledApplications.push_back(applicationID1);
+ // validAllReportsOfApp(request);
+ //
+ // MessageParser::execute(request);
+ //
+ // CHECK(ServiceTests::count() == 0);
+ // auto& applicationProcesses = realTimeForwarding.applicationProcessConfiguration.definitions;
+ // REQUIRE(applicationProcesses[applicationID1].empty());
+ //
+ // resetAppProcessConfiguration();
+ // ServiceTests::reset();
+ // Services.reset();
+ // }
+ //
+ // SECTION("Addition of all report types of an application process, combined with invalid request") {
+ // Message request(RealTimeForwardingControlService::ServiceType,
+ // RealTimeForwardingControlService::MessageType::AddReportTypesToAppProcessConfiguration,
+ // Message::TC, 1);
+ // uint8_t applicationID1 = 1;
+ // uint8_t applicationID2 = 2;
+ // realTimeForwarding.controlledApplications.push_back(applicationID1);
+ // realTimeForwarding.controlledApplications.push_back(applicationID2);
+ // validInvalidAllReportsOfApp(request);
+ //
+ // MessageParser::execute(request);
+ //
+ // CHECK(ServiceTests::count() == 1);
+ // CHECK(ServiceTests::countThrownErrors(ErrorHandler::ExecutionStartErrorType::NotControlledApplication) ==
+ // 1); auto& applicationProcesses = realTimeForwarding.applicationProcessConfiguration.definitions;
+ //
+ // REQUIRE(applicationProcesses.find(applicationID1) != applicationProcesses.end());
+ // REQUIRE(applicationProcesses.find(applicationID2) != applicationProcesses.end());
+ // REQUIRE(applicationProcesses.find(3) == applicationProcesses.end());
+ // REQUIRE(applicationProcesses[applicationID1].empty());
+ // REQUIRE(applicationProcesses[applicationID2].empty());
+ //
+ // resetAppProcessConfiguration();
+ // ServiceTests::reset();
+ // Services.reset();
+ // }
}