Method send_request

test/network_tests/memory_tests/memory_test_client.cpp:91–138

}

void memory_test_client::send_request(std::atomic<bool>& stop_checking_) {
    std::unique_lock lk(availability_mutex);
    // Only send the requests when the service availability is secured
    if (condition_availability.wait_for(lk, WAIT_AVAILABILITY, [this] { return availability; })) {

        // Trigger the test
        auto its_message = vsomeip_utilities::create_standard_vsip_request(MEMORY_SERVICE, MEMORY_INSTANCE, MEMORY_START_METHOD,
                                                                           MEMORY_MAJOR, vsomeip::message_type_e::MT_REQUEST_NO_RETURN);
        _app->send(its_message);
    }

    EXPECT_TRUE(availability) << "Events expected by the client were not available for 15 seconds ";

    bool stop_watchdog{false};
    uint64_t prev_counter{0};
    auto prev_time = std::chrono::steady_clock::now();

    // 3. Wait for service to send all the messages
    while (!stop_watchdog) {
        std::this_thread::sleep_for(WATCHDOG_INTERVAL);
        auto now = std::chrono::steady_clock::now();
        double elapsed_s = std::chrono::duration<double>(now - prev_time).count();

        uint64_t current_counter{0};
        bool timed_out{false};
        {
            std::scoped_lock lk(event_counter_mutex);
            current_counter = received_messages_counter;
            timed_out = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now() - sec).count() > 10;
        }

        uint64_t delta = current_counter - prev_counter;
        double throughput_mbs = (static_cast<double>(delta) * NOTIFY_PAYLOAD_SIZE) / elapsed_s / (1024.0 * 1024.0);

        VSOMEIP_INFO << "[watchdog] messages in last " << std::fixed << std::setprecision(1) << elapsed_s << "s: " << delta
                     << " | throughput: " << std::fixed << std::setprecision(2) << throughput_mbs << " MB/s"
                     << " | total received: " << current_counter;

        prev_counter = current_counter;
        prev_time = now;

        if (timed_out) {
            stop_watchdog = true;
        }
    }
    VSOMEIP_INFO << "received " << received_messages_counter;
    stop_checking_ = true;
}

void memory_test_client::unsubscribe_all() {
    _app->unsubscribe(MEMORY_SERVICE, MEMORY_INSTANCE, MEMORY_EVENTGROUP);