21655938172

Committed 04 Feb 2026 02:23AM UTC coverage: 49.021% (+0.06%) from 48.959%

Build # 21655938172

Build Type

Pull #2762

github

Committed by

web-flow

Commit Message

Merge 98ac24bde into b84eae3a5

Pull Request Pull Request #2762: core: fix MAVLink message sequence

Coverage Stats

34 of 35 new or added lines in 2 files covered. (97.14%)

2 existing lines in 2 files now uncovered.

18354 of 37441 relevant lines covered (49.02%)

671.39 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.06

/src/system_tests/mavlink_seq.cpp

#include "log.h"
#include "mavsdk.h"
#include <chrono>
#include <thread>
#include <mutex>
#include <vector>
#include <gtest/gtest.h>

using namespace mavsdk;

TEST(SystemTest, MavlinkSeqSequential)
{
    Mavsdk mavsdk_autopilot{Mavsdk::Configuration{ComponentType::Autopilot}};
    Mavsdk mavsdk_groundstation{Mavsdk::Configuration{ComponentType::GroundStation}};

    ASSERT_EQ(
        mavsdk_groundstation.add_any_connection("udpin://0.0.0.0:17012"),
        ConnectionResult::Success);
    ASSERT_EQ(
        mavsdk_autopilot.add_any_connection("udpout://127.0.0.1:17012"),
        ConnectionResult::Success);

    auto maybe_system = mavsdk_groundstation.first_autopilot(10.0);
    ASSERT_TRUE(maybe_system);

    std::mutex seq_mutex;
    std::vector<uint8_t> seq_numbers;

    constexpr unsigned num_messages = 10;

    // Intercept all incoming messages on the ground station and record
    // sequence numbers from the autopilot system (sysid 1, compid 1).
    mavsdk_groundstation.intercept_incoming_messages_async(
        [&](mavlink_message_t& message) -> bool {
            if (message.sysid == 1 && message.compid == MAV_COMP_ID_AUTOPILOT1) {
                std::lock_guard<std::mutex> lock(seq_mutex);
                seq_numbers.push_back(message.seq);
            }
            return true;
        });

    // Collect messages (heartbeats at 1 Hz plus any other traffic).
    for (unsigned i = 0; i < 150; ++i) {
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        std::lock_guard<std::mutex> lock(seq_mutex);
        if (seq_numbers.size() >= num_messages) {
            break;
        }
    }

    // Stop intercepting.
    mavsdk_groundstation.intercept_incoming_messages_async(nullptr);

    std::lock_guard<std::mutex> lock(seq_mutex);
    ASSERT_GE(seq_numbers.size(), num_messages);

    // Verify that all messages from the autopilot component have strictly
    // sequential seq numbers (incrementing by 1 with uint8_t wrapping).
    for (unsigned i = 1; i < num_messages; ++i) {
        uint8_t expected = static_cast<uint8_t>(seq_numbers[i - 1] + 1);
        EXPECT_EQ(seq_numbers[i], expected)
            << "seq[" << i - 1 << "]=" << static_cast<int>(seq_numbers[i - 1]) << " seq[" << i
            << "]=" << static_cast<int>(seq_numbers[i]);
    }
}

1	#include "log.h"
2	#include "mavsdk.h"
3	#include <chrono>
4	#include <thread>
5	#include <mutex>
6	#include <vector>
7	#include <gtest/gtest.h>
8
9	using namespace mavsdk;
10
11	TEST(SystemTest, MavlinkSeqSequential)	4✔
12	{
13	Mavsdk mavsdk_autopilot{Mavsdk::Configuration{ComponentType::Autopilot}};	1✔
14	Mavsdk mavsdk_groundstation{Mavsdk::Configuration{ComponentType::GroundStation}};	1✔
15
16	ASSERT_EQ(	1✔
17	mavsdk_groundstation.add_any_connection("udpin://0.0.0.0:17012"),
18	ConnectionResult::Success);	1✔
19	ASSERT_EQ(	1✔
20	mavsdk_autopilot.add_any_connection("udpout://127.0.0.1:17012"),
21	ConnectionResult::Success);	1✔
22
23	auto maybe_system = mavsdk_groundstation.first_autopilot(10.0);	1✔
24	ASSERT_TRUE(maybe_system);	1✔
25
26	std::mutex seq_mutex;	1✔
27	std::vector<uint8_t> seq_numbers;	1✔
28
29	constexpr unsigned num_messages = 10;	1✔
30
31	// Intercept all incoming messages on the ground station and record
32	// sequence numbers from the autopilot system (sysid 1, compid 1).
33	mavsdk_groundstation.intercept_incoming_messages_async(	1✔
34	[&](mavlink_message_t& message) -> bool {	11✔
35	if (message.sysid == 1 && message.compid == MAV_COMP_ID_AUTOPILOT1) {	11✔
36	std::lock_guard<std::mutex> lock(seq_mutex);	11✔
37	seq_numbers.push_back(message.seq);	11✔
38	}	11✔
39	return true;	11✔
40	});
41
42	// Collect messages (heartbeats at 1 Hz plus any other traffic).
43	for (unsigned i = 0; i < 150; ++i) {	51✔
44	std::this_thread::sleep_for(std::chrono::milliseconds(100));	51✔
45	std::lock_guard<std::mutex> lock(seq_mutex);	51✔
46	if (seq_numbers.size() >= num_messages) {	51✔
47	break;	1✔
48	}
49	}	51✔
50
51	// Stop intercepting.
52	mavsdk_groundstation.intercept_incoming_messages_async(nullptr);	1✔
53
54	std::lock_guard<std::mutex> lock(seq_mutex);	1✔
55	ASSERT_GE(seq_numbers.size(), num_messages);	1✔
56
57	// Verify that all messages from the autopilot component have strictly
58	// sequential seq numbers (incrementing by 1 with uint8_t wrapping).
59	for (unsigned i = 1; i < num_messages; ++i) {	10✔
60	uint8_t expected = static_cast<uint8_t>(seq_numbers[i - 1] + 1);	9✔
61	EXPECT_EQ(seq_numbers[i], expected)	9✔
NEW 62	<< "seq[" << i - 1 << "]=" << static_cast<int>(seq_numbers[i - 1]) << " seq[" << i	×
63	<< "]=" << static_cast<int>(seq_numbers[i]);	9✔
64	}
65	}	1✔

mavlink / MAVSDK / 21655938172

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous