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 "big_payload_test_client.hpp"
7 #include "big_payload_test_globals.hpp"
8
big_payload_test_client(bool _use_tcp,big_payload_test::test_mode _test_mode)9 big_payload_test_client::big_payload_test_client(
10 bool _use_tcp, big_payload_test::test_mode _test_mode) :
11 app_(vsomeip::runtime::get()->create_application("big_payload_test_client")),
12 request_(vsomeip::runtime::get()->create_request(_use_tcp)),
13 blocked_(false),
14 is_available_(false),
15 test_mode_(_test_mode),
16 number_of_messages_to_send_(
17 test_mode_ == big_payload_test::test_mode::RANDOM ?
18 big_payload_test::BIG_PAYLOAD_TEST_NUMBER_MESSAGES_RANDOM :
19 big_payload_test::BIG_PAYLOAD_TEST_NUMBER_MESSAGES),
20 number_of_sent_messages_(0),
21 number_of_acknowledged_messages_(0),
22 sender_(std::bind(&big_payload_test_client::run, this)) {
23 switch (test_mode_) {
24 case big_payload_test::test_mode::RANDOM:
25 service_id_ = big_payload_test::TEST_SERVICE_SERVICE_ID_RANDOM;
26 break;
27 case big_payload_test::test_mode::LIMITED:
28 service_id_ = big_payload_test::TEST_SERVICE_SERVICE_ID_LIMITED;
29 break;
30 case big_payload_test::test_mode::LIMITED_GENERAL:
31 service_id_ = big_payload_test::TEST_SERVICE_SERVICE_ID_LIMITED_GENERAL;
32 break;
33 case big_payload_test::test_mode::QUEUE_LIMITED_GENERAL:
34 service_id_ = big_payload_test::TEST_SERVICE_SERVICE_ID_QUEUE_LIMITED_GENERAL;
35 break;
36 case big_payload_test::test_mode::QUEUE_LIMITED_SPECIFIC:
37 service_id_ = big_payload_test::TEST_SERVICE_SERVICE_ID_QUEUE_LIMITED_SPECIFIC;
38 break;
39 case big_payload_test::test_mode::UDP:
40 service_id_ = big_payload_test::TEST_SERVICE_SERVICE_ID_UDP;
41 break;
42 default:
43 service_id_ = big_payload_test::TEST_SERVICE_SERVICE_ID;
44 break;
45 }
46 }
47
init()48 bool big_payload_test_client::init()
49 {
50 if (!app_->init()) {
51 ADD_FAILURE() << "Couldn't initialize application";
52 return false;
53 }
54
55 app_->register_state_handler(
56 std::bind(&big_payload_test_client::on_state, this,
57 std::placeholders::_1));
58
59 app_->register_message_handler(vsomeip::ANY_SERVICE,
60 vsomeip::ANY_INSTANCE, vsomeip::ANY_METHOD,
61 std::bind(&big_payload_test_client::on_message, this,
62 std::placeholders::_1));
63
64 app_->register_availability_handler(service_id_,
65 big_payload_test::TEST_SERVICE_INSTANCE_ID,
66 std::bind(&big_payload_test_client::on_availability, this,
67 std::placeholders::_1, std::placeholders::_2,
68 std::placeholders::_3));
69 return true;
70 }
71
start()72 void big_payload_test_client::start()
73 {
74 VSOMEIP_INFO << "Starting...";
75 app_->start();
76 }
77
stop()78 void big_payload_test_client::stop()
79 {
80 VSOMEIP_INFO << "Stopping...";
81 if (test_mode_ == big_payload_test::test_mode::LIMITED
82 || test_mode_ == big_payload_test::test_mode::LIMITED_GENERAL
83 || test_mode_ == big_payload_test::test_mode::QUEUE_LIMITED_GENERAL
84 || test_mode_ == big_payload_test::test_mode::QUEUE_LIMITED_SPECIFIC) {
85 std::this_thread::sleep_for(std::chrono::milliseconds(3000));
86 EXPECT_EQ(number_of_acknowledged_messages_, number_of_messages_to_send_ / 4);
87 } else if (test_mode_ == big_payload_test::test_mode::UDP) {
88 std::this_thread::sleep_for(std::chrono::milliseconds(3000));
89 EXPECT_EQ(number_of_acknowledged_messages_, number_of_messages_to_send_);
90 }
91 app_->clear_all_handler();
92 app_->stop();
93 }
94
join_sender_thread()95 void big_payload_test_client::join_sender_thread(){
96 sender_.join();
97 if (test_mode_ == big_payload_test::test_mode::LIMITED
98 || test_mode_ == big_payload_test::test_mode::LIMITED_GENERAL
99 || test_mode_ == big_payload_test::test_mode::QUEUE_LIMITED_GENERAL
100 || test_mode_ == big_payload_test::test_mode::QUEUE_LIMITED_SPECIFIC) {
101 EXPECT_EQ(number_of_acknowledged_messages_, number_of_messages_to_send_ / 4);
102 } else if (test_mode_ == big_payload_test::test_mode::UDP) {
103 EXPECT_EQ(number_of_sent_messages_, number_of_acknowledged_messages_);
104 } else {
105 EXPECT_EQ(number_of_sent_messages_, number_of_acknowledged_messages_);
106 }
107 }
108
on_state(vsomeip::state_type_e _state)109 void big_payload_test_client::on_state(vsomeip::state_type_e _state)
110 {
111 if (_state == vsomeip::state_type_e::ST_REGISTERED) {
112 app_->request_service(service_id_,
113 big_payload_test::TEST_SERVICE_INSTANCE_ID, false);
114 }
115 }
116
on_availability(vsomeip::service_t _service,vsomeip::instance_t _instance,bool _is_available)117 void big_payload_test_client::on_availability(vsomeip::service_t _service,
118 vsomeip::instance_t _instance, bool _is_available)
119 {
120 VSOMEIP_INFO << "Service [" << std::setw(4) << std::setfill('0') << std::hex
121 << _service << "." << _instance << "] is "
122 << (_is_available ? "available." : "NOT available.");
123
124 if(service_id_ == _service
125 && big_payload_test::TEST_SERVICE_INSTANCE_ID == _instance)
126 {
127 if(is_available_ && !_is_available)
128 {
129 is_available_ = false;
130 }
131 else if(_is_available && !is_available_)
132 {
133 is_available_ = true;
134 send();
135 }
136 }
137 }
138
on_message(const std::shared_ptr<vsomeip::message> & _response)139 void big_payload_test_client::on_message(const std::shared_ptr<vsomeip::message>& _response)
140 {
141 VSOMEIP_INFO << "Received a response from Service [" << std::setw(4)
142 << std::setfill('0') << std::hex << _response->get_service() << "."
143 << std::setw(4) << std::setfill('0') << std::hex
144 << _response->get_instance() << "] to Client/Session ["
145 << std::setw(4) << std::setfill('0') << std::hex
146 << _response->get_client() << "/" << std::setw(4)
147 << std::setfill('0') << std::hex << _response->get_session()
148 << "] size: " << std::dec << _response->get_payload()->get_length();
149 static vsomeip::session_t last_session(0);
150 ASSERT_GT(_response->get_session(), last_session);
151 last_session = _response->get_session();
152
153 if(test_mode_ == big_payload_test::test_mode::RANDOM) {
154 ASSERT_LT(_response->get_payload()->get_length(), big_payload_test::BIG_PAYLOAD_SIZE_RANDOM);
155 } else if (test_mode_ == big_payload_test::test_mode::UDP) {
156 EXPECT_EQ(big_payload_test::BIG_PAYLOAD_SIZE_UDP, _response->get_payload()->get_length());
157 } else {
158 ASSERT_EQ(_response->get_payload()->get_length(), big_payload_test::BIG_PAYLOAD_SIZE);
159 }
160
161 bool check(true);
162 vsomeip::length_t len = _response->get_payload()->get_length();
163 vsomeip::byte_t* datap = _response->get_payload()->get_data();
164 for(unsigned int i = 0; i < len; ++i) {
165 check = check && datap[i] == big_payload_test::DATA_SERVICE_TO_CLIENT;
166 }
167 if(!check) {
168 GTEST_FATAL_FAILURE_("wrong data transmitted");
169 }
170 number_of_acknowledged_messages_++;
171 if (test_mode_ == big_payload_test::test_mode::LIMITED
172 || test_mode_ == big_payload_test::test_mode::LIMITED_GENERAL
173 || test_mode_ == big_payload_test::test_mode::QUEUE_LIMITED_GENERAL
174 || test_mode_ == big_payload_test::test_mode::QUEUE_LIMITED_SPECIFIC) {
175 if (number_of_acknowledged_messages_ == number_of_messages_to_send_ / 4) {
176 send();
177 }
178 } else if ( number_of_acknowledged_messages_ == number_of_messages_to_send_) {
179 send();
180 }
181 }
182
send()183 void big_payload_test_client::send()
184 {
185 std::lock_guard<std::mutex> its_lock(mutex_);
186 blocked_ = true;
187 condition_.notify_one();
188 }
189
run()190 void big_payload_test_client::run()
191 {
192 std::unique_lock<std::mutex> its_lock(mutex_);
193 while (!blocked_)
194 {
195 condition_.wait(its_lock);
196 }
197 blocked_ = false;
198
199 request_->set_service(service_id_);
200 request_->set_instance(big_payload_test::TEST_SERVICE_INSTANCE_ID);
201 request_->set_method(big_payload_test::TEST_SERVICE_METHOD_ID);
202
203 std::srand(static_cast<unsigned int>(std::time(0)));
204
205 std::shared_ptr<vsomeip::payload> its_payload =
206 vsomeip::runtime::get()->create_payload();
207 std::vector<vsomeip::byte_t> its_payload_data;
208
209 for (unsigned int i = 0; i < number_of_messages_to_send_; i++)
210 {
211 if (test_mode_ == big_payload_test::test_mode::RANDOM) {
212 unsigned int datasize(static_cast<unsigned int>(std::rand()) % big_payload_test::BIG_PAYLOAD_SIZE_RANDOM);
213 its_payload_data.assign(datasize, big_payload_test::DATA_CLIENT_TO_SERVICE);
214 } else if (test_mode_ == big_payload_test::test_mode::LIMITED
215 || test_mode_ == big_payload_test::test_mode::LIMITED_GENERAL
216 || test_mode_ == big_payload_test::test_mode::QUEUE_LIMITED_GENERAL
217 || test_mode_ == big_payload_test::test_mode::QUEUE_LIMITED_SPECIFIC) {
218 if (i % 2) {
219 // try to sent a too big payload for half of the messages
220 its_payload_data.assign(big_payload_test::BIG_PAYLOAD_SIZE + 1,
221 big_payload_test::DATA_CLIENT_TO_SERVICE);
222 } else {
223 its_payload_data.assign(big_payload_test::BIG_PAYLOAD_SIZE,
224 big_payload_test::DATA_CLIENT_TO_SERVICE);
225 }
226 } else if (test_mode_ == big_payload_test::test_mode::UDP) {
227 its_payload_data.assign(big_payload_test::BIG_PAYLOAD_SIZE_UDP,
228 big_payload_test::DATA_CLIENT_TO_SERVICE);
229 } else {
230 its_payload_data.assign(big_payload_test::BIG_PAYLOAD_SIZE,
231 big_payload_test::DATA_CLIENT_TO_SERVICE);
232 }
233 its_payload->set_data(its_payload_data);
234 request_->set_payload(its_payload);
235 app_->send(request_);
236 if (test_mode_ == big_payload_test::test_mode::QUEUE_LIMITED_GENERAL
237 || test_mode_ == big_payload_test::test_mode::QUEUE_LIMITED_SPECIFIC) {
238 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
239 }
240 VSOMEIP_INFO << "Client/Session [" << std::setw(4) << std::setfill('0')
241 << std::hex << request_->get_client() << "/" << std::setw(4)
242 << std::setfill('0') << std::hex << request_->get_session()
243 << "] sent a request to Service [" << std::setw(4)
244 << std::setfill('0') << std::hex << request_->get_service()
245 << "." << std::setw(4) << std::setfill('0') << std::hex
246 << request_->get_instance() << "] size: " << std::dec <<
247 request_->get_payload()->get_length();
248 number_of_sent_messages_++;
249 }
250 while(!blocked_) {
251 if (std::cv_status::timeout
252 == condition_.wait_for(its_lock, std::chrono::seconds(120))) {
253 GTEST_FATAL_FAILURE_("Didn't receive all replies within time");
254 } else {
255 if (test_mode_ == big_payload_test::LIMITED
256 || test_mode_ == big_payload_test::test_mode::LIMITED_GENERAL
257 || test_mode_ == big_payload_test::test_mode::QUEUE_LIMITED_GENERAL
258 || test_mode_ == big_payload_test::test_mode::QUEUE_LIMITED_SPECIFIC) {
259 EXPECT_EQ(number_of_messages_to_send_ / 4,
260 number_of_acknowledged_messages_);
261 } else {
262 EXPECT_EQ(number_of_sent_messages_,
263 number_of_acknowledged_messages_);
264 }
265 }
266 }
267 stop();
268 }
269
270 static big_payload_test::test_mode test_mode(big_payload_test::test_mode::UNKNOWN);
271
TEST(someip_big_payload_test,send_ten_messages_to_service)272 TEST(someip_big_payload_test, send_ten_messages_to_service)
273 {
274 bool use_tcp = (test_mode != big_payload_test::test_mode::UDP);
275 big_payload_test_client test_client_(use_tcp, test_mode);
276 if (test_client_.init()) {
277 test_client_.start();
278 test_client_.join_sender_thread();
279 }
280 }
281
282 #ifndef _WIN32
main(int argc,char ** argv)283 int main(int argc, char** argv)
284 {
285 ::testing::InitGoogleTest(&argc, argv);
286 if (argc > 1) {
287 if (std::string("RANDOM") == std::string(argv[1])) {
288 test_mode = big_payload_test::test_mode::RANDOM;
289 } else if (std::string("LIMITED") == std::string(argv[1])) {
290 test_mode = big_payload_test::test_mode::LIMITED;
291 } else if (std::string("LIMITEDGENERAL") == std::string(argv[1])) {
292 test_mode = big_payload_test::test_mode::LIMITED_GENERAL;
293 } else if (std::string("QUEUELIMITEDGENERAL") == std::string(argv[1])) {
294 test_mode = big_payload_test::test_mode::QUEUE_LIMITED_GENERAL;
295 } else if (std::string("QUEUELIMITEDSPECIFIC") == std::string(argv[1])) {
296 test_mode = big_payload_test::test_mode::QUEUE_LIMITED_SPECIFIC;
297 } else if (std::string("UDP") == std::string(argv[1])) {
298 test_mode = big_payload_test::test_mode::UDP;
299 }
300 }
301 return RUN_ALL_TESTS();
302 }
303 #endif
304