GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: test/zserio/SpanTest.cpp Lines: 210 210 100.0 %
Date: 2023-12-13 14:51:09 Branches: 458 1464 31.3 %

Line Branch Exec Source
1
#include "gtest/gtest.h"
2
3
#include "zserio/Span.h"
4
5
#include <array>
6
#include <vector>
7
8
namespace zserio
9
{
10
11


802
TEST(SpanTest, EmptyConstructor)
12
{
13
1
    Span<int, 0> span;
14



1
    ASSERT_TRUE(span.empty());
15
16
1
    Span<int> spanDyn;
17



1
    ASSERT_TRUE(spanDyn.empty());
18
}
19
20


802
TEST(SpanTest, PtrCntConstructor)
21
{
22
2
    std::vector<int> vec = { 0, 13, 42, 666 };
23
1
    Span<int> span(vec.data(), vec.size());
24



1
    ASSERT_EQ(vec.size(), span.size());
25



1
    ASSERT_EQ(vec.data(), span.data());
26
27
1
    Span<int, 4> spanStatic(vec.data(), vec.size());
28



1
    ASSERT_EQ(vec.size(), spanStatic.size());
29



1
    ASSERT_EQ(vec.data(), spanStatic.data());
30
}
31
32


802
TEST(SpanTest, PtrPtrConstructor)
33
{
34
2
    std::vector<int> vec = { 0, 13, 42, 666 };
35
1
    Span<int> span(vec.data(), vec.data() + vec.size());
36



1
    ASSERT_EQ(vec.size(), span.size());
37



1
    ASSERT_EQ(vec.data(), span.data());
38
39
1
    Span<int, 4> spanStatic(vec.data(), vec.data() + vec.size());
40



1
    ASSERT_EQ(vec.size(), spanStatic.size());
41



1
    ASSERT_EQ(vec.data(), spanStatic.data());
42
}
43
44


802
TEST(SpanTest, ArrayConstructor)
45
{
46
1
    int arr[] = { 0, 13, 42 };
47
1
    Span<int> span(arr);
48



1
    ASSERT_EQ(3, span.size());
49



1
    ASSERT_EQ(&arr[0], span.data());
50
51
1
    Span<int, 3> spanStatic(arr);
52



1
    ASSERT_EQ(3, spanStatic.size());
53



1
    ASSERT_EQ(&arr[0], spanStatic.data());
54
}
55
56


802
TEST(SpanTest, StdArrayConstructor)
57
{
58
1
    std::array<int, 3> arr = { 0, 13, 42 };
59
1
    Span<int> span(arr);
60



1
    ASSERT_EQ(arr.size(), span.size());
61



1
    ASSERT_EQ(arr.data(), span.data());
62
63
1
    Span<int, 3> spanStatic(arr);
64



1
    ASSERT_EQ(arr.size(), spanStatic.size());
65



1
    ASSERT_EQ(arr.data(), spanStatic.data());
66
}
67
68


802
TEST(SpanTest, ConstStdArrayConstructor)
69
{
70
1
    const std::array<int, 3> arr = { 0, 13, 42 };
71
1
    Span<const int> span(arr);
72



1
    ASSERT_EQ(arr.size(), span.size());
73



1
    ASSERT_EQ(arr.data(), span.data());
74
75
1
    Span<const int, 3> spanStatic(arr);
76



1
    ASSERT_EQ(arr.size(), spanStatic.size());
77



1
    ASSERT_EQ(arr.data(), spanStatic.data());
78
}
79
80


802
TEST(SpanTest, VectorConstructor)
81
{
82
2
    std::vector<int> vec = { 0, 13, 42 };
83
1
    Span<int> span(vec);
84



1
    ASSERT_EQ(vec.size(), span.size());
85



1
    ASSERT_EQ(vec.data(), span.data());
86
}
87
88


802
TEST(SpanTest, ConstVectorConstructor)
89
{
90
2
    const std::vector<int> vec = { 0, 13, 42 };
91
1
    Span<const int> span(vec);
92



1
    ASSERT_EQ(vec.size(), span.size());
93



1
    ASSERT_EQ(vec.data(), span.data());
94
}
95
96


802
TEST(SpanTest, SpanConstructor)
97
{
98
2
    std::vector<int> vec = { 0, 13, 42 };
99
1
    Span<int> span(vec);
100



1
    ASSERT_EQ(vec.size(), span.size());
101



1
    ASSERT_EQ(vec.data(), span.data());
102
103
1
    Span<const int> spanConst(span);
104



1
    ASSERT_EQ(span.size(), spanConst.size());
105



1
    ASSERT_EQ(span.data(), spanConst.data());
106
107
1
    Span<int, 3> spanStatic(vec.data(), vec.size());
108



1
    ASSERT_EQ(vec.size(), spanStatic.size());
109



1
    ASSERT_EQ(vec.data(), spanStatic.data());
110
111
1
    Span<const int, 3> constSpanStatic(spanStatic);
112



1
    ASSERT_EQ(spanStatic.size(), constSpanStatic.size());
113



1
    ASSERT_EQ(spanStatic.data(), constSpanStatic.data());
114
}
115
116


802
TEST(SpanTest, BeginEnd)
117
{
118
2
    std::vector<int> vec = { 0, 13, 42 };
119
1
    Span<int> span(vec);
120
121
1
    auto itVec = vec.begin();
122
4
    for (auto it = span.begin(); it != span.end(); ++it, ++itVec)
123
    {
124



3
        ASSERT_EQ(*itVec, *it);
125
    }
126
127
1
    Span<int, 3> spanStatic(vec.data(), 3);
128
1
    itVec = vec.begin();
129

4
    for (auto it = spanStatic.begin(); it != spanStatic.end(); ++it, ++itVec)
130
    {
131



3
        ASSERT_EQ(*itVec, *it);
132
    }
133
}
134
135


802
TEST(SpanTest, RbeginRend)
136
{
137
2
    std::vector<int> vec = { 0, 13, 42 };
138
1
    Span<int> span(vec);
139
140
1
    auto itVec = vec.rbegin();
141

4
    for (auto it = span.rbegin(); it != span.rend(); ++it, ++itVec)
142
    {
143



3
        ASSERT_EQ(*itVec, *it);
144
    }
145
146
1
    Span<int, 3> spanStatic(vec.data(), 3);
147
1
    itVec = vec.rbegin();
148

4
    for (auto it = spanStatic.rbegin(); it != spanStatic.rend(); ++it, ++itVec)
149
    {
150



3
        ASSERT_EQ(*itVec, *it);
151
    }
152
}
153
154


802
TEST(SpanTest, Front)
155
{
156
2
    std::vector<int> vec = { 13, 42 };
157
1
    Span<int> span(vec);
158



1
    ASSERT_EQ(vec.front(), span.front());
159
160
1
    Span<int, 2> spanStatic(vec.data(), 2);
161



1
    ASSERT_EQ(vec.front(), spanStatic.front());
162
}
163
164


802
TEST(SpanTest, Back)
165
{
166
2
    std::vector<int> vec = { 13, 42 };
167
1
    Span<int> span(vec);
168



1
    ASSERT_EQ(vec.back(), span.back());
169
170
1
    Span<int, 2> spanStatic(vec.data(), 2);
171



1
    ASSERT_EQ(vec.back(), spanStatic.back());
172
}
173
174


802
TEST(SpanTest, ArrayAccess)
175
{
176
2
    std::vector<int> vec = { 13, 42, 666 };
177
1
    Span<int> span(vec);
178
179
4
    for (size_t i = 0; i < span.size(); ++i)
180
    {
181



3
        ASSERT_EQ(vec[i], span[i]);
182
    }
183
184
1
    Span<int, 3> spanStatic(vec.data(), 3);
185
186

4
    for (size_t i = 0; i < spanStatic.size(); ++i)
187
    {
188



3
        ASSERT_EQ(vec[i], spanStatic[i]);
189
    }
190
}
191
192


802
TEST(SpanTest, Data)
193
{
194
2
    std::vector<int> vec = { 13, 42, 666 };
195
1
    Span<int> span(vec);
196



1
    ASSERT_EQ(vec.data(), span.data());
197
198
1
    Span<int, 3> spanStatic(vec.data(), 3);
199



1
    ASSERT_EQ(vec.data(), spanStatic.data());
200
}
201
202


802
TEST(SpanTest, Size)
203
{
204
2
    std::vector<int> vec = { 13, 42, 666 };
205
1
    Span<int> span(vec);
206



1
    ASSERT_EQ(vec.size(), span.size());
207
208
1
    Span<int, 3> spanStatic(vec.data(), 3);
209



1
    ASSERT_EQ(vec.size(), spanStatic.size());
210
}
211
212


802
TEST(SpanTest, SizeBytes)
213
{
214
2
    std::vector<int> vec = { 13, 42, 666 };
215
1
    Span<int> span(vec);
216



1
    ASSERT_EQ(vec.size() * sizeof(int), span.size_bytes());
217
218
1
    Span<int, 3> spanStatic(vec.data(), 3);
219



1
    ASSERT_EQ(vec.size() * sizeof(int), spanStatic.size_bytes());
220
}
221
222


802
TEST(SpanTest, Empty)
223
{
224
2
    std::vector<int> vec = { 13, 42, 666 };
225
1
    Span<int> span(vec);
226
1
    Span<int> emptySpan;
227



1
    ASSERT_FALSE(span.empty());
228



1
    ASSERT_TRUE(emptySpan.empty());
229
230
1
    Span<int, 3> spanStatic(vec.data(), 3);
231
1
    Span<int, 0> emptySpanStatic;
232



1
    ASSERT_FALSE(spanStatic.empty());
233



1
    ASSERT_TRUE(emptySpanStatic.empty());
234
}
235
236


802
TEST(SpanTest, staticFirst)
237
{
238
2
    std::vector<int> vec = { 13, 42, 666 };
239
1
    Span<int> span(vec);
240
1
    Span<int, 2> spanFirst = span.first<2>();
241



1
    ASSERT_EQ(2, spanFirst.size());
242



1
    ASSERT_TRUE(std::equal(span.begin(), span.end() - 1, spanFirst.begin()));
243
244
1
    Span<int, 3> spanStatic(vec.data(), 3);
245
1
    Span<int, 2> spanFirstStatic = spanStatic.first<2>();
246



1
    ASSERT_EQ(2, spanFirstStatic.size());
247




1
    ASSERT_TRUE(std::equal(spanStatic.begin(), spanStatic.end() - 1, spanFirstStatic.begin()));
248
}
249
250


802
TEST(SpanTest, first)
251
{
252
2
    std::vector<int> vec = { 13, 42, 666 };
253
1
    Span<int> span(vec);
254
1
    Span<int> spanFirst = span.first(2);
255



1
    ASSERT_EQ(2, spanFirst.size());
256



1
    ASSERT_TRUE(std::equal(span.begin(), span.end() - 1, spanFirst.begin()));
257
258
1
    Span<int, 3> spanStatic(vec.data(), 3);
259
1
    Span<int> spanFirstStatic = spanStatic.first(2);
260



1
    ASSERT_EQ(2, spanFirstStatic.size());
261




1
    ASSERT_TRUE(std::equal(spanStatic.begin(), spanStatic.end() - 1, spanFirstStatic.begin()));
262
}
263
264


802
TEST(SpanTest, staticLast)
265
{
266
2
    std::vector<int> vec = { 13, 42, 666 };
267
1
    Span<int> span(vec);
268
1
    Span<int, 2> spanLast = span.last<2>();
269



1
    ASSERT_EQ(2, spanLast.size());
270



1
    ASSERT_TRUE(std::equal(span.begin() + 1, span.end(), spanLast.begin()));
271
272
1
    Span<int, 3> spanStatic(vec.data(), 3);
273
1
    Span<int, 2> spanLastStatic = spanStatic.last<2>();
274



1
    ASSERT_EQ(2, spanLastStatic.size());
275




1
    ASSERT_TRUE(std::equal(spanStatic.begin() + 1, spanStatic.end(), spanLastStatic.begin()));
276
}
277
278


802
TEST(SpanTest, last)
279
{
280
2
    std::vector<int> vec = { 13, 42, 666 };
281
1
    Span<int> span(vec);
282
1
    Span<int> spanLast = span.last(2);
283



1
    ASSERT_EQ(2, spanLast.size());
284



1
    ASSERT_TRUE(std::equal(span.begin() + 1, span.end(), spanLast.begin()));
285
286
1
    Span<int, 3> spanStatic(vec.data(), 3);
287
1
    Span<int> spanLastStatic = spanStatic.last(2);
288



1
    ASSERT_EQ(2, spanLastStatic.size());
289




1
    ASSERT_TRUE(std::equal(spanStatic.begin() + 1, spanStatic.end(), spanLastStatic.begin()));
290
}
291
292


802
TEST(SpanTest, staticSubspan)
293
{
294
2
    std::vector<int> vec = { 0, 13, 42, 666, 13 };
295
1
    Span<int> span(vec);
296
1
    Span<int> spanSub1 = span.subspan<1>();
297



1
    ASSERT_EQ(4, spanSub1.size());
298



1
    ASSERT_TRUE(std::equal(span.begin() + 1, span.begin() + 5, spanSub1.begin()));
299
300
1
    Span<int> spanSub2 = span.subspan<1, 3>();
301



1
    ASSERT_EQ(3, spanSub2.size());
302



1
    ASSERT_TRUE(std::equal(span.begin() + 1, span.begin() + 4, spanSub2.begin()));
303
304
1
    Span<int, 5> spanStatic(vec.data(), 3);
305
1
    Span<int> spanSubStatic1 = spanStatic.subspan<1>();
306



1
    ASSERT_EQ(4, spanSubStatic1.size());
307



1
    ASSERT_TRUE(std::equal(spanStatic.begin() + 1, spanStatic.begin() + 5, spanSubStatic1.begin()));
308
309
1
    Span<int, 3> spanSubStatic2 = spanStatic.subspan<1, 3>();
310



1
    ASSERT_EQ(3, spanSubStatic2.size());
311




1
    ASSERT_TRUE(std::equal(spanStatic.begin() + 1, spanStatic.begin() + 4, spanSubStatic2.begin()));
312
}
313
314


802
TEST(SpanTest, subspan)
315
{
316
2
    std::vector<int> vec = { 0, 13, 42, 666, 13 };
317
1
    Span<int> span(vec);
318
1
    Span<int> spanSubDyn1 = span.subspan(1);
319



1
    ASSERT_EQ(4, spanSubDyn1.size());
320



1
    ASSERT_TRUE(std::equal(span.begin() + 1, span.begin() + 5, spanSubDyn1.begin()));
321
322
1
    Span<int> spanSubDyn2 = span.subspan(1, 3);
323



1
    ASSERT_EQ(3, spanSubDyn2.size());
324



1
    ASSERT_TRUE(std::equal(span.begin() + 1, span.begin() + 4, spanSubDyn2.begin()));
325
326
1
    Span<int, 5> spanStatic(vec.data(), 3);
327
1
    Span<int> spanSubStatic1 = spanStatic.subspan(1);
328



1
    ASSERT_EQ(4, spanSubStatic1.size());
329



1
    ASSERT_TRUE(std::equal(spanStatic.begin() + 1, spanStatic.begin() + 5, spanSubStatic1.begin()));
330
331
1
    Span<int> spanSubStatic2 = spanStatic.subspan(1, 3);
332



1
    ASSERT_EQ(3, spanSubStatic2.size());
333




1
    ASSERT_TRUE(std::equal(spanStatic.begin() + 1, spanStatic.begin() + 4, spanSubStatic2.begin()));
334
}
335
336

2394
} // namespace zserio
337