diff --git a/CMakeLists.txt b/CMakeLists.txt
index d0257ae73a208b2c81db0d1278da390ce42fccfc..24ae6a8fd012616ff86b4a546faef0c52dd084a2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -47,6 +47,7 @@ add_library(common OBJECT
src/Helpers/Statistic.cpp
src/Services/RealTimeForwardingControlService.cpp
src/Helpers/PMONBase.cpp
+ src/Helpers/AllMessageTypes.cpp
)
# Specify the .cpp files for the executables
diff --git a/inc/ECSS_Definitions.hpp b/inc/ECSS_Definitions.hpp
index 52f182444ff7ce613f3c412b2c4600c3fa80b804..79eb5bd7b14d153b5230a8359e314eed492a4cc9 100644
--- a/inc/ECSS_Definitions.hpp
+++ b/inc/ECSS_Definitions.hpp
@@ -185,6 +185,9 @@ inline const uint8_t ECSSMaxHousekeepingStructures = 10;
/**
<<<<<<< HEAD
+<<<<<<< HEAD
+=======
+>>>>>>> master
* The max number of controlled application processes
* @see RealTimeForwardingControlService
*/
@@ -194,6 +197,7 @@ inline const uint8_t ECSSMaxControlledApplicationProcesses = 5;
* The max number of report type blocking definitions per service type definition in the application process
* configuration
* @see RealTimeForwardingControlService
+ * todo: must change when a service with more report types is implemented.
*/
inline const uint8_t ECSSMaxReportTypeDefinitions = 20;
@@ -201,15 +205,16 @@ inline const uint8_t ECSSMaxReportTypeDefinitions = 20;
* The max number of service type definitions per application process type definition in the application process
* configuration
* @see RealTimeForwardingControlService
+ * todo: must change when all 15 services are implemented.
*/
-inline const uint8_t ECSSMaxServiceTypeDefinitions = 15;
+inline const uint8_t ECSSMaxServiceTypeDefinitions = 10;
/**
- * The max number of housekeeping structure IDs per housekeeping parameter report type definition in the housekeeping
- * parameter report configuration
- * @see RealTimeForwardingControlService
+ * The number of possible combinations between application processes and service types, i.e. the number of all
+ * possible (applicationID, serviceType) pairs.
*/
-inline const uint8_t ECSSMaxHousekeepingStructureIDs = 10;
+inline const uint8_t ECSSMaxApplicationsServicesCombinations = ECSSMaxControlledApplicationProcesses *
+ ECSSMaxServiceTypeDefinitions;
/**
* The max number of event definition IDs per event report blocking type definition in the event report blocking
@@ -231,6 +236,5 @@ inline struct {
*/
inline const uint8_t ECSSMaxMonitoringDefinitions = 4;
-
/** @} */
#endif // ECSS_SERVICES_ECSS_DEFINITIONS_H
diff --git a/inc/ErrorHandler.hpp b/inc/ErrorHandler.hpp
index cf996ca0cfb613576537c105a4868074c46a2bfc..216c9b1bce25a21d9903973c7f1a4dcf543b033e 100644
--- a/inc/ErrorHandler.hpp
+++ b/inc/ErrorHandler.hpp
@@ -334,16 +334,19 @@ public:
* Application Process configuration (ST[14])
*/
AllServiceTypesAlreadyAllowed = 48,
+
/**
* Attempt to add a new report type, when the max number of reports types allowed per service type
* definition in the Application Process configuration is already reached (ST[14])
*/
MaxReportTypesReached = 49,
+
/**
* Attempt to add a new service type, when the max number of service types allowed per application process
* definition in the Application Process configuration is already reached (ST[14])
*/
MaxServiceTypesReached = 50,
+
/**
* Attempt to add a report/event definition/housekeeping report type, when the specified application process
* ID is not controlled by the Service (ST[14])
diff --git a/inc/Helpers/AllMessageTypes.hpp b/inc/Helpers/AllMessageTypes.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..fb5c2c488647f0b54fa783dd09c72eff28801092
--- /dev/null
+++ b/inc/Helpers/AllMessageTypes.hpp
@@ -0,0 +1,20 @@
+#ifndef ECSS_SERVICES_ALLMESSAGETYPES_HPP
+#define ECSS_SERVICES_ALLMESSAGETYPES_HPP
+
+#include "ECSS_Definitions.hpp"
+#include <etl/map.h>
+#include <etl/vector.h>
+
+/**
+ * Namespace containing all the message types for every service type.
+ */
+namespace AllMessageTypes {
+ /**
+ * Map containing all the message types, per service. The key is the ServiceType and the value,
+ * an etl vector containing the message types.
+ */
+ extern etl::map<uint8_t, etl::vector<uint8_t, ECSSMaxReportTypeDefinitions>, ECSSMaxServiceTypeDefinitions> messagesOfService;
+
+} // namespace AllMessageTypes
+
+#endif
diff --git a/inc/Helpers/ForwardControlConfiguration.hpp b/inc/Helpers/ForwardControlConfiguration.hpp
index 7a72e17674f712b357327f01608b9ebd24e88cb7..da573dd1ff4979caaa4ed8953fb88874ee3a1e35 100644
--- a/inc/Helpers/ForwardControlConfiguration.hpp
+++ b/inc/Helpers/ForwardControlConfiguration.hpp
@@ -7,17 +7,10 @@
#include "etl/map.h"
#include "etl/vector.h"
-/**
- * Implements the Real Time Forward Control configuration, which includes three separate configurations, Application
- * Process configuration, Housekeeping configuration and Event Report configuration. These configurations contain
- * definitions, which indicate whether a telemetry message should be forwarded to the ground station.
- *
- * @author Konstantinos Petridis <petridkon@gmail.com>
- */
-
/**
* The Application Process configuration. It's basically a map, storing a vector of report type definitions for each
- * pair of (applicationID, serviceType).
+ * pair of (applicationID, serviceType). It contains definitions, which indicate whether a telemetry message, produced
+ * by a service, inside an application process (subsystem), should be forwarded to the ground station.
*/
class ApplicationProcessConfiguration {
public:
@@ -25,13 +18,13 @@ public:
* Vector containing the Report Type definitions. Each definition has its unique name of type uint8. For
* example, a Report Type definition could be 'ReportHousekeepingStructures'.
*/
- typedef etl::vector<uint8_t, ECSSMaxReportTypeDefinitions> reportTypeDefinitions;
+ typedef etl::vector<uint8_t, ECSSMaxReportTypeDefinitions> ReportTypeDefinitions;
/**
* This is the key for the application process configuration map. It contains a pair with the applicationID and
* the serviceType.
*/
- typedef std::pair<uint8_t, uint8_t> appServiceKey;
+ typedef std::pair<uint8_t, uint8_t> AppServiceKey;
/**
* Map containing the report type definitions. Each application process has its own ID. The combination of the
@@ -46,9 +39,7 @@ public:
* already exist in the map, and the requested report type is located in the vector of report types, which corresponds
* to the appID and service type.
*/
- etl::map<appServiceKey, reportTypeDefinitions,
- ECSSMaxControlledApplicationProcesses * ECSSMaxServiceTypeDefinitions>
- definitions;
+ etl::map<AppServiceKey, ReportTypeDefinitions, ECSSMaxApplicationsServicesCombinations> definitions;
ApplicationProcessConfiguration() = default;
};
diff --git a/inc/Platform/x86/ECSS_Configuration.hpp b/inc/Platform/x86/ECSS_Configuration.hpp
index f67bd19f6fe3785264bbeaabd5c3dc7302e1d3d0..bd4e0163632d1b4b4b2bae10a6f96c24c1ff3872 100644
--- a/inc/Platform/x86/ECSS_Configuration.hpp
+++ b/inc/Platform/x86/ECSS_Configuration.hpp
@@ -18,9 +18,7 @@
* @{
*/
-#define SERVICE_ALL ///< Enables compilation of all the ECSS services
-
-#ifdef SERVICE_ALL
+#define SERVICE_ALL
#define SERVICE_EVENTACTION ///< Compile ST[19] event-action
#define SERVICE_EVENTREPORT ///< Compile ST[05] event reporting
#define SERVICE_FUNCTION ///< Compile ST[08] function management
@@ -36,7 +34,5 @@
#define SERVICE_TEST ///< Compile ST[17] test
#define SERVICE_TIME ///< Compile ST[09] time management
#define SERVICE_TIMESCHEDULING ///< Compile ST[11] time-based scheduling
-#endif
-/** @} */
#endif // ECSS_SERVICES_ECSS_CONFIGURATION_HPP
diff --git a/inc/Services/RealTimeForwardingControlService.hpp b/inc/Services/RealTimeForwardingControlService.hpp
index 1f4ec8fc5de204a812552bc25a7f70d261f380fa..580c5e61776b83aaf2766a40382a47d341c04e76 100644
--- a/inc/Services/RealTimeForwardingControlService.hpp
+++ b/inc/Services/RealTimeForwardingControlService.hpp
@@ -3,6 +3,7 @@
#include "ECSS_Definitions.hpp"
#include "ErrorHandler.hpp"
+#include "Helpers/AllMessageTypes.hpp"
#include "Helpers/ForwardControlConfiguration.hpp"
#include "Service.hpp"
#include "etl/vector.h"
@@ -10,8 +11,7 @@
/**
* Implementation of the ST[14] 'Real Time Forwarding Control Service' as defined in ECSS-E-ST-70-41C.
*
- * @brief
- * The purpose of this Service is to control the forwarding of the stores' telemetry to the ground station. It includes
+ * The purpose of this Service is to control the forwarding of the telemetry to the ground station. It includes
* conditions for all the application processes that are controlled by the Service, which determine whether a message
* should be forwarded to the ground station, through the corresponding virtual channel.
*
@@ -22,6 +22,7 @@ public:
inline static const uint8_t ServiceType = 14;
enum MessageType : uint8_t {
+ AddReportTypesToAppProcessConfiguration = 1,
DeleteReportTypesFromAppProcessConfiguration = 2,
EventReportConfigurationContentReport = 16,
};
@@ -40,6 +41,77 @@ public:
ApplicationProcessConfiguration applicationProcessConfiguration;
private:
+ /**
+ * Adds all report types of the specified application process definition, to the application process configuration.
+ */
+ void addAllReportsOfApplication(uint8_t applicationID);
+
+ /**
+ * Adds all report types of the specified service type, to the application process configuration.
+ */
+ void addAllReportsOfService(uint8_t applicationID, uint8_t serviceType);
+
+ /**
+ * 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.
+ */
+ bool reportExistsInAppProcessConfiguration(uint8_t applicationID, uint8_t serviceType, uint8_t messageType);
+
+ /**
+ * Performs the necessary error checking/logging for a specific application process ID. Also, skips the necessary
+ * bytes from the request message, in case of an invalid request.
+ *
+ * @return True: if the application is valid and passes all the necessary error checking.
+ */
+ bool checkApplicationOfAppProcessConfig(Message& request, uint8_t applicationID, uint8_t numOfServices);
+
+ /**
+ * Checks if the specified application process is controlled by the Service and returns true if it does.
+ */
+ bool checkAppControlled(Message& request, uint8_t applicationId);
+
+ /**
+ * Checks if all service types are allowed already, i.e. if the application process contains no service type
+ * definitions.
+ */
+ bool allServiceTypesAllowed(Message& request, uint8_t applicationID);
+
+ /**
+ * Checks if the maximum number of service type definitions per application process is reached.
+ */
+ bool maxServiceTypesReached(Message& request, uint8_t applicationID);
+
+ /**
+ * Performs the necessary error checking/logging for a specific service type. Also, skips the necessary bytes
+ * from the request message, in case of an invalid request.
+ *
+ * @return True: if the service type is valid and passes all the necessary error checking.
+ */
+ bool checkService(Message& request, uint8_t applicationID, uint8_t numOfMessages);
+
+ /**
+ * Checks if the maximum number of report type definitions per service type definition is reached.
+ */
+ bool maxReportTypesReached(Message& request, uint8_t applicationID, uint8_t serviceType);
+
+ /**
+ * Checks if the maximum number of message types that can be contained inside a service type definition, is
+ * already reached.
+ *
+ * @return True: if the message type is valid and passes all the necessary error checking.
+ */
+ bool checkMessage(Message& request, uint8_t applicationID, uint8_t serviceType, uint8_t messageType);
+
/**
* Returns true, if the defined application exists in the application process configuration map.
*/
@@ -90,6 +162,11 @@ private:
void deleteReportRecursive(uint8_t applicationID, uint8_t serviceType, uint8_t messageType);
public:
+ /**
+ * TC[14,1] 'Add report types to the application process forward control configuration'.
+ */
+ void addReportTypesToAppProcessConfiguration(Message& request);
+
/**
* TC[14,2] 'Delete report types from the application process forward control configuration'.
*/
@@ -100,7 +177,7 @@ public:
* is the ground station.
*
* @note This function is called from the main execute() that is defined in the file MessageParser.hpp
- * @param message Contains the necessary parameters to call the suitable subservice
+ * @param message Contains the necessary parameters to call the suitable subservice.
*/
void execute(Message& message);
};
diff --git a/src/Helpers/AllMessageTypes.cpp b/src/Helpers/AllMessageTypes.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c67e09b31d3ebf98fd7a477d051b23beb7949a62
--- /dev/null
+++ b/src/Helpers/AllMessageTypes.cpp
@@ -0,0 +1,72 @@
+#include "Helpers/AllMessageTypes.hpp"
+#include "Services/EventActionService.hpp"
+#include "Services/EventReportService.hpp"
+#include "Services/HousekeepingService.hpp"
+#include "Services/LargePacketTransferService.hpp"
+#include "Services/MemoryManagementService.hpp"
+#include "Services/ParameterService.hpp"
+#include "Services/ParameterStatisticsService.hpp"
+#include "Services/RealTimeForwardingControlService.hpp"
+#include "Services/RequestVerificationService.hpp"
+#include "Services/TestService.hpp"
+#include "Services/TimeBasedSchedulingService.hpp"
+
+namespace AllMessageTypes {
+ etl::vector<uint8_t, ECSSMaxReportTypeDefinitions> 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, ECSSMaxReportTypeDefinitions> st03Messages = {
+ HousekeepingService::MessageType::DisablePeriodicHousekeepingParametersReport,
+ HousekeepingService::MessageType::EnablePeriodicHousekeepingParametersReport,
+ HousekeepingService::MessageType::GenerateOneShotHousekeepingReport,
+ HousekeepingService::MessageType::HousekeepingParametersReport,
+ HousekeepingService::MessageType::HousekeepingPeriodicPropertiesReport,
+ HousekeepingService::MessageType::HousekeepingStructuresReport};
+
+ etl::vector<uint8_t, ECSSMaxReportTypeDefinitions> st04Messages = {
+ ParameterStatisticsService::MessageType::ParameterStatisticsDefinitionsReport,
+ ParameterStatisticsService::MessageType::ParameterStatisticsReport,
+ };
+
+ etl::vector<uint8_t, ECSSMaxReportTypeDefinitions> st05Messages = {EventReportService::MessageType::HighSeverityAnomalyReport,
+ EventReportService::MessageType::DisabledListEventReport,
+ EventReportService::MessageType::InformativeEventReport,
+ EventReportService::MessageType::LowSeverityAnomalyReport,
+ EventReportService::MessageType::MediumSeverityAnomalyReport};
+
+ etl::vector<uint8_t, ECSSMaxReportTypeDefinitions> st06Messages = {MemoryManagementService::MessageType::CheckRawMemoryDataReport,
+ MemoryManagementService::MessageType::DumpRawMemoryDataReport};
+
+ etl::vector<uint8_t, ECSSMaxReportTypeDefinitions> st11Messages = {TimeBasedSchedulingService::MessageType::TimeBasedScheduledSummaryReport};
+
+ etl::vector<uint8_t, ECSSMaxReportTypeDefinitions> st13Messages = {LargePacketTransferService::MessageType::FirstDownlinkPartReport,
+ LargePacketTransferService::MessageType::InternalDownlinkPartReport,
+ LargePacketTransferService::MessageType::LastDownlinkPartReport};
+
+ etl::vector<uint8_t, ECSSMaxReportTypeDefinitions> st17Messages = {TestService::MessageType::AreYouAliveTestReport,
+ TestService::MessageType::OnBoardConnectionTestReport};
+
+ etl::vector<uint8_t, ECSSMaxReportTypeDefinitions> st19Messages = {EventActionService::MessageType::EventActionStatusReport};
+
+ etl::vector<uint8_t, ECSSMaxReportTypeDefinitions> st20Messages = {ParameterService::MessageType::ParameterValuesReport};
+
+ etl::map<uint8_t, etl::vector<uint8_t, ECSSMaxReportTypeDefinitions>, ECSSMaxServiceTypeDefinitions> 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}};
+
+} // namespace AllMessageTypes
diff --git a/src/Services/RealTimeForwardingControlService.cpp b/src/Services/RealTimeForwardingControlService.cpp
index 1cdc38465a6f6eaf20a1060a70767445a596b605..2ca94a03289880696d9663881d71ae22a43fa067 100644
--- a/src/Services/RealTimeForwardingControlService.cpp
+++ b/src/Services/RealTimeForwardingControlService.cpp
@@ -1,6 +1,151 @@
#include "Services/RealTimeForwardingControlService.hpp"
#include <iostream>
+void RealTimeForwardingControlService::addAllReportsOfApplication(uint8_t applicationID) {
+ for (auto& service: AllMessageTypes::messagesOfService) {
+ uint8_t serviceType = service.first;
+ addAllReportsOfService(applicationID, serviceType);
+ }
+}
+
+void RealTimeForwardingControlService::addAllReportsOfService(uint8_t applicationID, uint8_t serviceType) {
+ for (auto& messageType: AllMessageTypes::messagesOfService[serviceType]) {
+ auto appServicePair = std::make_pair(applicationID, serviceType);
+ applicationProcessConfiguration.definitions[appServicePair].push_back(messageType);
+ }
+}
+
+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) {
+ auto appServicePair = std::make_pair(applicationID, serviceType);
+ return applicationProcessConfiguration.definitions[appServicePair].size();
+}
+
+bool RealTimeForwardingControlService::checkAppControlled(Message& request, uint8_t applicationId) {
+ if (std::find(controlledApplications.begin(), controlledApplications.end(), applicationId) ==
+ controlledApplications.end()) {
+ ErrorHandler::reportError(request, ErrorHandler::ExecutionStartErrorType::NotControlledApplication);
+ return false;
+ }
+ return true;
+}
+
+bool RealTimeForwardingControlService::checkApplicationOfAppProcessConfig(Message& request, uint8_t applicationID,
+ uint8_t numOfServices) {
+ if (not checkAppControlled(request, applicationID) or allServiceTypesAllowed(request, applicationID)) {
+ for (uint8_t i = 0; i < numOfServices; i++) {
+ request.skipBytes(1);
+ uint8_t numOfMessages = request.readUint8();
+ request.skipBytes(numOfMessages);
+ }
+ return false;
+ }
+ return true;
+}
+
+bool RealTimeForwardingControlService::allServiceTypesAllowed(Message& request, uint8_t applicationID) {
+ if (countServicesOfApplication(applicationID) >= ECSSMaxServiceTypeDefinitions) {
+ ErrorHandler::reportError(request, ErrorHandler::ExecutionStartErrorType::AllServiceTypesAlreadyAllowed);
+ return true;
+ }
+ return false;
+}
+
+bool RealTimeForwardingControlService::maxServiceTypesReached(Message& request, uint8_t applicationID) {
+ if (countServicesOfApplication(applicationID) >= ECSSMaxServiceTypeDefinitions) {
+ ErrorHandler::reportError(request, ErrorHandler::ExecutionStartErrorType::MaxServiceTypesReached);
+ return true;
+ }
+ return false;
+}
+
+bool RealTimeForwardingControlService::checkService(Message& request, uint8_t applicationID, uint8_t numOfMessages) {
+ if (maxServiceTypesReached(request, applicationID)) {
+ request.skipBytes(numOfMessages);
+ return false;
+ }
+ return true;
+}
+
+bool RealTimeForwardingControlService::maxReportTypesReached(Message& request, uint8_t applicationID,
+ uint8_t serviceType) {
+ if (countReportsOfService(applicationID, serviceType) >= AllMessageTypes::messagesOfService[serviceType].size()) {
+ ErrorHandler::reportError(request, ErrorHandler::ExecutionStartErrorType::MaxReportTypesReached);
+ return true;
+ }
+ return false;
+}
+
+bool RealTimeForwardingControlService::checkMessage(Message& request, uint8_t applicationID, uint8_t serviceType,
+ uint8_t messageType) {
+ if (maxReportTypesReached(request, applicationID, serviceType) or
+ reportExistsInAppProcessConfiguration(applicationID, serviceType, messageType)) {
+ return false;
+ }
+ return true;
+}
+
+bool RealTimeForwardingControlService::reportExistsInAppProcessConfiguration(uint8_t applicationID, uint8_t serviceType,
+ uint8_t messageType) {
+ auto key = std::make_pair(applicationID, serviceType);
+ auto& messages = applicationProcessConfiguration.definitions[key];
+ return std::find(messages.begin(), messages.end(), messageType) != messages.end();
+}
+
+void RealTimeForwardingControlService::addReportTypesToAppProcessConfiguration(Message& request) {
+ request.assertTC(ServiceType, MessageType::AddReportTypesToAppProcessConfiguration);
+ uint8_t numOfApplications = request.readUint8();
+
+ for (uint8_t i = 0; i < numOfApplications; i++) {
+ uint8_t applicationID = request.readUint8();
+ uint8_t numOfServices = request.readUint8();
+
+ if (not checkApplicationOfAppProcessConfig(request, applicationID, numOfServices)) {
+ continue;
+ }
+
+ if (numOfServices == 0) {
+ addAllReportsOfApplication(applicationID);
+ continue;
+ }
+
+ for (uint8_t j = 0; j < numOfServices; j++) {
+ uint8_t serviceType = request.readUint8();
+ uint8_t numOfMessages = request.readUint8();
+
+ if (not checkService(request, applicationID, numOfMessages)) {
+ continue;
+ }
+
+ if (numOfMessages == 0) {
+ addAllReportsOfService(applicationID, serviceType);
+ continue;
+ }
+
+ for (uint8_t k = 0; k < numOfMessages; k++) {
+ uint8_t messageType = request.readUint8();
+
+ if (not checkMessage(request, applicationID, serviceType, messageType)) {
+ continue;
+ }
+ auto key = std::make_pair(applicationID, serviceType);
+ applicationProcessConfiguration.definitions[key].push_back(
+ messageType);
+ }
+ }
+ }
+}
+
bool RealTimeForwardingControlService::findApplication(uint8_t targetAppID) {
auto& definitions = applicationProcessConfiguration.definitions;
return std::any_of(std::begin(definitions), std::end(definitions), [targetAppID](auto& definition) { return targetAppID == definition.first.first; });
@@ -126,11 +271,14 @@ void RealTimeForwardingControlService::deleteReportTypesFromAppProcessConfigurat
void RealTimeForwardingControlService::execute(Message& message) {
switch (message.messageType) {
+ case AddReportTypesToAppProcessConfiguration:
+ addReportTypesToAppProcessConfiguration(message);
+ break;
case DeleteReportTypesFromAppProcessConfiguration:
deleteReportTypesFromAppProcessConfiguration(message);
break;
+
default:
ErrorHandler::reportInternalError(ErrorHandler::OtherMessageType);
- break;
}
}
diff --git a/test/Services/RealTimeForwardingControl.cpp b/test/Services/RealTimeForwardingControl.cpp
index bb9cc5eb4c029a490d70fa94d6a6b258e82cae89..dd1a3351766df0e610fb046a60d9eded54635edc 100644
--- a/test/Services/RealTimeForwardingControl.cpp
+++ b/test/Services/RealTimeForwardingControl.cpp
@@ -9,14 +9,559 @@ 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};
uint8_t messages2[] = {EventReportService::MessageType::InformativeEventReport,
EventReportService::MessageType::DisabledListEventReport};
+void validReportTypes(Message& request) {
+ uint8_t numOfApplications = 1;
+ uint8_t numOfServicesPerApp = 2;
+ uint8_t numOfMessagesPerService = 2;
+
+ request.appendUint8(numOfApplications);
+
+ for (auto appID: applications) {
+ request.appendUint8(appID);
+ request.appendUint8(numOfServicesPerApp);
+
+ for (uint8_t j = 0; j < numOfServicesPerApp; j++) {
+ uint8_t serviceType = services[j];
+ request.appendUint8(serviceType);
+ request.appendUint8(numOfMessagesPerService);
+ uint8_t* messages = (j == 0) ? messages1 : messages2;
+
+ for (uint8_t k = 0; k < numOfMessagesPerService; k++) {
+ request.appendUint8(messages[k]);
+ }
+ }
+ }
+}
+
+void duplicateReportTypes(Message& request) {
+ uint8_t numOfApplications = 1;
+ uint8_t numOfServicesPerApp = 2;
+ uint8_t numOfMessagesPerService = 2;
+
+ request.appendUint8(numOfApplications);
+
+ for (auto appID: applications) {
+ request.appendUint8(appID);
+ request.appendUint8(numOfServicesPerApp);
+
+ for (uint8_t j = 0; j < numOfServicesPerApp; j++) {
+ uint8_t serviceType = services[j];
+ request.appendUint8(serviceType);
+ request.appendUint8(numOfMessagesPerService);
+
+ for (uint8_t k = 0; k < numOfMessagesPerService; k++) {
+ request.appendUint8(messages1[0]);
+ }
+ }
+ }
+}
+
+void validInvalidReportTypes(Message& request) {
+ uint8_t numOfApplications = 3;
+ uint8_t numOfMessagesPerService = 2;
+
+ uint8_t applications2[] = {1, 2, 3};
+ request.appendUint8(numOfApplications);
+
+ for (uint8_t i = 0; i < numOfApplications; i++) {
+ request.appendUint8(applications2[i]);
+ uint8_t numOfServicesPerApp = (i == 0) ? 12 : 2;
+ uint8_t* servicesToPick = (i == 0) ? redundantServices : services;
+ request.appendUint8(numOfServicesPerApp);
+
+ for (uint8_t j = 0; j < numOfServicesPerApp; j++) {
+ uint8_t serviceType = servicesToPick[j];
+ request.appendUint8(serviceType);
+ request.appendUint8(numOfMessagesPerService);
+ uint8_t* messages = (j == 0) ? messages1 : messages2;
+
+ for (uint8_t k = 0; k < numOfMessagesPerService; k++) {
+ request.appendUint8(messages[k]);
+ }
+ }
+ }
+}
+
+void validAllReportsOfService(Message& request) {
+ uint8_t numOfApplications = 1;
+ uint8_t numOfServicesPerApp = 2;
+ uint8_t numOfMessagesPerService = 0;
+
+ request.appendUint8(numOfApplications);
+
+ for (auto appID: applications) {
+ request.appendUint8(appID);
+ request.appendUint8(numOfServicesPerApp);
+
+ for (uint8_t j = 0; j < numOfServicesPerApp; j++) {
+ uint8_t serviceType = services[j];
+ request.appendUint8(serviceType);
+ request.appendUint8(numOfMessagesPerService);
+ }
+ }
+}
+
+void validInvalidAllReportsOfService(Message& request) {
+ uint8_t numOfApplications = 3;
+ uint8_t numOfMessagesPerService = 2;
+
+ uint8_t applications2[] = {1, 2, 3};
+ request.appendUint8(numOfApplications);
+
+ for (uint8_t i = 0; i < numOfApplications; i++) {
+ request.appendUint8(applications2[i]);
+ uint8_t numOfServicesPerApp = (i == 0) ? 12 : 2;
+ uint8_t* servicesToPick = (i == 0) ? redundantServices : services;
+ request.appendUint8(numOfServicesPerApp);
+
+ for (uint8_t j = 0; j < numOfServicesPerApp; j++) {
+ uint8_t serviceType = servicesToPick[j];
+ request.appendUint8(serviceType);
+ uint8_t numOfMessages = (i < 2) ? 0 : numOfMessagesPerService;
+ request.appendUint8(numOfMessages);
+ if (i >= 2) {
+ uint8_t* messages = (j == 0) ? messages1 : messages2;
+
+ for (uint8_t k = 0; k < numOfMessagesPerService; k++) {
+ request.appendUint8(messages[k]);
+ }
+ }
+ }
+ }
+}
+
+void validAllReportsOfApp(Message& request) {
+ uint8_t numOfApplications = 1;
+ uint8_t numOfServicesPerApp = 0;
+
+ request.appendUint8(numOfApplications);
+
+ for (auto appID: applications) {
+ request.appendUint8(appID);
+ request.appendUint8(numOfServicesPerApp);
+ }
+}
+
+void validInvalidAllReportsOfApp(Message& request) {
+ uint8_t numOfApplications = 3;
+ uint8_t numOfMessagesPerService = 2;
+
+ uint8_t applications2[] = {1, 2, 3};
+ request.appendUint8(numOfApplications);
+
+ for (uint8_t i = 0; i < numOfApplications; i++) {
+ request.appendUint8(applications2[i]);
+ uint8_t numOfServicesPerApp = (i == 0 or i == 1) ? 0 : 2;
+ uint8_t* servicesToPick = (i == 0) ? redundantServices : services;
+ request.appendUint8(numOfServicesPerApp);
+
+ if (i >= 2) {
+ for (uint8_t j = 0; j < numOfServicesPerApp; j++) {
+ uint8_t serviceType = servicesToPick[j];
+ request.appendUint8(serviceType);
+ uint8_t numOfMessages = (i == 0 or i == 1) ? 0 : numOfMessagesPerService;
+ request.appendUint8(numOfMessages);
+
+ uint8_t* messages = (j == 0) ? messages1 : messages2;
+
+ for (uint8_t k = 0; k < numOfMessagesPerService; k++) {
+ request.appendUint8(messages[k]);
+ }
+ }
+ }
+ }
+}
+
+void resetAppProcessConfiguration() {
+ realTimeForwarding.applicationProcessConfiguration.definitions.clear();
+ REQUIRE(realTimeForwarding.applicationProcessConfiguration.definitions.empty());
+}
+
+TEST_CASE("Add report types to the Application Process Configuration") {
+ SECTION("Successful addition of report types to the Application Process Configuration") {
+ Message request(RealTimeForwardingControlService::ServiceType,
+ RealTimeForwardingControlService::MessageType::AddReportTypesToAppProcessConfiguration,
+ Message::TC, 1);
+
+ uint8_t applicationID = 1;
+ realTimeForwarding.controlledApplications.push_back(applicationID);
+ validReportTypes(request);
+
+ MessageParser::execute(request);
+
+ CHECK(ServiceTests::count() == 0);
+ auto& applicationProcesses = realTimeForwarding.applicationProcessConfiguration.definitions;
+ REQUIRE(applicationProcesses.size() == 2);
+
+ for (auto appID: applications) {
+ for (uint8_t j = 0; j < 2; j++) {
+ uint8_t serviceType = services[j];
+ 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[appServicePair].begin(),
+ applicationProcesses[appServicePair].end(),
+ messages[k]) != applicationProcesses[appServicePair].end());
+ }
+ }
+ }
+
+ resetAppProcessConfiguration();
+ ServiceTests::reset();
+ Services.reset();
+ }
+
+ SECTION("Requested Application Process is not controlled by the service") {
+ Message request(RealTimeForwardingControlService::ServiceType,
+ RealTimeForwardingControlService::MessageType::AddReportTypesToAppProcessConfiguration,
+ Message::TC, 1);
+
+ uint8_t applicationID = 1;
+ validReportTypes(request);
+
+ MessageParser::execute(request);
+
+ CHECK(ServiceTests::count() == 1);
+ CHECK(ServiceTests::countThrownErrors(ErrorHandler::ExecutionStartErrorType::NotControlledApplication) == 1);
+ REQUIRE(realTimeForwarding.applicationProcessConfiguration.definitions.empty());
+
+ resetAppProcessConfiguration();
+ ServiceTests::reset();
+ Services.reset();
+ }
+
+ SECTION("All service types already allowed") {
+ Message request(RealTimeForwardingControlService::ServiceType,
+ RealTimeForwardingControlService::MessageType::AddReportTypesToAppProcessConfiguration,
+ Message::TC, 1);
+
+ uint8_t applicationID = 1;
+ realTimeForwarding.controlledApplications.push_back(applicationID);
+ validReportTypes(request);
+
+ 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.size() == ECSSMaxServiceTypeDefinitions);
+
+ resetAppProcessConfiguration();
+ ServiceTests::reset();
+ Services.reset();
+ }
+
+ SECTION("Max service types already reached") {
+ Message request(RealTimeForwardingControlService::ServiceType,
+ RealTimeForwardingControlService::MessageType::AddReportTypesToAppProcessConfiguration,
+ 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.definitions;
+
+ for (uint8_t i = 100; i < ECSSMaxServiceTypeDefinitions + 99; i++) {
+ applicationProcessConfig[std::make_pair(applicationID, i)];
+ }
+ CHECK(applicationProcessConfig.size() == ECSSMaxServiceTypeDefinitions - 1);
+
+ MessageParser::execute(request);
+
+ CHECK(ServiceTests::count() == 1);
+ CHECK(ServiceTests::countThrownErrors(ErrorHandler::ExecutionStartErrorType::MaxServiceTypesReached) == 1);
+ REQUIRE(applicationProcessConfig.size() == ECSSMaxServiceTypeDefinitions);
+
+ resetAppProcessConfiguration();
+ ServiceTests::reset();
+ Services.reset();
+ }
+
+ SECTION("All report types already allowed") {
+ Message request(RealTimeForwardingControlService::ServiceType,
+ RealTimeForwardingControlService::MessageType::AddReportTypesToAppProcessConfiguration,
+ Message::TC, 1);
+
+ uint8_t applicationID = 1;
+ uint8_t serviceType = services[0]; // st03
+ realTimeForwarding.controlledApplications.push_back(applicationID);
+ validReportTypes(request);
+
+ for (auto message: AllMessageTypes::messagesOfService[serviceType]) {
+ realTimeForwarding.applicationProcessConfiguration.definitions[std::make_pair(applicationID, serviceType)]
+ .push_back(message);
+ }
+
+ MessageParser::execute(request);
+
+ CHECK(ServiceTests::count() == 2);
+ CHECK(ServiceTests::countThrownErrors(ErrorHandler::ExecutionStartErrorType::MaxReportTypesReached) ==
+ 2);
+ REQUIRE(
+ realTimeForwarding.applicationProcessConfiguration.definitions[std::make_pair(applicationID, serviceType)]
+ .size() == AllMessageTypes::messagesOfService[serviceType].size());
+
+ resetAppProcessConfiguration();
+ ServiceTests::reset();
+ Services.reset();
+ }
+
+ SECTION("Max report types already reached") {
+ Message request(RealTimeForwardingControlService::ServiceType,
+ RealTimeForwardingControlService::MessageType::AddReportTypesToAppProcessConfiguration,
+ 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 appServicePair1 = std::make_pair(applicationID, serviceType1);
+ auto appServicePair2 = std::make_pair(applicationID, serviceType2);
+ REQUIRE(applicationProcessConfig.definitions[appServicePair1].empty());
+ REQUIRE(applicationProcessConfig.definitions[appServicePair2].empty());
+
+ auto numOfMessages1 = AllMessageTypes::messagesOfService[serviceType1].size();
+ auto numOfMessages2 = 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.size() == 2);
+ REQUIRE(applicationProcessConfig.definitions[appServicePair1].size() == numOfMessages1);
+ REQUIRE(applicationProcessConfig.definitions[appServicePair2].size() == numOfMessages2);
+
+ resetAppProcessConfiguration();
+ ServiceTests::reset();
+ Services.reset();
+ }
+
+ SECTION("Requested addition of duplicate report type definitions") {
+ Message request(RealTimeForwardingControlService::ServiceType,
+ RealTimeForwardingControlService::MessageType::AddReportTypesToAppProcessConfiguration,
+ Message::TC, 1);
+
+ uint8_t applicationID = 1;
+ realTimeForwarding.controlledApplications.push_back(applicationID);
+ duplicateReportTypes(request);
+
+ MessageParser::execute(request);
+
+ CHECK(ServiceTests::count() == 0);
+ auto& applicationProcesses = realTimeForwarding.applicationProcessConfiguration.definitions;
+ REQUIRE(applicationProcesses.size() == 2);
+
+ for (auto appID: applications) {
+ for (auto& serviceType: services) {
+ 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());
+ }
+ }
+
+ resetAppProcessConfiguration();
+ ServiceTests::reset();
+ Services.reset();
+ }
+
+ SECTION("Valid and invalid application-related requests combined") {
+ Message request(RealTimeForwardingControlService::ServiceType,
+ RealTimeForwardingControlService::MessageType::AddReportTypesToAppProcessConfiguration,
+ Message::TC, 1);
+ uint8_t applicationID1 = 1;
+ uint8_t applicationID2 = 2;
+ uint8_t applicationID3 = 3;
+ realTimeForwarding.controlledApplications.push_back(applicationID1);
+ realTimeForwarding.controlledApplications.push_back(applicationID3);
+ validInvalidReportTypes(request);
+
+ for (uint8_t i = 100; i < ECSSMaxServiceTypeDefinitions + 99; i++) {
+ realTimeForwarding.applicationProcessConfiguration.definitions[std::make_pair(applicationID3, i)];
+ }
+ CHECK(realTimeForwarding.applicationProcessConfiguration.definitions.size() ==
+ ECSSMaxServiceTypeDefinitions - 1);
+
+ MessageParser::execute(request);
+
+ CHECK(ServiceTests::count() == 7);
+ CHECK(ServiceTests::countThrownErrors(ErrorHandler::ExecutionStartErrorType::NotControlledApplication) == 1);
+ CHECK(ServiceTests::countThrownErrors(ErrorHandler::ExecutionStartErrorType::MaxServiceTypesReached) == 3);
+ CHECK(ServiceTests::countThrownErrors(ErrorHandler::ExecutionStartErrorType::MaxReportTypesReached) == 3);
+
+ auto& definitions = realTimeForwarding.applicationProcessConfiguration.definitions;
+ REQUIRE(definitions.size() == 20);
+ for (auto serviceType: allServices) {
+ REQUIRE(definitions.find(std::make_pair(applicationID1, serviceType)) != definitions.end());
+ }
+
+ 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;
+ for (auto serviceType: services) {
+ REQUIRE(applicationProcesses[std::make_pair(applicationID1, serviceType)].size() ==
+ AllMessageTypes::messagesOfService[serviceType].size());
+ }
+
+ 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& definitions = realTimeForwarding.applicationProcessConfiguration.definitions;
+ REQUIRE(definitions.size() == 12);
+
+ int cnt1 = 0;
+ int cnt2 = 0;
+ for (auto& pair: definitions) {
+ if (pair.first.first == applicationID1) {
+ cnt1++;
+ } else if (pair.first.first == applicationID2) {
+ cnt2++;
+ }
+ }
+ REQUIRE(cnt1 == 10);
+ REQUIRE(cnt2 == 2);
+
+ for (auto& serviceType: allServices) {
+ REQUIRE(definitions[std::make_pair(applicationID1, serviceType)].size() ==
+ AllMessageTypes::messagesOfService[serviceType].size());
+ }
+ for (auto& serviceType: services) {
+ REQUIRE(definitions[std::make_pair(applicationID2, serviceType)].size() ==
+ AllMessageTypes::messagesOfService[serviceType].size());
+ }
+
+ 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& definitions = realTimeForwarding.applicationProcessConfiguration.definitions;
+ REQUIRE(definitions.size() == ECSSMaxServiceTypeDefinitions);
+
+ for (auto serviceType: allServices) {
+ REQUIRE(std::equal(definitions[std::make_pair(applicationID1, serviceType)].begin(),
+ definitions[std::make_pair(applicationID1, serviceType)].end(),
+ AllMessageTypes::messagesOfService[serviceType].begin()));
+ }
+
+ 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& definitions = realTimeForwarding.applicationProcessConfiguration.definitions;
+
+ REQUIRE(definitions.size() == 2 * ECSSMaxServiceTypeDefinitions);
+
+ resetAppProcessConfiguration();
+ ServiceTests::reset();
+ Services.reset();
+ }
+}
+
+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 messages1_[] = {HousekeepingService::MessageType::HousekeepingPeriodicPropertiesReport,
+ HousekeepingService::MessageType::DisablePeriodicHousekeepingParametersReport};
+
+uint8_t messages2_[] = {EventReportService::MessageType::InformativeEventReport,
+ EventReportService::MessageType::DisabledListEventReport};
+
bool findApplication(uint8_t targetAppID) {
auto& definitions = realTimeForwarding.applicationProcessConfiguration.definitions;
return std::any_of(std::begin(definitions), std::end(definitions), [targetAppID](auto definition) { return targetAppID == definition.first.first; });
@@ -31,7 +576,7 @@ void checkAppProcessConfig() {
auto& applicationProcesses = realTimeForwarding.applicationProcessConfiguration.definitions;
// Check if configuration is initialized properly
- for (auto appID: applications) {
+ for (auto appID: applications_) {
REQUIRE(findApplication(appID));
for (auto serviceType: services) {
@@ -39,7 +584,7 @@ void checkAppProcessConfig() {
REQUIRE(findServiceType(appID, serviceType));
REQUIRE(applicationProcesses[appServicePair].size() == 2);
- for (auto messageType: messages1) {
+ for (auto messageType: messages1_) {
REQUIRE(std::find(applicationProcesses[appServicePair].begin(),
applicationProcesses[appServicePair].end(),
messageType) != applicationProcesses[appServicePair].end());
@@ -53,10 +598,10 @@ void initializeAppProcessConfig() {
// uint8_t numOfServicesPerApp = 2;
// uint8_t numOfMessagesPerService = 2;
- for (auto appID: applications) {
+ for (auto appID: applications_) {
for (auto serviceType: services) {
auto appServicePair = std::make_pair(appID, serviceType);
- for (auto messageType: messages1) {
+ for (auto messageType: messages1_) {
realTimeForwarding.applicationProcessConfiguration.definitions[appServicePair].push_back(
messageType);
}
@@ -78,11 +623,11 @@ void checkAppProcessConfig2() {
REQUIRE(findApplication(appID));
uint8_t numOfServices = (i == 2) ? 15 : 2;
- uint8_t* serviceTypes = (i == 2) ? allServices : services;
+ uint8_t* serviceTypes = (i == 2) ? allServices_ : services_;
for (uint8_t j = 0; j < numOfServices; j++) {
uint8_t serviceType = serviceTypes[j];
- uint8_t* messages = (i == 2) ? messages2 : messages1;
+ uint8_t* messages = (i == 2) ? messages2_ : messages1_;
REQUIRE(findServiceType(appID, serviceType));
auto appServicePair = std::make_pair(appID, serviceType);
@@ -107,11 +652,11 @@ void initializeAppProcessConfig2() {
for (uint8_t i = 0; i < numOfApplications; i++) {
uint8_t appID = applications2[i];
uint8_t numOfServices = (i == 2) ? 15 : 2;
- uint8_t* serviceTypes = (i == 2) ? allServices : services;
+ uint8_t* serviceTypes = (i == 2) ? allServices_ : services_;
for (uint8_t j = 0; j < numOfServices; j++) {
uint8_t serviceType = serviceTypes[j];
- uint8_t* messages = (i == 2) ? messages2 : messages1;
+ uint8_t* messages = (i == 2) ? messages2_ : messages1_;
for (uint8_t k = 0; k < numOfMessagesPerService; k++) {
uint8_t messageType = messages[k];
@@ -130,7 +675,7 @@ void serviceNotInApplication(Message& request) {
request.appendUint8(numOfApplications);
- for (auto appID: applications) {
+ for (auto appID: applications_) {
request.appendUint8(appID);
request.appendUint8(numOfServicesPerApp);
@@ -138,7 +683,7 @@ void serviceNotInApplication(Message& request) {
uint8_t nonExistingService = 13; // add arbitrary, non-existing service type
request.appendUint8(nonExistingService);
request.appendUint8(numOfMessagesPerService);
- uint8_t* messages = (j == 0) ? messages1 : messages2;
+ uint8_t* messages = (j == 0) ? messages1_ : messages2_;
for (uint8_t k = 0; k < numOfMessagesPerService; k++) {
request.appendUint8(messages[k]);
@@ -154,7 +699,7 @@ void messageNotInApplication(Message& request) {
request.appendUint8(numOfApplications);
- for (auto appID: applications) {
+ for (auto appID: applications_) {
request.appendUint8(appID);
request.appendUint8(numOfServicesPerApp);
@@ -179,7 +724,7 @@ void deleteValidReportTypes(Message& request) {
request.appendUint8(numOfApplications);
- for (auto appID: applications) {
+ for (auto appID: applications_) {
request.appendUint8(appID);
request.appendUint8(numOfServicesPerApp);
@@ -189,7 +734,7 @@ void deleteValidReportTypes(Message& request) {
request.appendUint8(numOfMessagesPerService);
for (uint8_t k = 0; k < numOfMessagesPerService; k++) {
- request.appendUint8(messages1[k]);
+ request.appendUint8(messages1_[k]);
}
}
}
@@ -202,7 +747,7 @@ void deleteReportEmptyService(Message& request) {
request.appendUint8(numOfApplications);
- for (auto appID: applications) {
+ for (auto appID: applications_) {
request.appendUint8(appID);
request.appendUint8(numOfServicesPerApp);
@@ -212,7 +757,7 @@ void deleteReportEmptyService(Message& request) {
request.appendUint8(numOfMessagesPerService);
for (uint8_t k = 0; k < numOfMessagesPerService; k++) {
- request.appendUint8(messages1[k]);
+ request.appendUint8(messages1_[k]);
}
}
}
@@ -225,17 +770,17 @@ void deleteReportEmptyApplication(Message& request) {
request.appendUint8(numOfApplications);
- for (auto appID: applications) {
+ for (auto appID: applications_) {
request.appendUint8(appID);
request.appendUint8(numOfServicesPerApp);
for (uint8_t j = 0; j < numOfServicesPerApp; j++) {
- uint8_t serviceType = services[j];
+ uint8_t serviceType = services_[j];
request.appendUint8(serviceType);
request.appendUint8(numOfMessagesPerService);
for (uint8_t k = 0; k < numOfMessagesPerService; k++) {
- request.appendUint8(messages1[k]);
+ request.appendUint8(messages1_[k]);
}
}
}
@@ -246,7 +791,7 @@ void deleteApplicationProcess(Message& request) {
uint8_t numOfServicesPerApp = 0;
request.appendUint8(numOfApplications);
- request.appendUint8(applications[0]);
+ request.appendUint8(applications_[0]);
request.appendUint8(numOfServicesPerApp);
}
@@ -256,7 +801,7 @@ void deleteService(Message& request) {
uint8_t numOfMessagesPerService = 0;
request.appendUint8(numOfApplications);
- for (auto appID: applications) {
+ for (auto appID: applications_) {
request.appendUint8(appID);
request.appendUint8(numOfServicesPerApp);
@@ -274,7 +819,7 @@ void deleteServiceEmptyApplication(Message& request) {
uint8_t numOfMessagesPerService = 0;
request.appendUint8(numOfApplications);
- for (auto appID: applications) {
+ for (auto appID: applications_) {
request.appendUint8(appID);
request.appendUint8(numOfServicesPerApp);
@@ -304,7 +849,7 @@ void deleteValidInvalidReportTypes(Message& request) {
for (uint8_t j = 0; j < numOfServices; j++) {
uint8_t serviceType = validInvalidServices[i][j];
- uint8_t* messages = (i == 2) ? validInvalidMessages : messages1;
+ uint8_t* messages = (i == 2) ? validInvalidMessages : messages1_;
request.appendUint8(serviceType);
request.appendUint8(numOfMessages);
@@ -317,11 +862,6 @@ void deleteValidInvalidReportTypes(Message& request) {
}
}
-void resetAppProcessConfiguration() {
- realTimeForwarding.applicationProcessConfiguration.definitions.clear();
- REQUIRE(realTimeForwarding.applicationProcessConfiguration.definitions.empty());
-}
-
TEST_CASE("Delete report types from the Application Process Configuration") {
SECTION("Empty the application process configuration") {
Message request(RealTimeForwardingControlService::ServiceType,
@@ -414,8 +954,8 @@ TEST_CASE("Delete report types from the Application Process Configuration") {
auto& applicationProcesses = realTimeForwarding.applicationProcessConfiguration.definitions;
REQUIRE(applicationProcesses.size() == 2);
- REQUIRE(applicationProcesses[std::make_pair(applicationID, services[0])].size() == 1);
- REQUIRE(applicationProcesses[std::make_pair(applicationID, services[1])].size() == 1);
+ REQUIRE(applicationProcesses[std::make_pair(applicationID, services_[0])].size() == 1);
+ REQUIRE(applicationProcesses[std::make_pair(applicationID, services_[1])].size() == 1);
resetAppProcessConfiguration();
ServiceTests::reset();
@@ -437,7 +977,7 @@ TEST_CASE("Delete report types from the Application Process Configuration") {
CHECK(ServiceTests::count() == 0);
REQUIRE(applicationProcesses.size() == 1);
- REQUIRE(findServiceType(applicationID, services[1]));
+ REQUIRE(findServiceType(applicationID, services_[1]));
resetAppProcessConfiguration();
ServiceTests::reset();
@@ -497,7 +1037,7 @@ TEST_CASE("Delete report types from the Application Process Configuration") {
auto& applicationProcesses = realTimeForwarding.applicationProcessConfiguration.definitions;
REQUIRE(applicationProcesses.size() == 1);
- REQUIRE(not findServiceType(applicationID, services[0]));
+ REQUIRE(not findServiceType(applicationID, services_[0]));
resetAppProcessConfiguration();
ServiceTests::reset();
@@ -517,7 +1057,6 @@ TEST_CASE("Delete report types from the Application Process Configuration") {
MessageParser::execute(request);
CHECK(ServiceTests::count() == 0);
-
REQUIRE(applicationProcesses.empty());
resetAppProcessConfiguration();
@@ -555,11 +1094,11 @@ TEST_CASE("Delete report types from the Application Process Configuration") {
// Check for appID = 1
uint8_t appID1 = remainingApps[0];
REQUIRE(std::count_if(std::begin(definitions), std::end(definitions), [appID1](auto& definition) { return appID1 == definition.first.first; }) == 1);
- REQUIRE(not findServiceType(appID1, services[0]));
- auto appServicePair = std::make_pair(appID1, services[1]);
+ REQUIRE(not findServiceType(appID1, services_[0]));
+ auto appServicePair = std::make_pair(appID1, services_[1]);
REQUIRE(definitions[appServicePair].size() == 2);
- for (auto& message: messages1) {
+ for (auto& message: messages1_) {
REQUIRE(std::find(definitions[appServicePair].begin(),
definitions[appServicePair].end(),
message) != definitions[appServicePair].end());
@@ -575,8 +1114,8 @@ TEST_CASE("Delete report types from the Application Process Configuration") {
for (uint8_t i = 0; i < 15; i++) {
uint8_t numOfMessages = (i == 0 or i == 7) ? 1 : 2; // we only deleted one report from services 1 and 8
- uint8_t* messages = (i == 0 or i == 7) ? remainingMessage : messages2;
- auto appServicePair1 = std::make_pair(appID3, allServices[i]);
+ uint8_t* messages = (i == 0 or i == 7) ? remainingMessage : messages2_;
+ auto appServicePair1 = std::make_pair(appID3, allServices_[i]);
REQUIRE(definitions[appServicePair1].size() == numOfMessages);
for (uint8_t j = 0; j < numOfMessages; j++) {