wirenboard / wb-mqtt-mbgate / 79

Committed 31 Jul 2026 10:42AM UTC coverage: 69.352% (-1.3%) from 70.692%

Build # 79

Build Type

push

github

Committed by

web-flow

Commit Message

Use exported vars instead of MAKEFLAGS for coverage options (#62)

Coverage Stats

706 of 926 branches covered (76.24%)

1188 of 1713 relevant lines covered (69.35%)

11.4 hits per line

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

98.74

/test/address_range_test.cpp

#include <gmock/gmock.h>
#include <gtest/gtest.h>

#include "address_range.h"
#include <exception>
#include <iostream>
#include <memory>

using namespace std;

using ::testing::_;
using ::testing::ElementsAre;

typedef TAddressRange<int> TestAddressRange;
typedef TAddressRange<std::shared_ptr<int>> TestPtrAddressRange;

class TAddressRangeTest: public ::testing::Test
{
protected:
    void SetUp()
    {}
    void TearDown()
    {}
};

TEST_F(TAddressRangeTest, IntersectionTest)
{
    TestAddressRange test_range;
    TestAddressRange result_range;

    // check merging
    // --[--)-------- +
    // -----[-----)-- =
    // --[--------)--
    test_range.insert(0, 10, 1);
    test_range.insert(10, 10, 1);

    result_range.insert(0, 20, 1);
    EXPECT_EQ(test_range, result_range);

    test_range.clear();
    result_range.clear();

    // --[----)------- +
    // ----[----)----- =
    // --[------)-----
    test_range.insert(-10, 20, 1);
    test_range.insert(0, 20, 1);

    result_range.insert(-10, 30, 1);
    EXPECT_EQ(test_range, result_range);

    test_range.clear();
    result_range.clear();

    // --[---------)---- +
    // ----[-----)------ =
    // --[---------)----
    test_range.insert(10, 30, 1);
    test_range.insert(20, 10, 1);

    result_range.insert(10, 30, 1);
    EXPECT_EQ(test_range, result_range);

    test_range.clear();
    result_range.clear();

    // ----[-----)------ +
    // --[---------)---- =
    // --[---------)----
    test_range.insert(20, 10, 1);
    test_range.insert(10, 30, 1);

    result_range.insert(10, 30, 1);
    EXPECT_EQ(test_range, result_range);

    test_range.clear();
    result_range.clear();

    // ---[---)----[---)--- +
    // ----[----)---------- =
    // ---[-----)--[---)---
    test_range.insert(0, 10, 1);
    test_range.insert(20, 10, 1);
    test_range.insert(5, 10, 1);

    result_range.insert(0, 15, 1);
    result_range.insert(20, 10, 1);
    EXPECT_EQ(test_range, result_range);

    test_range.clear();
    result_range.clear();

    // ---[---)----[---)--- +
    // ----------[----)---- =
    // ---[---)--[-----)---
    test_range.insert(0, 10, 1);
    test_range.insert(20, 10, 1);
    test_range.insert(15, 10, 1);

    result_range.insert(0, 10, 1);
    result_range.insert(15, 15, 1);
    EXPECT_EQ(test_range, result_range);

    test_range.clear();
    result_range.clear();

    // ---[---)----[---)--- +
    // ------[--------)---- =
    // ---[------------)---
    test_range.insert(0, 10, 1);
    test_range.insert(20, 10, 1);
    test_range.insert(5, 20, 1);

    result_range.insert(0, 30, 1);
    EXPECT_EQ(test_range, result_range);

    test_range.clear();
    result_range.clear();

    // ---[---)-[)--[---)--- +
    // --[---------------)-- =
    // --[---------------)--
    test_range.insert(0, 10, 1);
    test_range.insert(20, 10, 1);
    test_range.insert(35, 10, 1);
    test_range.insert(-10, 80, 1);

    result_range.insert(-10, 80, 1);
    EXPECT_EQ(test_range, result_range);

    test_range.clear();
    result_range.clear();
}

TEST_F(TAddressRangeTest, EmptyIntersectionTest)
{
    TestPtrAddressRange r1(0, 10), r2(5, 10), result(0, 15);

    r1 += r2;

    EXPECT_EQ(r1, result);
}

TEST_F(TAddressRangeTest, OperatorTest)
{
    TestAddressRange r1, r2, r3, result;

    // basic insert()
    r1.insert(1, 10, 1);
    r2.insert(2, 10, 1);

    r1.insert(r2);

    result.insert(1, 11, 1);
    EXPECT_EQ(r1, result);

    r1.clear();
    r2.clear();
    result.clear();

    // overloaded operators
    r1.insert(1, 10, 1);
    r2.insert(5, 10, 1);
    r3 = r1 + r2;

    result.insert(1, 14, 1);
    EXPECT_EQ(r3, result);

    r1.clear();
    r2.clear();
    r3.clear();
    result.clear();

    // different parameters
    r1.insert(0, 10, 1);
    r2.insert(10, 10, 2);
    r3.insert(20, 10, 3);

    r1 += r2 + r3;
    r2 += r1;

    EXPECT_EQ(r1, r2);
}

TEST_F(TAddressRangeTest, InRangeTest)
{
    TestAddressRange r1, r2;

    r1.insert(0, 10, 1);
    r2.insert(10, 10, 2);

    r1 += r2;

    EXPECT_EQ(r1.inRange(0), true);
    EXPECT_EQ(r1.inRange(20), false);
    EXPECT_EQ(r1.inRange(1, 5), true);
    EXPECT_EQ(r1.inRange(4), true);
    EXPECT_EQ(r1.inRange(15, 3), true);
    EXPECT_EQ(r1.inRange(10), true);
    EXPECT_EQ(r1.inRange(-15, 5), false);
    EXPECT_EQ(r1.inRange(21), false);
    EXPECT_EQ(r1.inRange(8, 4), false);
}

TEST_F(TAddressRangeTest, GetParamTest)
{
    TestAddressRange r1(0, 10, 1), r2(10, 10, 2), r3(100, 25, -1);

    r1 += r2 + r3;

    EXPECT_EQ(r1.getParam(0), 1);
    EXPECT_EQ(r1.getParam(10), 2);
    EXPECT_EQ(r1.getParam(100), -1);
    EXPECT_EQ(r1.getParam(9), 1);

    EXPECT_THROW(r1.getParam(20), WrongSegmentException);
    EXPECT_THROW(r1.getParam(8, 4), WrongSegmentException);
    EXPECT_THROW(r1.getParam(0, 11), WrongSegmentException);
}

TEST_F(TAddressRangeTest, InsertFailureTest)
{
    TestAddressRange r(0, 20, 1);

    EXPECT_THROW(r + TestAddressRange(10, 20, 2), WrongSegmentException);
    EXPECT_THROW(r.insert(10, 20, 2), WrongSegmentException);
    EXPECT_THROW(TestAddressRange(2, 1, 1) + TestAddressRange(0, 15, 2), WrongSegmentException);
}

TEST_F(TAddressRangeTest, DiffIntersectionTest)
{
    TestAddressRange test_range;
    TestAddressRange result_range;

    test_range.insert(0, 1, 1);
    test_range.insert(1, 1, 2);
}

TEST_F(TAddressRangeTest, MultiSegmentsTest)
{
    TestAddressRange r, r1, r2, r3, r4, r5;

    r1 = TestAddressRange(0, 5, 1);
    r2 = TestAddressRange(5, 5, 2);
    r3 = TestAddressRange(10, 5, 1);
    r4 = TestAddressRange(15, 5, 3);

    r5 = TestAddressRange(40, 5, 1);

    r = r1 + r2 + r3 + r4 + r5;
    auto list1 = r.getSegments(1, 14);
    EXPECT_THAT(list1, ElementsAre(TestAddressRange(1, 4, 1), r2, TestAddressRange(10, 5, 1)));

    try {
        auto list2 = r.getSegments(4, 2);
        EXPECT_THAT(list2, ElementsAre(TestAddressRange(4, 1, 1), TestAddressRange(5, 1, 2)));
    } catch (const WrongSegmentException& e) {
        cerr << e.what() << endl;
    }

    EXPECT_THROW(r.getSegments(13, 40), WrongSegmentException);
}

TEST_F(TAddressRangeTest, ShiftTest)
{
    TestAddressRange r(0, 10, 1);
    r += TestAddressRange(40, 10, 2);
    TestAddressRange r2 = r + 10;

    TestAddressRange result1(10, 10, 1);
    result1.insert(50, 10, 2);

    EXPECT_EQ(r2, result1);

    r2 -= 10;
    EXPECT_EQ(r, r2);
}

1	#include <gmock/gmock.h>
2	#include <gtest/gtest.h>
3
4	#include "address_range.h"
5	#include <exception>
6	#include <iostream>
7	#include <memory>
8
9	using namespace std;
10
11	using ::testing::_;
12	using ::testing::ElementsAre;
13
14	typedef TAddressRange<int> TestAddressRange;
15	typedef TAddressRange<std::shared_ptr<int>> TestPtrAddressRange;
16
17	class TAddressRangeTest: public ::testing::Test
18	{
19	protected:
20	void SetUp()	9✔
21	{}	9✔
22	void TearDown()	9✔
23	{}	9✔
24	};
25
26	TEST_F(TAddressRangeTest, IntersectionTest)	8✔
27	{
28	TestAddressRange test_range;	2✔
29	TestAddressRange result_range;	2✔
30
31	// check merging
32	// --[--)-------- +
33	// -----[-----)-- =
34	// --[--------)--
35	test_range.insert(0, 10, 1);	2✔
36	test_range.insert(10, 10, 1);	2✔
37
38	result_range.insert(0, 20, 1);	2✔
39	EXPECT_EQ(test_range, result_range);	2✔
40
41	test_range.clear();	2✔
42	result_range.clear();	2✔
43
44	// --[----)------- +
45	// ----[----)----- =
46	// --[------)-----
47	test_range.insert(-10, 20, 1);	2✔
48	test_range.insert(0, 20, 1);	2✔
49
50	result_range.insert(-10, 30, 1);	2✔
51	EXPECT_EQ(test_range, result_range);	2✔
52
53	test_range.clear();	2✔
54	result_range.clear();	2✔
55
56	// --[---------)---- +
57	// ----[-----)------ =
58	// --[---------)----
59	test_range.insert(10, 30, 1);	2✔
60	test_range.insert(20, 10, 1);	2✔
61
62	result_range.insert(10, 30, 1);	2✔
63	EXPECT_EQ(test_range, result_range);	2✔
64
65	test_range.clear();	2✔
66	result_range.clear();	2✔
67
68	// ----[-----)------ +
69	// --[---------)---- =
70	// --[---------)----
71	test_range.insert(20, 10, 1);	2✔
72	test_range.insert(10, 30, 1);	2✔
73
74	result_range.insert(10, 30, 1);	2✔
75	EXPECT_EQ(test_range, result_range);	2✔
76
77	test_range.clear();	2✔
78	result_range.clear();	2✔
79
80	// ---[---)----[---)--- +
81	// ----[----)---------- =
82	// ---[-----)--[---)---
83	test_range.insert(0, 10, 1);	2✔
84	test_range.insert(20, 10, 1);	2✔
85	test_range.insert(5, 10, 1);	2✔
86
87	result_range.insert(0, 15, 1);	2✔
88	result_range.insert(20, 10, 1);	2✔
89	EXPECT_EQ(test_range, result_range);	2✔
90
91	test_range.clear();	2✔
92	result_range.clear();	2✔
93
94	// ---[---)----[---)--- +
95	// ----------[----)---- =
96	// ---[---)--[-----)---
97	test_range.insert(0, 10, 1);	2✔
98	test_range.insert(20, 10, 1);	2✔
99	test_range.insert(15, 10, 1);	2✔
100
101	result_range.insert(0, 10, 1);	2✔
102	result_range.insert(15, 15, 1);	2✔
103	EXPECT_EQ(test_range, result_range);	2✔
104
105	test_range.clear();	2✔
106	result_range.clear();	2✔
107
108	// ---[---)----[---)--- +
109	// ------[--------)---- =
110	// ---[------------)---
111	test_range.insert(0, 10, 1);	2✔
112	test_range.insert(20, 10, 1);	2✔
113	test_range.insert(5, 20, 1);	2✔
114
115	result_range.insert(0, 30, 1);	2✔
116	EXPECT_EQ(test_range, result_range);	2✔
117
118	test_range.clear();	2✔
119	result_range.clear();	2✔
120
121	// ---[---)-[)--[---)--- +
122	// --[---------------)-- =
123	// --[---------------)--
124	test_range.insert(0, 10, 1);	2✔
125	test_range.insert(20, 10, 1);	2✔
126	test_range.insert(35, 10, 1);	2✔
127	test_range.insert(-10, 80, 1);	2✔
128
129	result_range.insert(-10, 80, 1);	2✔
130	EXPECT_EQ(test_range, result_range);	2✔
131
132	test_range.clear();	2✔
133	result_range.clear();	2✔
134	}	2✔
135
136	TEST_F(TAddressRangeTest, EmptyIntersectionTest)	8✔
137	{
138	TestPtrAddressRange r1(0, 10), r2(5, 10), result(0, 15);	2✔
139
140	r1 += r2;	2✔
141
142	EXPECT_EQ(r1, result);	2✔
143	}	2✔
144
145	TEST_F(TAddressRangeTest, OperatorTest)	8✔
146	{
147	TestAddressRange r1, r2, r3, result;	2✔
148
149	// basic insert()
150	r1.insert(1, 10, 1);	2✔
151	r2.insert(2, 10, 1);	2✔
152
153	r1.insert(r2);	2✔
154
155	result.insert(1, 11, 1);	2✔
156	EXPECT_EQ(r1, result);	2✔
157
158	r1.clear();	2✔
159	r2.clear();	2✔
160	result.clear();	2✔
161
162	// overloaded operators
163	r1.insert(1, 10, 1);	2✔
164	r2.insert(5, 10, 1);	2✔
165	r3 = r1 + r2;	2✔
166
167	result.insert(1, 14, 1);	2✔
168	EXPECT_EQ(r3, result);	2✔
169
170	r1.clear();	2✔
171	r2.clear();	2✔
172	r3.clear();	2✔
173	result.clear();	2✔
174
175	// different parameters
176	r1.insert(0, 10, 1);	2✔
177	r2.insert(10, 10, 2);	2✔
178	r3.insert(20, 10, 3);	2✔
179
180	r1 += r2 + r3;	2✔
181	r2 += r1;	2✔
182
183	EXPECT_EQ(r1, r2);	2✔
184	}	2✔
185
186	TEST_F(TAddressRangeTest, InRangeTest)	8✔
187	{
188	TestAddressRange r1, r2;	2✔
189
190	r1.insert(0, 10, 1);	2✔
191	r2.insert(10, 10, 2);	2✔
192
193	r1 += r2;	2✔
194
195	EXPECT_EQ(r1.inRange(0), true);	2✔
196	EXPECT_EQ(r1.inRange(20), false);	2✔
197	EXPECT_EQ(r1.inRange(1, 5), true);	2✔
198	EXPECT_EQ(r1.inRange(4), true);	2✔
199	EXPECT_EQ(r1.inRange(15, 3), true);	2✔
200	EXPECT_EQ(r1.inRange(10), true);	2✔
201	EXPECT_EQ(r1.inRange(-15, 5), false);	2✔
202	EXPECT_EQ(r1.inRange(21), false);	2✔
203	EXPECT_EQ(r1.inRange(8, 4), false);	2✔
204	}	2✔
205
206	TEST_F(TAddressRangeTest, GetParamTest)	8✔
207	{
208	TestAddressRange r1(0, 10, 1), r2(10, 10, 2), r3(100, 25, -1);	2✔
209
210	r1 += r2 + r3;	2✔
211
212	EXPECT_EQ(r1.getParam(0), 1);	2✔
213	EXPECT_EQ(r1.getParam(10), 2);	2✔
214	EXPECT_EQ(r1.getParam(100), -1);	2✔
215	EXPECT_EQ(r1.getParam(9), 1);	2✔
216
217	EXPECT_THROW(r1.getParam(20), WrongSegmentException);	2✔
218	EXPECT_THROW(r1.getParam(8, 4), WrongSegmentException);	2✔
219	EXPECT_THROW(r1.getParam(0, 11), WrongSegmentException);	2✔
220	}	2✔
221
222	TEST_F(TAddressRangeTest, InsertFailureTest)	8✔
223	{
224	TestAddressRange r(0, 20, 1);	2✔
225
226	EXPECT_THROW(r + TestAddressRange(10, 20, 2), WrongSegmentException);	4✔
227	EXPECT_THROW(r.insert(10, 20, 2), WrongSegmentException);	2✔
228	EXPECT_THROW(TestAddressRange(2, 1, 1) + TestAddressRange(0, 15, 2), WrongSegmentException);	6✔
229	}	2✔
230
231	TEST_F(TAddressRangeTest, DiffIntersectionTest)	8✔
232	{
233	TestAddressRange test_range;	2✔
234	TestAddressRange result_range;	2✔
235
236	test_range.insert(0, 1, 1);	2✔
237	test_range.insert(1, 1, 2);	2✔
238	}	2✔
239
240	TEST_F(TAddressRangeTest, MultiSegmentsTest)	8✔
241	{
242	TestAddressRange r, r1, r2, r3, r4, r5;	2✔
243
244	r1 = TestAddressRange(0, 5, 1);	2✔
245	r2 = TestAddressRange(5, 5, 2);	2✔
246	r3 = TestAddressRange(10, 5, 1);	2✔
247	r4 = TestAddressRange(15, 5, 3);	2✔
248
249	r5 = TestAddressRange(40, 5, 1);	2✔
250
251	r = r1 + r2 + r3 + r4 + r5;	2✔
252	auto list1 = r.getSegments(1, 14);	2✔
253	EXPECT_THAT(list1, ElementsAre(TestAddressRange(1, 4, 1), r2, TestAddressRange(10, 5, 1)));	2✔
254
255	try {
256	auto list2 = r.getSegments(4, 2);	2✔
257	EXPECT_THAT(list2, ElementsAre(TestAddressRange(4, 1, 1), TestAddressRange(5, 1, 2)));	2✔
258	} catch (const WrongSegmentException& e) {	2✔
259	cerr << e.what() << endl;	×
260	}	×
261
262	EXPECT_THROW(r.getSegments(13, 40), WrongSegmentException);	2✔
263	}	2✔
264
265	TEST_F(TAddressRangeTest, ShiftTest)	8✔
266	{
267	TestAddressRange r(0, 10, 1);	2✔
268	r += TestAddressRange(40, 10, 2);	2✔
269	TestAddressRange r2 = r + 10;	2✔
270
271	TestAddressRange result1(10, 10, 1);	2✔
272	result1.insert(50, 10, 2);	2✔
273
274	EXPECT_EQ(r2, result1);	2✔
275
276	r2 -= 10;	2✔
277	EXPECT_EQ(r, r2);	2✔
278	}	2✔

wirenboard / wb-mqtt-mbgate / 79

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