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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
// Copyright (C) 2014-2017 Bayerische Motoren Werke Aktiengesellschaft (BMW AG)
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
#include <chrono>
#include <condition_variable>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <thread>
#include <map>
#include <algorithm>
#include <future>
#include <atomic>
#include <gtest/gtest.h>
#include <vsomeip/vsomeip.hpp>
#include <vsomeip/internal/logger.hpp>
#include "application_test_globals.hpp"
class application_test_service {
public:
application_test_service(struct application_test::service_info _service_info) :
service_info_(_service_info),
// service with number 1 uses "routingmanagerd" as application name
// this way the same json file can be reused for all local tests
// including the ones with routingmanagerd
app_(vsomeip::runtime::get()->create_application("service")),
wait_until_registered_(true),
stop_called_(false),
offer_thread_(std::bind(&application_test_service::run, this)) {
if (!app_->init()) {
ADD_FAILURE() << "Couldn't initialize application";
return;
}
app_->register_state_handler(
std::bind(&application_test_service::on_state, this,
std::placeholders::_1));
app_->register_message_handler(service_info_.service_id,
service_info_.instance_id, service_info_.method_id,
std::bind(&application_test_service::on_request, this,
std::placeholders::_1));
app_->register_message_handler(service_info_.service_id,
service_info_.instance_id, service_info_.shutdown_method_id,
std::bind(&application_test_service::on_shutdown_method_called, this,
std::placeholders::_1));
std::promise<bool> its_promise;
application_thread_ = std::thread([&](){
its_promise.set_value(true);
app_->start();
});
EXPECT_TRUE(its_promise.get_future().get());
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
~application_test_service() {
offer_thread_.join();
application_thread_.join();
}
void offer() {
app_->offer_service(service_info_.service_id, service_info_.instance_id,
service_info_.major_version, service_info_.minor_version);
}
void on_state(vsomeip::state_type_e _state) {
VSOMEIP_INFO << "Application " << app_->get_name() << " is "
<< (_state == vsomeip::state_type_e::ST_REGISTERED ?
"registered." : "deregistered.");
if (_state == vsomeip::state_type_e::ST_REGISTERED) {
std::lock_guard<std::mutex> its_lock(mutex_);
wait_until_registered_ = false;
condition_.notify_one();
}
}
void on_request(const std::shared_ptr<vsomeip::message> &_message) {
app_->send(vsomeip::runtime::get()->create_response(_message));
VSOMEIP_INFO << "Received a request with Client/Session [" << std::setw(4)
<< std::setfill('0') << std::hex << _message->get_client() << "/"
<< std::setw(4) << std::setfill('0') << std::hex
<< _message->get_session() << "]";
}
void on_shutdown_method_called(const std::shared_ptr<vsomeip::message> &_message) {
(void)_message;
stop();
}
void stop() {
stop_called_ = true;
app_->stop_offer_service(service_info_.service_id, service_info_.instance_id,
service_info_.major_version, service_info_.minor_version);
app_->clear_all_handler();
app_->stop();
}
void run() {
VSOMEIP_DEBUG << "[" << std::setw(4) << std::setfill('0') << std::hex
<< service_info_.service_id << "] Running";
std::unique_lock<std::mutex> its_lock(mutex_);
while (wait_until_registered_ && !stop_called_) {
condition_.wait_for(its_lock, std::chrono::milliseconds(100));
}
VSOMEIP_DEBUG << "[" << std::setw(4) << std::setfill('0') << std::hex
<< service_info_.service_id << "] Offering";
offer();
}
private:
struct application_test::service_info service_info_;
std::shared_ptr<vsomeip::application> app_;
bool wait_until_registered_;
std::mutex mutex_;
std::condition_variable condition_;
std::atomic<bool> stop_called_;
std::thread offer_thread_;
std::thread application_thread_;
};
|
