~aleteoryx/muditaos

ref: 5e8f773d475f6b76156ee7c3375bdc543b5a9ace muditaos/module-services/service-db/test/test-settings/test-service-db-settings-api.cpp -rw-r--r-- 3.6 KiB
5e8f773d — Przemyslaw Brudny [EGD-6772] Fixed failing resize test 4 years ago 
                                                                                
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md

#include <catch2/catch.hpp>
#include <service-db/Settings.hpp>
#include <service-db/SettingsMessages.hpp>
#include <Service/Service.hpp>
#include <functional>
#include <thread> // for Message_t, ResponseMessage, DataMessage, Message

#include <module-services/service-db/ServiceDB.hpp>
#include <module-sys/SystemManager/SystemManager.hpp>

#include <service-evtmgr/EventManager.hpp>
#include <service-evtmgr/Constants.hpp>

#include "test-service-db-settings-testmsgs.hpp"
#include "test-service-db-settings-testservices.hpp"
#include "test-service-db-settings-testapps.hpp"
#include "Database.cpp"

TEST_CASE("SettingsApi")
{
    SECTION("variable/profile/mode register/set/get/unregister")
    {
        auto manager = std::make_shared<sys::SystemManager>(std::vector<std::unique_ptr<sys::BaseServiceCreator>>{});
        std::shared_ptr<settings::MyService> varWritter;
        std::shared_ptr<settings::MyService> varReader;
        std::shared_ptr<settings::AppTest> testVar;
        std::shared_ptr<std::mutex> testStart;

        std::shared_ptr<settings::Settings> postMortemSetting;

        manager->StartSystem(nullptr, [manager, &varWritter, &varReader, &testVar, &testStart, &postMortemSetting]() {
            // preliminary
            testStart = std::make_shared<std::mutex>();
            testStart->lock();
            std::cout << "start thr_id: " << std::this_thread::get_id() << std::endl << std::flush;
            auto ret = sys::SystemManager::RunSystemService(std::make_shared<EventManager>(service::name::evt_manager),
                                                            manager.get());
            ret &= sys::SystemManager::RunSystemService(std::make_shared<ServiceDB>(), manager.get());

            varWritter = std::make_shared<settings::MyService>("writterVar");
            varReader  = std::make_shared<settings::MyService>("readerVar");

            postMortemSetting = varWritter->getSettings();

            ret &= sys::SystemManager::RunSystemService(varWritter, manager.get());
            ret &= sys::SystemManager::RunSystemService(varReader, manager.get());

            testVar = std::make_shared<settings::AppTest>("appTest", varWritter, varReader, testStart);
            ret &= sys::SystemManager::RunSystemService(testVar, manager.get());

            std::cout << "koniec start thr_id: " << std::this_thread::get_id() << std::endl << std::flush;
            testStart->unlock();
            auto msgStart = std::make_shared<settings::UTMsg::UTMsgStart>();
            manager->bus.sendUnicast(std::move(msgStart), "appTest");

            msgStart = std::make_shared<settings::UTMsg::UTMsgStart>();
            manager->bus.sendUnicast(std::move(msgStart), "appTestProfile");

            msgStart = std::make_shared<settings::UTMsg::UTMsgStart>();
            manager->bus.sendUnicast(std::move(msgStart), "appTestMode");

            return ret;
        });

        try {
            // start application
            cpp_freertos::Thread::StartScheduler();

            // check the results
            std::cout << "testVar values:" << std::endl << std::flush;
            for (const auto &s : testVar->v) {
                std::cout << s << std::endl << std::flush;
            }
            REQUIRE(testVar->v.size() == 3);
            REQUIRE(testVar->v[1] == testVar->v[0] + "1");
            REQUIRE(testVar->v[2] == testVar->v[1] + "2");
        }
        catch (std::exception &error) {
            std::cout << error.what() << std::endl;
            exit(1);
        }
    }
}