diff options
Diffstat (limited to 'test/network_tests/subscribe_notify_tests/subscribe_notify_test_one_event_two_eventgroups_service.cpp')
-rw-r--r-- | test/network_tests/subscribe_notify_tests/subscribe_notify_test_one_event_two_eventgroups_service.cpp | 248 |
1 files changed, 248 insertions, 0 deletions
diff --git a/test/network_tests/subscribe_notify_tests/subscribe_notify_test_one_event_two_eventgroups_service.cpp b/test/network_tests/subscribe_notify_tests/subscribe_notify_test_one_event_two_eventgroups_service.cpp new file mode 100644 index 0000000..20021e5 --- /dev/null +++ b/test/network_tests/subscribe_notify_tests/subscribe_notify_test_one_event_two_eventgroups_service.cpp @@ -0,0 +1,248 @@ +// 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/. +#ifndef VSOMEIP_ENABLE_SIGNAL_HANDLING +#include <csignal> +#endif +#include <chrono> +#include <condition_variable> +#include <iomanip> +#include <iostream> +#include <sstream> +#include <thread> +#include <atomic> + +#include <gtest/gtest.h> +#include <vsomeip/internal/logger.hpp> + +#include <vsomeip/vsomeip.hpp> + +#include "subscribe_notify_test_globals.hpp" + +class subscribe_notify_test_one_event_two_eventgroups_service { +public: + subscribe_notify_test_one_event_two_eventgroups_service(subscribe_notify_test::service_info _info, bool _use_tcp) : + app_(vsomeip::runtime::get()->create_application()), + wait_for_shutdown_(true), + info_(_info), + notify_thread_(std::bind(&subscribe_notify_test_one_event_two_eventgroups_service::wait_for_shutdown, this)), + use_tcp_(_use_tcp) { + } + + ~subscribe_notify_test_one_event_two_eventgroups_service() { + notify_thread_.join(); + } + + bool init() { + if (!app_->init()) { + ADD_FAILURE() << "Couldn't initialize application"; + return false; + } + app_->register_state_handler( + std::bind(&subscribe_notify_test_one_event_two_eventgroups_service::on_state, this, + std::placeholders::_1)); + + app_->register_message_handler( + info_.service_id, + info_.instance_id, + subscribe_notify_test::set_method_id, + std::bind(&subscribe_notify_test_one_event_two_eventgroups_service::on_set, this, + std::placeholders::_1)); + + app_->register_message_handler( + info_.service_id, + info_.instance_id, + info_.method_id, + std::bind(&subscribe_notify_test_one_event_two_eventgroups_service::on_message, this, + std::placeholders::_1)); + + app_->register_message_handler( + info_.service_id, + info_.instance_id, + subscribe_notify_test::shutdown_method_id, + std::bind(&subscribe_notify_test_one_event_two_eventgroups_service::on_shutdown, this, + std::placeholders::_1)); + + std::set<vsomeip::eventgroup_t> its_groups; + // the service offers three events in two eventgroups + // one of the events is in both eventgroups + its_groups.insert(info_.eventgroup_id); + app_->offer_event(info_.service_id, info_.instance_id, + info_.event_id, its_groups, vsomeip::event_type_e::ET_FIELD, + std::chrono::milliseconds::zero(), + false, true, nullptr, + (use_tcp_ ? vsomeip::reliability_type_e::RT_RELIABLE : vsomeip::reliability_type_e::RT_UNRELIABLE)); + app_->offer_event(info_.service_id, info_.instance_id, + static_cast<vsomeip::event_t>(info_.event_id + 2), + its_groups, vsomeip::event_type_e::ET_FIELD, + std::chrono::milliseconds::zero(), + false, true, nullptr, + (use_tcp_ ? vsomeip::reliability_type_e::RT_RELIABLE : vsomeip::reliability_type_e::RT_UNRELIABLE)); + its_groups.erase(info_.eventgroup_id); + its_groups.insert(static_cast<vsomeip::eventgroup_t>(info_.eventgroup_id + 1)); + app_->offer_event(info_.service_id, info_.instance_id, + static_cast<vsomeip::event_t>(info_.event_id + 1), + its_groups, vsomeip::event_type_e::ET_FIELD, + std::chrono::milliseconds::zero(), + false, true, nullptr, + (use_tcp_ ? vsomeip::reliability_type_e::RT_RELIABLE : vsomeip::reliability_type_e::RT_UNRELIABLE)); + app_->offer_event(info_.service_id, info_.instance_id, + static_cast<vsomeip::event_t>(info_.event_id + 2), + its_groups, vsomeip::event_type_e::ET_FIELD, + std::chrono::milliseconds::zero(), + false, true, nullptr, + (use_tcp_ ? vsomeip::reliability_type_e::RT_RELIABLE : vsomeip::reliability_type_e::RT_UNRELIABLE)); + payload_ = vsomeip::runtime::get()->create_payload(); + + return true; + } + + void start() { + app_->start(); + } + +#ifndef VSOMEIP_ENABLE_SIGNAL_HANDLING + /* + * Handle signal to shutdown + */ + void stop() { + { + std::lock_guard<std::mutex> its_lock(shutdown_mutex_); + wait_for_shutdown_ = false; + shutdown_condition_.notify_one(); + } + app_->clear_all_handler(); + stop_offer(); + notify_thread_.join(); + app_->stop(); + } +#endif + + void offer() { + app_->offer_service(info_.service_id, info_.instance_id); + } + + void stop_offer() { + app_->stop_offer_service(info_.service_id, info_.instance_id); + } + + void on_state(vsomeip::state_type_e _state) { + std::cout << "Application " << app_->get_name() << " is " + << (_state == vsomeip::state_type_e::ST_REGISTERED ? + "registered." : "deregistered.") << std::endl; + + if (_state == vsomeip::state_type_e::ST_REGISTERED) { + offer(); + } + } + + void on_shutdown(const std::shared_ptr<vsomeip::message> &_message) { + std::shared_ptr<vsomeip::message> its_response + = vsomeip::runtime::get()->create_response(_message); + its_response->set_payload(payload_); + app_->send(its_response); + { + std::lock_guard<std::mutex> its_lock(shutdown_mutex_); + wait_for_shutdown_ = false; + shutdown_condition_.notify_one(); + } + } + + void on_set(const std::shared_ptr<vsomeip::message> &_message) { + std::shared_ptr<vsomeip::message> its_response + = vsomeip::runtime::get()->create_response(_message); + payload_ = _message->get_payload(); + its_response->set_payload(payload_); + app_->send(its_response); + app_->notify(info_.service_id, info_.instance_id, info_.event_id, payload_); + app_->notify(info_.service_id, info_.instance_id, static_cast<vsomeip::event_t>(info_.event_id + 1), payload_); + app_->notify(info_.service_id, info_.instance_id, static_cast<vsomeip::event_t>(info_.event_id + 2), payload_); + } + + void on_message(const std::shared_ptr<vsomeip::message> &_message) { + app_->send(vsomeip::runtime::get()->create_response(_message)); + } + + void wait_for_shutdown() { + { + std::unique_lock<std::mutex> its_lock(shutdown_mutex_); + while (wait_for_shutdown_) { + shutdown_condition_.wait(its_lock); + } + wait_for_shutdown_= true; + } + + app_->clear_all_handler(); + std::this_thread::sleep_for(std::chrono::milliseconds(100)); + stop_offer(); + app_->stop(); + } + +private: + std::shared_ptr<vsomeip::application> app_; + + std::mutex shutdown_mutex_; + bool wait_for_shutdown_; + std::condition_variable shutdown_condition_; + + std::shared_ptr<vsomeip::payload> payload_; + + subscribe_notify_test::service_info info_; + + std::thread notify_thread_; + bool use_tcp_; +}; + +#ifndef VSOMEIP_ENABLE_SIGNAL_HANDLING + subscribe_notify_test_one_event_two_eventgroups_service *its_service_ptr(nullptr); + void handle_signal(int _signal) { + if (its_service_ptr != nullptr && + (_signal == SIGINT || _signal == SIGTERM)) + its_service_ptr->stop(); + } +#endif + +static bool use_tcp; + +TEST(someip_subscribe_notify_test_one_event_two_eventgroups, wait_for_attribute_set) +{ + subscribe_notify_test_one_event_two_eventgroups_service its_service( + subscribe_notify_test::service_info_subscriber_based_notification, use_tcp); +#ifndef VSOMEIP_ENABLE_SIGNAL_HANDLING + its_service_ptr = &its_service; + signal(SIGINT, handle_signal); + signal(SIGTERM, handle_signal); +#endif + if (its_service.init()) { + its_service.start(); + } +} + +#if defined(__linux__) || defined(ANDROID) +int main(int argc, char** argv) +{ + ::testing::InitGoogleTest(&argc, argv); + if(argc < 2) { + std::cerr << "Please specify a offer type of the service, like: " << argv[0] << " UDP" << std::endl; + std::cerr << "Valid offer types include:" << std::endl; + std::cerr << "[UDP, TCP]" << std::endl; + return 1; + } + + if(std::string("TCP") == std::string(argv[1])) { + use_tcp = true; + } else if(std::string("UDP") == std::string(argv[1])) { + use_tcp = false; + } else { + std::cerr << "Wrong subscription type passed, exiting" << std::endl; + std::cerr << "Valid subscription types include:" << std::endl; + std::cerr << "[UDP, TCP]" << std::endl; + return 1; + } + + return RUN_ALL_TESTS(); +} +#endif + + |