1 // Copyright (C) 2014-2018 Bayerische Motoren Werke Aktiengesellschaft (BMW AG)
2 // This Source Code Form is subject to the terms of the Mozilla Public
3 // License, v. 2.0. If a copy of the MPL was not distributed with this
4 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
5 
6 #include <chrono>
7 #include <condition_variable>
8 #include <iomanip>
9 #include <iostream>
10 #include <sstream>
11 #include <thread>
12 #include <map>
13 #include <algorithm>
14 #include <atomic>
15 
16 #include <gtest/gtest.h>
17 
18 #include <vsomeip/vsomeip.hpp>
19 #include <vsomeip/internal/logger.hpp>
20 
21 #include "event_test_globals.hpp"
22 
23 class event_test_client {
24 public:
event_test_client(struct event_test::service_info _service_info,event_test::test_mode_e _mode,bool _use_tcp)25     event_test_client(struct event_test::service_info _service_info, event_test::test_mode_e _mode,
26                       bool _use_tcp) :
27             service_info_(_service_info),
28             test_mode_(_mode),
29             use_tcp_(_use_tcp),
30             app_(vsomeip::runtime::get()->create_application("event_test_client")),
31             service_available_(false),
32             wait_until_registered_(true),
33             wait_until_service_available_(true),
34             wait_until_subscription_accepted_(true),
35             wait_until_events_received_(true),
36             wait_until_shutdown_reply_received_(true),
37             number_events_to_send_(50),
38             number_events_received_(0),
39             send_thread_(std::bind(&event_test_client::send, this)) {
40         if (!app_->init()) {
41             ADD_FAILURE() << "Couldn't initialize application";
42             return;
43         }
44         app_->register_state_handler(
45                 std::bind(&event_test_client::on_state, this,
46                         std::placeholders::_1));
47 
48         app_->register_message_handler(vsomeip::ANY_SERVICE,
49                 vsomeip::ANY_INSTANCE, vsomeip::ANY_METHOD,
50                 std::bind(&event_test_client::on_message, this,
51                         std::placeholders::_1));
52 
53         // register availability for all other services and request their event.
54         app_->register_availability_handler(service_info_.service_id,
55                 service_info_.instance_id,
56                 std::bind(&event_test_client::on_availability, this,
57                         std::placeholders::_1, std::placeholders::_2,
58                         std::placeholders::_3));
59         app_->request_service(service_info_.service_id,
60                 service_info_.instance_id);
61 
62         std::set<vsomeip::eventgroup_t> its_eventgroups;
63         its_eventgroups.insert(service_info_.eventgroup_id);
64         app_->request_event(service_info_.service_id,
65                 service_info_.instance_id, service_info_.event_id,
66                 its_eventgroups, vsomeip::event_type_e::ET_EVENT,
67                 (use_tcp_ ? vsomeip::reliability_type_e::RT_RELIABLE : vsomeip::reliability_type_e::RT_UNRELIABLE));
68         app_->register_subscription_status_handler(service_info_.service_id,
69                 service_info_.instance_id, service_info_.eventgroup_id,
70                 service_info_.event_id,
71                 std::bind(&event_test_client::on_subscription_status_changed, this,
72                           std::placeholders::_1, std::placeholders::_2,
73                           std::placeholders::_3, std::placeholders::_4,
74                           std::placeholders::_5));
75         app_->subscribe(service_info_.service_id, service_info_.instance_id,
76                 service_info_.eventgroup_id);
77 
78         app_->start();
79     }
80 
~event_test_client()81     ~event_test_client() {
82         send_thread_.join();
83     }
84 
on_state(vsomeip::state_type_e _state)85     void on_state(vsomeip::state_type_e _state) {
86         VSOMEIP_INFO << "Application " << app_->get_name() << " is "
87         << (_state == vsomeip::state_type_e::ST_REGISTERED ?
88                 "registered." : "deregistered.");
89 
90         if (_state == vsomeip::state_type_e::ST_REGISTERED) {
91             std::lock_guard<std::mutex> its_lock(mutex_);
92             wait_until_registered_ = false;
93             condition_.notify_one();
94         }
95     }
96 
on_availability(vsomeip::service_t _service,vsomeip::instance_t _instance,bool _is_available)97     void on_availability(vsomeip::service_t _service,
98                          vsomeip::instance_t _instance, bool _is_available) {
99             VSOMEIP_INFO << "Service [" << std::setw(4)
100             << std::setfill('0') << std::hex << _service << "." << _instance
101             << "] is " << (_is_available ? "available":"not available") << ".";
102             if (_is_available) {
103                 std::lock_guard<std::mutex> its_lock(mutex_);
104                 wait_until_service_available_ = false;
105                 condition_.notify_one();
106             }
107     }
108 
on_message(const std::shared_ptr<vsomeip::message> & _message)109     void on_message(const std::shared_ptr<vsomeip::message> &_message) {
110         if(_message->get_message_type() == vsomeip::message_type_e::MT_NOTIFICATION) {
111             on_notification(_message);
112         } else if (_message->get_message_type() == vsomeip::message_type_e::MT_RESPONSE) {
113             on_response(_message);
114         }
115     }
116 
on_notification(const std::shared_ptr<vsomeip::message> & _message)117     void on_notification(const std::shared_ptr<vsomeip::message> &_message) {
118         EXPECT_EQ(service_info_.service_id, _message->get_service());
119         EXPECT_EQ(service_info_.instance_id, _message->get_instance());
120         EXPECT_EQ(service_info_.event_id, _message->get_method());
121         if (test_mode_ == event_test::test_mode_e::PAYLOAD_FIXED) {
122             EXPECT_EQ(event_test::payload_fixed_length, _message->get_payload()->get_length());
123         } else if (test_mode_ == event_test::test_mode_e::PAYLOAD_DYNAMIC) {
124             static vsomeip::length_t length_last_received_msg(0);
125             EXPECT_GT(_message->get_payload()->get_length(), length_last_received_msg);
126             length_last_received_msg = _message->get_payload()->get_length();
127 
128         }
129         if (++number_events_received_ == number_events_to_send_) {
130             std::lock_guard<std::mutex> its_lock(mutex_);
131             wait_until_events_received_ = false;
132             condition_.notify_one();
133         }
134 
135         VSOMEIP_DEBUG
136         << "Received a notification with Client/Session [" << std::setw(4)
137         << std::setfill('0') << std::hex << _message->get_client() << "/"
138         << std::setw(4) << std::setfill('0') << std::hex
139         << _message->get_session() << "] from Service/Method ["
140         << std::setw(4) << std::setfill('0') << std::hex
141         << _message->get_service() << "/" << std::setw(4) << std::setfill('0')
142         << std::hex << _message->get_method() <<"]";
143 
144     }
145 
on_response(const std::shared_ptr<vsomeip::message> & _message)146     void on_response(const std::shared_ptr<vsomeip::message> &_message) {
147         EXPECT_EQ(service_info_.service_id, _message->get_service());
148         EXPECT_EQ(service_info_.shutdown_method_id, _message->get_method());
149         EXPECT_EQ(service_info_.instance_id, _message->get_instance());
150         std::lock_guard<std::mutex> its_lock(mutex_);
151         wait_until_shutdown_reply_received_ = false;
152         condition_.notify_one();
153     }
154 
on_subscription_status_changed(const vsomeip::service_t _service,const vsomeip::instance_t _instance,const vsomeip::eventgroup_t _eventgroup,const vsomeip::event_t _event,const uint16_t error_code)155     void on_subscription_status_changed(const vsomeip::service_t _service,
156                                         const vsomeip::instance_t _instance,
157                                         const vsomeip::eventgroup_t _eventgroup,
158                                         const vsomeip::event_t _event,
159                                         const uint16_t error_code) {
160         EXPECT_EQ(service_info_.service_id, _service);
161         EXPECT_EQ(service_info_.instance_id, _instance);
162         EXPECT_EQ(service_info_.eventgroup_id, _eventgroup);
163         EXPECT_EQ(service_info_.event_id, _event);
164         EXPECT_TRUE((error_code == 0x0u || error_code == 0x7u));
165         if (error_code == 0x0u) { // accepted
166             std::lock_guard<std::mutex> its_lock(mutex_);
167             wait_until_subscription_accepted_ = false;
168             condition_.notify_one();
169         }
170     }
171 
send()172     void send() {
173         std::unique_lock<std::mutex> its_lock(mutex_);
174         while (wait_until_registered_) {
175             condition_.wait(its_lock);
176         }
177 
178         while (wait_until_service_available_) {
179             condition_.wait(its_lock);
180         }
181 
182         while (wait_until_subscription_accepted_) {
183             if (std::cv_status::timeout == condition_.wait_for(its_lock, std::chrono::seconds(30))) {
184                 VSOMEIP_ERROR << "Subscription wasn't accepted in time!";
185                 break;
186             }
187         }
188 
189         // call notify method
190         auto its_message = vsomeip::runtime::get()->create_request(use_tcp_);
191         its_message->set_service(service_info_.service_id);
192         its_message->set_instance(service_info_.instance_id);
193         its_message->set_method(service_info_.notify_method_id);
194         its_message->set_message_type(vsomeip::message_type_e::MT_REQUEST_NO_RETURN);
195         auto its_payload = vsomeip::runtime::get()->create_payload();
196         its_payload->set_data(std::vector<vsomeip::byte_t>({
197                 static_cast<vsomeip::byte_t>(test_mode_),
198                 static_cast<vsomeip::byte_t>(number_events_to_send_)}));
199         its_message->set_payload(its_payload);
200         app_->send(its_message);
201 
202         while (wait_until_events_received_) {
203             if (std::cv_status::timeout == condition_.wait_for(its_lock, std::chrono::seconds(30))) {
204                 VSOMEIP_ERROR << "Didn't receive events in time!";
205                 break;
206             }
207         }
208 
209         // shutdown service
210         its_message->set_method(service_info_.shutdown_method_id);
211         its_message->set_message_type(vsomeip::message_type_e::MT_REQUEST);
212         app_->send(its_message);
213 
214         while (wait_until_shutdown_reply_received_) {
215             if (std::cv_status::timeout == condition_.wait_for(its_lock, std::chrono::seconds(30))) {
216                 VSOMEIP_ERROR << "Shutdown request wasn't answered in time!";
217                 break;
218             }
219         }
220         VSOMEIP_INFO << "going down";
221         app_->clear_all_handler();
222         app_->stop();
223     }
224 
225 
226 private:
227     struct event_test::service_info service_info_;
228     event_test::test_mode_e test_mode_;
229     bool use_tcp_;
230     std::shared_ptr<vsomeip::application> app_;
231     bool service_available_;
232 
233     bool wait_until_registered_;
234     bool wait_until_service_available_;
235     bool wait_until_subscription_accepted_;
236     bool wait_until_events_received_;
237     bool wait_until_shutdown_reply_received_;
238     std::mutex mutex_;
239     std::condition_variable condition_;
240 
241     const std::uint8_t number_events_to_send_;
242     std::atomic<std::uint32_t> number_events_received_;
243     std::thread send_thread_;
244 };
245 
246 static event_test::test_mode_e passed_mode = event_test::test_mode_e::PAYLOAD_FIXED;
247 static bool use_tcp = false;
248 
TEST(someip_event_test,subscribe_or_call_method_at_service)249 TEST(someip_event_test, subscribe_or_call_method_at_service)
250 {
251     event_test_client its_sample(event_test::service, passed_mode, use_tcp);
252 }
253 
254 #ifndef _WIN32
main(int argc,char ** argv)255 int main(int argc, char** argv)
256 {
257     ::testing::InitGoogleTest(&argc, argv);
258     if (argc < 3) {
259         std::cerr << "Please specify a operation mode, like: " << argv[0] << "PAYLOAD_FIXED TCP" << std::endl;
260         std::cerr << "Valid operation modes are PAYLOAD_FIXED and PAYLOAD_DYNAMIC" << std::endl;
261         std::cerr << "Valid communication modes are UDP or TCP" << std::endl;
262         return 1;
263     }
264 
265     if (std::string("PAYLOAD_FIXED") == std::string(argv[1])) {
266         passed_mode = event_test::test_mode_e::PAYLOAD_FIXED;
267     } else if (std::string("PAYLOAD_DYNAMIC") == std::string(argv[1])) {
268         passed_mode = event_test::test_mode_e::PAYLOAD_DYNAMIC;
269     } else {
270         std::cerr << "Wrong operation mode passed, exiting" << std::endl;
271         std::cerr << "Please specify a operation mode, like: " << argv[0] << " PAYLOAD_FIXED" << std::endl;
272         std::cerr << "Valid operation modes are PAYLOAD_FIXED and PAYLOAD_DYNAMIC" << std::endl;
273         return 1;
274     }
275     if (std::string("TCP")== std::string(argv[2])) {
276         use_tcp = true;
277     } else if (std::string("UDP")== std::string(argv[2])) {
278         use_tcp = false;
279     }
280     return RUN_ALL_TESTS();
281 }
282 #endif
283