mirror of
https://github.com/mudita/MuditaOS.git
synced 2026-01-25 06:18:18 -05:00
319 lines
9.7 KiB
C++
319 lines
9.7 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){
|
|
uint32_t servCount = 10;
|
|
|
|
|
|
/*
|
|
* 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);
|
|
}
|
|
|
|
for(uint32_t i =0;i<servCount;i++){
|
|
auto ret = sys::SystemManager::SuspendService("Test Service " + std::to_string(i),this);
|
|
REQUIRE( ret );
|
|
}
|
|
|
|
REQUIRE( TestService1::TestServiceInstanceSuspendedCount == servCount);
|
|
|
|
for(uint32_t i =0;i<servCount;i++){
|
|
auto ret = sys::SystemManager::ResumeService("Test Service " + std::to_string(i),this);
|
|
REQUIRE( ret );
|
|
}
|
|
|
|
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>();
|
|
} |