Function TEST

test/network_tests/memory_tests/memory_test_client.cpp:156–204

}

TEST(memory_tests, receive_messages) {

    // Test steps:
    //      1: Start measuring memory load
    //      2: Send requests for 20 different events
    //      3: Wait for receiving all responses from service
    //      4: Stop measuring load and evaluate load increase
    //
    // At the end evaluate if the threshold of 5% increase in memory load was not surpassed

    std::map<vsomeip::event_t, int> events_to_subscribe;

    for (vsomeip::event_t i = 0; i < TEST_EVENT_NUMBER; i++) {
        events_to_subscribe[MEMORY_EVENT + i] = 0;
    }

    memory_test_client memory_test_client("memory_tests_client", events_to_subscribe);

    std::atomic<bool> stop_checking{false};

    // 1. Measure load until stop_checking is triggered
    std::thread memory_checker_thread;
    memory_checker_thread = std::thread([&stop_checking] {
        std::vector<std::uint64_t> test_memory_array;
        std::uint64_t sum{0};

        check_memory(test_memory_array, stop_checking);

        for (auto memory_stat : test_memory_array) {
            sum += memory_stat;
            VSOMEIP_INFO << memory_stat;
        }
        double memory_average = static_cast<double>(sum) / static_cast<double>(test_memory_array.size());
        VSOMEIP_INFO << memory_average;

        // 4. Evaluate memory load increase
        for (auto memory_stat : test_memory_array) {
            EXPECT_LT(static_cast<double>(memory_stat), (static_cast<double>(memory_average) * MEMORY_LOAD_LIMIT))
                    << "memory not lesser than " << (static_cast<double>(memory_average) * MEMORY_LOAD_LIMIT);
        }
    });

    // 2. Send a request and wait until all the messages are sent by the service
    memory_test_client.send_request(stop_checking);

    if (memory_checker_thread.joinable()) {
        memory_checker_thread.join();
    }
}

int main(int argc, char** argv) {
    return test_main(argc, argv, std::chrono::seconds(300));