1 // Copyright (C) 2015-2017 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 "local_routing_test_client.hpp"
7
local_routing_test_client(bool _use_tcp)8 local_routing_test_client::local_routing_test_client(bool _use_tcp) :
9 app_(vsomeip::runtime::get()->create_application()),
10 request_(vsomeip::runtime::get()->create_request(_use_tcp)),
11 blocked_(false),
12 is_available_(false),
13 number_of_messages_to_send_(vsomeip_test::NUMBER_OF_MESSAGES_TO_SEND),
14 number_of_sent_messages_(0),
15 number_of_acknowledged_messages_(0),
16 sender_(std::bind(&local_routing_test_client::run, this))
17 {
18 }
19
init()20 bool local_routing_test_client::init()
21 {
22 if (!app_->init()) {
23 ADD_FAILURE() << "Couldn't initialize application";
24 return false;
25 }
26
27 app_->register_state_handler(
28 std::bind(&local_routing_test_client::on_state, this,
29 std::placeholders::_1));
30
31 app_->register_message_handler(vsomeip::ANY_SERVICE,
32 vsomeip_test::TEST_SERVICE_INSTANCE_ID, vsomeip::ANY_METHOD,
33 std::bind(&local_routing_test_client::on_message, this,
34 std::placeholders::_1));
35
36 app_->register_availability_handler(vsomeip_test::TEST_SERVICE_SERVICE_ID,
37 vsomeip_test::TEST_SERVICE_INSTANCE_ID,
38 std::bind(&local_routing_test_client::on_availability, this,
39 std::placeholders::_1, std::placeholders::_2,
40 std::placeholders::_3));
41 return true;
42 }
43
start()44 void local_routing_test_client::start()
45 {
46 VSOMEIP_INFO << "Starting...";
47 app_->start();
48 }
49
stop()50 void local_routing_test_client::stop()
51 {
52 VSOMEIP_INFO << "Stopping...";
53 app_->clear_all_handler();
54 app_->stop();
55 }
56
join_sender_thread()57 void local_routing_test_client::join_sender_thread(){
58 sender_.join();
59
60 ASSERT_EQ(number_of_sent_messages_, number_of_acknowledged_messages_);
61 }
62
on_state(vsomeip::state_type_e _state)63 void local_routing_test_client::on_state(vsomeip::state_type_e _state)
64 {
65 if(_state == vsomeip::state_type_e::ST_REGISTERED)
66 {
67 app_->request_service(vsomeip_test::TEST_SERVICE_SERVICE_ID,
68 vsomeip_test::TEST_SERVICE_INSTANCE_ID, false);
69 }
70 }
71
on_availability(vsomeip::service_t _service,vsomeip::instance_t _instance,bool _is_available)72 void local_routing_test_client::on_availability(vsomeip::service_t _service,
73 vsomeip::instance_t _instance, bool _is_available)
74 {
75 VSOMEIP_INFO << "Service [" << std::setw(4) << std::setfill('0') << std::hex
76 << _service << "." << _instance << "] is "
77 << (_is_available ? "available." : "NOT available.");
78
79 if(vsomeip_test::TEST_SERVICE_SERVICE_ID == _service
80 && vsomeip_test::TEST_SERVICE_INSTANCE_ID == _instance)
81 {
82 if(is_available_ && !_is_available)
83 {
84 is_available_ = false;
85 }
86 else if(_is_available && !is_available_)
87 {
88 is_available_ = true;
89 send();
90 }
91 }
92 }
93
on_message(const std::shared_ptr<vsomeip::message> & _response)94 void local_routing_test_client::on_message(const std::shared_ptr<vsomeip::message>& _response)
95 {
96 VSOMEIP_INFO << "Received a response from Service [" << std::setw(4)
97 << std::setfill('0') << std::hex << _response->get_service() << "."
98 << std::setw(4) << std::setfill('0') << std::hex
99 << _response->get_instance() << "] to Client/Session ["
100 << std::setw(4) << std::setfill('0') << std::hex
101 << _response->get_client() << "/" << std::setw(4)
102 << std::setfill('0') << std::hex << _response->get_session() << "]";
103 number_of_acknowledged_messages_++;
104 if(number_of_acknowledged_messages_ == number_of_messages_to_send_) {
105 std::lock_guard<std::mutex> its_lock(mutex_);
106 blocked_ = true;
107 condition_.notify_one();
108 }
109 }
110
send()111 void local_routing_test_client::send()
112 {
113 std::lock_guard<std::mutex> its_lock(mutex_);
114 blocked_ = true;
115 condition_.notify_one();
116 }
117
run()118 void local_routing_test_client::run()
119 {
120 std::unique_lock<std::mutex> its_lock(mutex_);
121 while (!blocked_)
122 {
123 condition_.wait(its_lock);
124 }
125 blocked_ = false;
126 request_->set_service(vsomeip_test::TEST_SERVICE_SERVICE_ID);
127 request_->set_instance(vsomeip_test::TEST_SERVICE_INSTANCE_ID);
128 request_->set_method(vsomeip_test::TEST_SERVICE_METHOD_ID);
129
130 for (uint32_t i = 0; i < number_of_messages_to_send_; i++)
131 {
132 app_->send(request_);
133 VSOMEIP_INFO << "Client/Session [" << std::setw(4) << std::setfill('0')
134 << std::hex << request_->get_client() << "/" << std::setw(4)
135 << std::setfill('0') << std::hex << request_->get_session()
136 << "] sent a request to Service [" << std::setw(4)
137 << std::setfill('0') << std::hex << request_->get_service()
138 << "." << std::setw(4) << std::setfill('0') << std::hex
139 << request_->get_instance() << "]";
140 number_of_sent_messages_++;
141 }
142 blocked_ = false;
143 // wait until all messages have been acknowledged
144 while (!blocked_)
145 {
146 condition_.wait(its_lock);
147 }
148 stop();
149 }
150
TEST(someip_local_routing_test,send_ten_messages_to_service_and_receive_reply)151 TEST(someip_local_routing_test, send_ten_messages_to_service_and_receive_reply)
152 {
153 bool use_tcp = false;
154 local_routing_test_client test_client_(use_tcp);
155 if (test_client_.init()) {
156 test_client_.start();
157 test_client_.join_sender_thread();
158 }
159 }
160
161 #ifndef _WIN32
main(int argc,char ** argv)162 int main(int argc, char** argv)
163 {
164 ::testing::InitGoogleTest(&argc, argv);
165 return RUN_ALL_TESTS();
166 }
167 #endif
168