mirror of
https://github.com/mudita/MuditaOS.git
synced 2026-01-25 14:29:22 -05:00
287 lines
9.6 KiB
C++
287 lines
9.6 KiB
C++
//
|
|
// Created by mati on 26.04.19.
|
|
//
|
|
|
|
#include "CommandsService.hpp"
|
|
|
|
#include "../Common/SchedulerKiller.hpp"
|
|
#include "TestService1.hpp"
|
|
#include "DelayedService.hpp"
|
|
#include "ticks.hpp"
|
|
#include "Service/Bus.hpp"
|
|
|
|
CommandsService::CommandsService(const std::string &name) : sys::Service(name)
|
|
{
|
|
|
|
busChannels.push_back(sys::BusChannels::CommandsServiceRequests);
|
|
|
|
oneShotTimer = CreateTimer(cpp_freertos::Ticks::MsToTicks(1000), false);
|
|
ReloadTimer(oneShotTimer);
|
|
}
|
|
|
|
sys::ReturnCodes CommandsService::InitHandler()
|
|
{
|
|
return sys::ReturnCodes::Success;
|
|
}
|
|
|
|
void CommandsService::TickHandler(uint32_t id)
|
|
{
|
|
|
|
auto msg = std::make_shared<CommandsServiceMsgRequest>();
|
|
|
|
sys::Bus::SendUnicast(msg, GetName(), this);
|
|
}
|
|
|
|
sys::Message_t CommandsService::DataReceivedHandler(sys::DataMessage *msgl, sys::ResponseMessage *resp)
|
|
{
|
|
uint32_t servCount = 10;
|
|
|
|
if (resp != nullptr) {
|
|
return std::make_shared<sys::ResponseMessage>();
|
|
}
|
|
|
|
/*
|
|
* Spawn 10 services and kill all of them
|
|
*/
|
|
|
|
// Spawn 10 test services
|
|
for (uint32_t i = 0; i < servCount; i++) {
|
|
auto ret = sys::SystemManager::CreateService(
|
|
std::make_shared<TestService1>("Test Service " + std::to_string(i)), this);
|
|
REQUIRE(ret);
|
|
REQUIRE(TestService1::TestServiceInstanceCount == i + 1);
|
|
}
|
|
|
|
// Destroy each service one by one
|
|
for (uint32_t i = servCount; i > 0; i--) {
|
|
REQUIRE(TestService1::TestServiceInstanceCount == i);
|
|
auto ret = sys::SystemManager::DestroyService("Test Service " + std::to_string(i - 1), this);
|
|
REQUIRE(ret);
|
|
}
|
|
|
|
REQUIRE(TestService1::TestServiceInstanceCount == 0);
|
|
|
|
/*
|
|
*
|
|
* Create 10 services,suspend,resume,send data and finally destroy them
|
|
*
|
|
*/
|
|
|
|
for (uint32_t i = 0; i < servCount; i++) {
|
|
auto ret = sys::SystemManager::CreateService(
|
|
std::make_shared<TestService1>("Test Service " + std::to_string(i)), this);
|
|
REQUIRE(ret);
|
|
REQUIRE(TestService1::TestServiceInstanceCount == i + 1);
|
|
}
|
|
|
|
REQUIRE(TestService1::TestServiceInstanceSuspendedCount == 0);
|
|
|
|
// Send 1000 data messages to test service using blocking Unicast method
|
|
uint32_t dataMsgCount = 1000;
|
|
|
|
for (uint32_t i = 0; i < dataMsgCount; i++) {
|
|
|
|
for (uint32_t j = 0; j < servCount; j++) {
|
|
auto msg = std::make_shared<TestServiceDataMessage>(TestServiceDataMessageType::Plain);
|
|
auto ret = sys::Bus::SendUnicast(msg, "Test Service " + std::to_string(j), this, 5000);
|
|
REQUIRE(ret.first == sys::ReturnCodes::Success);
|
|
}
|
|
}
|
|
|
|
// Send 1000 data messages to test service using Multicast method
|
|
|
|
for (uint32_t i = 0; i < dataMsgCount; i++) {
|
|
auto msg = std::make_shared<TestServiceDataMessage>(TestServiceDataMessageType::Plain);
|
|
sys::Bus::SendMulticast(msg, sys::BusChannels::TestServiceRequests, this);
|
|
}
|
|
cpp_freertos::Thread::Delay(50);
|
|
|
|
REQUIRE(TestService1::TestServiceInstanceDataMsgCount == 2 * servCount * dataMsgCount);
|
|
|
|
// Messages count should be 1, this is because there is still one left message which invoked this
|
|
// DataReceivedHandler
|
|
REQUIRE(sys::Message::unitestsMsgInstancesCount == 1);
|
|
|
|
// Destroy each service one by one
|
|
for (uint32_t i = servCount; i > 0; i--) {
|
|
REQUIRE(TestService1::TestServiceInstanceCount == i);
|
|
auto ret = sys::SystemManager::DestroyService("Test Service " + std::to_string(i - 1), this);
|
|
REQUIRE(ret);
|
|
}
|
|
|
|
REQUIRE(TestService1::TestServiceInstanceCount == 0);
|
|
|
|
/*
|
|
*
|
|
* Unicast blocking API variants test 1
|
|
* Sending data messages to service in blocked state
|
|
*
|
|
*/
|
|
|
|
{
|
|
auto ret = sys::SystemManager::CreateService(std::make_shared<DelayedService>("DelayedService"), this);
|
|
REQUIRE(ret);
|
|
REQUIRE(DelayedService::DelayerServiceInstanceCount == 1);
|
|
|
|
ret = sys::SystemManager::CreateService(std::make_shared<TestService1>("TS"), this);
|
|
REQUIRE(ret);
|
|
REQUIRE(TestService1::TestServiceInstanceCount == 1);
|
|
|
|
REQUIRE(TestService1::TestServiceInstanceDataMsgCount == 0);
|
|
|
|
sys::Bus::SendUnicast(
|
|
std::make_shared<TestServiceDataMessage>(TestServiceDataMessageType::Delayed), "TS", this);
|
|
|
|
for (uint32_t i = 0; i < 10; i++) {
|
|
auto msg = std::make_shared<TestServiceDataMessage>(TestServiceDataMessageType::Plain);
|
|
sys::Bus::SendUnicast(msg, "TS", this);
|
|
}
|
|
|
|
// Wait for TS to process incoming data
|
|
cpp_freertos::Thread::Delay(200);
|
|
|
|
REQUIRE(TestService1::TestServiceInstanceDataMsgCount == 10);
|
|
|
|
// Messages count should be 12, this is because:
|
|
// There is one response message (SendUnicast:145) waiting for processing
|
|
// There are 10 response messages (for loop at :147) waiting for processing
|
|
// There is still one left message which invoked this DataReceivedHandler
|
|
REQUIRE(sys::Message::unitestsMsgInstancesCount == 12);
|
|
|
|
ret = sys::SystemManager::DestroyService("DelayedService", this);
|
|
REQUIRE(ret);
|
|
REQUIRE(DelayedService::DelayerServiceInstanceCount == 0);
|
|
|
|
ret = sys::SystemManager::DestroyService("TS", this);
|
|
REQUIRE(ret);
|
|
REQUIRE(TestService1::TestServiceInstanceCount == 0);
|
|
}
|
|
|
|
/*
|
|
*
|
|
* Unicast blocking API variants test 2
|
|
* Destroying service in blocked state waiting for unicast response message
|
|
*
|
|
*/
|
|
|
|
{
|
|
|
|
uint32_t currentMessagesInstances = sys::Message::unitestsMsgInstancesCount;
|
|
|
|
auto ret = sys::SystemManager::CreateService(std::make_shared<DelayedService>("DelayedService"), this);
|
|
REQUIRE(ret);
|
|
REQUIRE(DelayedService::DelayerServiceInstanceCount == 1);
|
|
|
|
ret = sys::SystemManager::CreateService(std::make_shared<TestService1>("TS"), this);
|
|
REQUIRE(ret);
|
|
REQUIRE(TestService1::TestServiceInstanceCount == 1);
|
|
|
|
sys::Bus::SendUnicast(
|
|
std::make_shared<TestServiceDataMessage>(TestServiceDataMessageType::Delayed), "TS", this);
|
|
|
|
// There is one more pending response message (result of invoking SendUnicast at :195)
|
|
REQUIRE(sys::Message::unitestsMsgInstancesCount == currentMessagesInstances + 1);
|
|
|
|
ret = sys::SystemManager::DestroyService("TS", this);
|
|
REQUIRE(ret);
|
|
REQUIRE(TestService1::TestServiceInstanceCount == 0);
|
|
|
|
ret = sys::SystemManager::DestroyService("DelayedService", this);
|
|
REQUIRE(ret);
|
|
REQUIRE(DelayedService::DelayerServiceInstanceCount == 0);
|
|
}
|
|
|
|
/*
|
|
*
|
|
* Unicast blocking API variants test 3
|
|
* Testing timeout + droping staled response messages
|
|
*
|
|
*/
|
|
|
|
{
|
|
|
|
uint32_t currentMessagesInstances = sys::Message::unitestsMsgInstancesCount;
|
|
|
|
auto ret = sys::SystemManager::CreateService(std::make_shared<DelayedService>("DelayedService"), this);
|
|
REQUIRE(ret);
|
|
REQUIRE(DelayedService::DelayerServiceInstanceCount == 1);
|
|
|
|
ret = sys::SystemManager::CreateService(std::make_shared<TestService1>("TS"), this);
|
|
REQUIRE(ret);
|
|
REQUIRE(TestService1::TestServiceInstanceCount == 1);
|
|
|
|
{
|
|
auto retFalse = sys::Bus::SendUnicast(
|
|
std::make_shared<TestServiceDataMessage>(TestServiceDataMessageType::DelayedFail), "TS", this, 1000);
|
|
|
|
auto resp = std::static_pointer_cast<TestServiceResponse>(retFalse.second);
|
|
|
|
REQUIRE(resp->ret == sys::ReturnCodes::Timeout);
|
|
}
|
|
|
|
cpp_freertos::Thread::Delay(200);
|
|
|
|
REQUIRE(sys::Message::unitestsMsgInstancesCount == currentMessagesInstances);
|
|
|
|
ret = sys::SystemManager::DestroyService("TS", this);
|
|
REQUIRE(ret);
|
|
REQUIRE(TestService1::TestServiceInstanceCount == 0);
|
|
|
|
ret = sys::SystemManager::DestroyService("DelayedService", this);
|
|
REQUIRE(ret);
|
|
REQUIRE(DelayedService::DelayerServiceInstanceCount == 0);
|
|
}
|
|
|
|
/*
|
|
*
|
|
* Send data messages: many to many variant
|
|
*
|
|
*/
|
|
{
|
|
uint32_t currentMessagesInstances = sys::Message::unitestsMsgInstancesCount;
|
|
|
|
// Spawn 10 test services
|
|
for (uint32_t i = 0; i < servCount; i++) {
|
|
auto ret = sys::SystemManager::CreateService(std::make_shared<TestService1>(std::to_string(i)), this);
|
|
REQUIRE(ret);
|
|
REQUIRE(TestService1::TestServiceInstanceCount == i + 1);
|
|
}
|
|
|
|
sys::Bus::SendMulticast(std::make_shared<TestServiceDataMessage>(TestServiceDataMessageType::SendData),
|
|
sys::BusChannels::TestServiceRequests,
|
|
this);
|
|
|
|
cpp_freertos::Thread::Delay(500);
|
|
|
|
REQUIRE(TestService1::TestServiceInstanceDataMsgCount == servCount * 1000);
|
|
|
|
// Destroy each service one by one
|
|
for (uint32_t i = servCount; i > 0; i--) {
|
|
REQUIRE(TestService1::TestServiceInstanceCount == i);
|
|
auto ret = sys::SystemManager::DestroyService(std::to_string(i - 1), this);
|
|
REQUIRE(ret);
|
|
}
|
|
|
|
REQUIRE(TestService1::TestServiceInstanceCount == 0);
|
|
|
|
REQUIRE(sys::Message::unitestsMsgInstancesCount == currentMessagesInstances);
|
|
}
|
|
|
|
/*
|
|
*
|
|
* Test system close
|
|
*
|
|
*/
|
|
|
|
for (uint32_t i = 0; i < servCount; i++) {
|
|
auto ret = sys::SystemManager::CreateService(
|
|
std::make_shared<TestService1>("Test Service " + std::to_string(i)), this);
|
|
REQUIRE(ret);
|
|
REQUIRE(TestService1::TestServiceInstanceCount == i + 1);
|
|
}
|
|
|
|
auto ret = sys::SystemManager::CreateService(std::make_shared<SchedulerKiller>("Scheduler killer"), this);
|
|
REQUIRE(ret);
|
|
|
|
return std::make_shared<sys::ResponseMessage>();
|
|
} |