Coverage Report

Created: 2024-04-30 09:35

test/zserio/SpanTest.cpp
Line
Count
Source
1
#include <array>
2
#include <vector>
3
4
#include "gtest/gtest.h"
5
#include "zserio/Span.h"
6
7
namespace zserio
8
{
9
10
TEST(SpanTest, EmptyConstructor)
11
1
{
12
1
    Span<int, 0> span;
13
1
    ASSERT_TRUE(span.empty());
14
15
1
    Span<int> spanDyn;
16
1
    ASSERT_TRUE(spanDyn.empty());
17
1
}
18
19
TEST(SpanTest, PtrCntConstructor)
20
1
{
21
1
    std::vector<int> vec = {0, 13, 42, 666};
22
1
    Span<int> span(vec.data(), vec.size());
23
1
    ASSERT_EQ(vec.size(), span.size());
24
1
    ASSERT_EQ(vec.data(), span.data());
25
26
1
    Span<int, 4> spanStatic(vec.data(), vec.size());
27
1
    ASSERT_EQ(vec.size(), spanStatic.size());
28
1
    ASSERT_EQ(vec.data(), spanStatic.data());
29
1
}
30
31
TEST(SpanTest, PtrPtrConstructor)
32
1
{
33
1
    std::vector<int> vec = {0, 13, 42, 666};
34
1
    Span<int> span(vec.data(), vec.data() + vec.size());
35
1
    ASSERT_EQ(vec.size(), span.size());
36
1
    ASSERT_EQ(vec.data(), span.data());
37
38
1
    Span<int, 4> spanStatic(vec.data(), vec.data() + vec.size());
39
1
    ASSERT_EQ(vec.size(), spanStatic.size());
40
1
    ASSERT_EQ(vec.data(), spanStatic.data());
41
1
}
42
43
TEST(SpanTest, ArrayConstructor)
44
1
{
45
1
    int arr[] = {0, 13, 42};
46
1
    Span<int> span(arr);
47
1
    ASSERT_EQ(3, span.size());
48
1
    ASSERT_EQ(&arr[0], span.data());
49
50
1
    Span<int, 3> spanStatic(arr);
51
1
    ASSERT_EQ(3, spanStatic.size());
52
1
    ASSERT_EQ(&arr[0], spanStatic.data());
53
1
}
54
55
TEST(SpanTest, StdArrayConstructor)
56
1
{
57
1
    std::array<int, 3> arr = {0, 13, 42};
58
1
    Span<int> span(arr);
59
1
    ASSERT_EQ(arr.size(), span.size());
60
1
    ASSERT_EQ(arr.data(), span.data());
61
62
1
    Span<int, 3> spanStatic(arr);
63
1
    ASSERT_EQ(arr.size(), spanStatic.size());
64
1
    ASSERT_EQ(arr.data(), spanStatic.data());
65
1
}
66
67
TEST(SpanTest, ConstStdArrayConstructor)
68
1
{
69
1
    const std::array<int, 3> arr = {0, 13, 42};
70
1
    Span<const int> span(arr);
71
1
    ASSERT_EQ(arr.size(), span.size());
72
1
    ASSERT_EQ(arr.data(), span.data());
73
74
1
    Span<const int, 3> spanStatic(arr);
75
1
    ASSERT_EQ(arr.size(), spanStatic.size());
76
1
    ASSERT_EQ(arr.data(), spanStatic.data());
77
1
}
78
79
TEST(SpanTest, VectorConstructor)
80
1
{
81
1
    std::vector<int> vec = {0, 13, 42};
82
1
    Span<int> span(vec);
83
1
    ASSERT_EQ(vec.size(), span.size());
84
1
    ASSERT_EQ(vec.data(), span.data());
85
1
}
86
87
TEST(SpanTest, ConstVectorConstructor)
88
1
{
89
1
    const std::vector<int> vec = {0, 13, 42};
90
1
    Span<const int> span(vec);
91
1
    ASSERT_EQ(vec.size(), span.size());
92
1
    ASSERT_EQ(vec.data(), span.data());
93
1
}
94
95
TEST(SpanTest, SpanConstructor)
96
1
{
97
1
    std::vector<int> vec = {0, 13, 42};
98
1
    Span<int> span(vec);
99
1
    ASSERT_EQ(vec.size(), span.size());
100
1
    ASSERT_EQ(vec.data(), span.data());
101
102
1
    Span<const int> spanConst(span);
103
1
    ASSERT_EQ(span.size(), spanConst.size());
104
1
    ASSERT_EQ(span.data(), spanConst.data());
105
106
1
    Span<int, 3> spanStatic(vec.data(), vec.size());
107
1
    ASSERT_EQ(vec.size(), spanStatic.size());
108
1
    ASSERT_EQ(vec.data(), spanStatic.data());
109
110
1
    Span<const int, 3> constSpanStatic(spanStatic);
111
1
    ASSERT_EQ(spanStatic.size(), constSpanStatic.size());
112
1
    ASSERT_EQ(spanStatic.data(), constSpanStatic.data());
113
1
}
114
115
TEST(SpanTest, BeginEnd)
116
1
{
117
1
    std::vector<int> vec = {0, 13, 42};
118
1
    Span<int> span(vec);
119
120
1
    auto itVec = vec.begin();
121
4
    for (auto it = span.begin(); it != span.end(); 
++it, ++itVec3
)
122
3
    {
123
3
        ASSERT_EQ(*itVec, *it);
124
3
    }
125
126
1
    Span<int, 3> spanStatic(vec.data(), 3);
127
1
    itVec = vec.begin();
128
4
    for (auto it = spanStatic.begin(); it != spanStatic.end(); 
++it, ++itVec3
)
129
3
    {
130
3
        ASSERT_EQ(*itVec, *it);
131
3
    }
132
1
}
133
134
TEST(SpanTest, RbeginRend)
135
1
{
136
1
    std::vector<int> vec = {0, 13, 42};
137
1
    Span<int> span(vec);
138
139
1
    auto itVec = vec.rbegin();
140
4
    for (auto it = span.rbegin(); it != span.rend(); 
++it, ++itVec3
)
141
3
    {
142
3
        ASSERT_EQ(*itVec, *it);
143
3
    }
144
145
1
    Span<int, 3> spanStatic(vec.data(), 3);
146
1
    itVec = vec.rbegin();
147
4
    for (auto it = spanStatic.rbegin(); it != spanStatic.rend(); 
++it, ++itVec3
)
148
3
    {
149
3
        ASSERT_EQ(*itVec, *it);
150
3
    }
151
1
}
152
153
TEST(SpanTest, Front)
154
1
{
155
1
    std::vector<int> vec = {13, 42};
156
1
    Span<int> span(vec);
157
1
    ASSERT_EQ(vec.front(), span.front());
158
159
1
    Span<int, 2> spanStatic(vec.data(), 2);
160
1
    ASSERT_EQ(vec.front(), spanStatic.front());
161
1
}
162
163
TEST(SpanTest, Back)
164
1
{
165
1
    std::vector<int> vec = {13, 42};
166
1
    Span<int> span(vec);
167
1
    ASSERT_EQ(vec.back(), span.back());
168
169
1
    Span<int, 2> spanStatic(vec.data(), 2);
170
1
    ASSERT_EQ(vec.back(), spanStatic.back());
171
1
}
172
173
TEST(SpanTest, ArrayAccess)
174
1
{
175
1
    std::vector<int> vec = {13, 42, 666};
176
1
    Span<int> span(vec);
177
178
4
    for (size_t i = 0; i < span.size(); 
++i3
)
179
3
    {
180
3
        ASSERT_EQ(vec[i], span[i]);
181
3
    }
182
183
1
    Span<int, 3> spanStatic(vec.data(), 3);
184
185
4
    for (size_t i = 0; i < spanStatic.size(); 
++i3
)
186
3
    {
187
3
        ASSERT_EQ(vec[i], spanStatic[i]);
188
3
    }
189
1
}
190
191
TEST(SpanTest, Data)
192
1
{
193
1
    std::vector<int> vec = {13, 42, 666};
194
1
    Span<int> span(vec);
195
1
    ASSERT_EQ(vec.data(), span.data());
196
197
1
    Span<int, 3> spanStatic(vec.data(), 3);
198
1
    ASSERT_EQ(vec.data(), spanStatic.data());
199
1
}
200
201
TEST(SpanTest, Size)
202
1
{
203
1
    std::vector<int> vec = {13, 42, 666};
204
1
    Span<int> span(vec);
205
1
    ASSERT_EQ(vec.size(), span.size());
206
207
1
    Span<int, 3> spanStatic(vec.data(), 3);
208
1
    ASSERT_EQ(vec.size(), spanStatic.size());
209
1
}
210
211
TEST(SpanTest, SizeBytes)
212
1
{
213
1
    std::vector<int> vec = {13, 42, 666};
214
1
    Span<int> span(vec);
215
1
    ASSERT_EQ(vec.size() * sizeof(int), span.size_bytes());
216
217
1
    Span<int, 3> spanStatic(vec.data(), 3);
218
1
    ASSERT_EQ(vec.size() * sizeof(int), spanStatic.size_bytes());
219
1
}
220
221
TEST(SpanTest, Empty)
222
1
{
223
1
    std::vector<int> vec = {13, 42, 666};
224
1
    Span<int> span(vec);
225
1
    Span<int> emptySpan;
226
1
    ASSERT_FALSE(span.empty());
227
1
    ASSERT_TRUE(emptySpan.empty());
228
229
1
    Span<int, 3> spanStatic(vec.data(), 3);
230
1
    Span<int, 0> emptySpanStatic;
231
1
    ASSERT_FALSE(spanStatic.empty());
232
1
    ASSERT_TRUE(emptySpanStatic.empty());
233
1
}
234
235
TEST(SpanTest, staticFirst)
236
1
{
237
1
    std::vector<int> vec = {13, 42, 666};
238
1
    Span<int> span(vec);
239
1
    Span<int, 2> spanFirst = span.first<2>();
240
1
    ASSERT_EQ(2, spanFirst.size());
241
1
    ASSERT_TRUE(std::equal(span.begin(), span.end() - 1, spanFirst.begin()));
242
243
1
    Span<int, 3> spanStatic(vec.data(), 3);
244
1
    Span<int, 2> spanFirstStatic = spanStatic.first<2>();
245
1
    ASSERT_EQ(2, spanFirstStatic.size());
246
1
    ASSERT_TRUE(std::equal(spanStatic.begin(), spanStatic.end() - 1, spanFirstStatic.begin()));
247
1
}
248
249
TEST(SpanTest, first)
250
1
{
251
1
    std::vector<int> vec = {13, 42, 666};
252
1
    Span<int> span(vec);
253
1
    Span<int> spanFirst = span.first(2);
254
1
    ASSERT_EQ(2, spanFirst.size());
255
1
    ASSERT_TRUE(std::equal(span.begin(), span.end() - 1, spanFirst.begin()));
256
257
1
    Span<int, 3> spanStatic(vec.data(), 3);
258
1
    Span<int> spanFirstStatic = spanStatic.first(2);
259
1
    ASSERT_EQ(2, spanFirstStatic.size());
260
1
    ASSERT_TRUE(std::equal(spanStatic.begin(), spanStatic.end() - 1, spanFirstStatic.begin()));
261
1
}
262
263
TEST(SpanTest, staticLast)
264
1
{
265
1
    std::vector<int> vec = {13, 42, 666};
266
1
    Span<int> span(vec);
267
1
    Span<int, 2> spanLast = span.last<2>();
268
1
    ASSERT_EQ(2, spanLast.size());
269
1
    ASSERT_TRUE(std::equal(span.begin() + 1, span.end(), spanLast.begin()));
270
271
1
    Span<int, 3> spanStatic(vec.data(), 3);
272
1
    Span<int, 2> spanLastStatic = spanStatic.last<2>();
273
1
    ASSERT_EQ(2, spanLastStatic.size());
274
1
    ASSERT_TRUE(std::equal(spanStatic.begin() + 1, spanStatic.end(), spanLastStatic.begin()));
275
1
}
276
277
TEST(SpanTest, last)
278
1
{
279
1
    std::vector<int> vec = {13, 42, 666};
280
1
    Span<int> span(vec);
281
1
    Span<int> spanLast = span.last(2);
282
1
    ASSERT_EQ(2, spanLast.size());
283
1
    ASSERT_TRUE(std::equal(span.begin() + 1, span.end(), spanLast.begin()));
284
285
1
    Span<int, 3> spanStatic(vec.data(), 3);
286
1
    Span<int> spanLastStatic = spanStatic.last(2);
287
1
    ASSERT_EQ(2, spanLastStatic.size());
288
1
    ASSERT_TRUE(std::equal(spanStatic.begin() + 1, spanStatic.end(), spanLastStatic.begin()));
289
1
}
290
291
TEST(SpanTest, staticSubspan)
292
1
{
293
1
    std::vector<int> vec = {0, 13, 42, 666, 13};
294
1
    Span<int> span(vec);
295
1
    Span<int> spanSub1 = span.subspan<1>();
296
1
    ASSERT_EQ(4, spanSub1.size());
297
1
    ASSERT_TRUE(std::equal(span.begin() + 1, span.begin() + 5, spanSub1.begin()));
298
299
1
    Span<int> spanSub2 = span.subspan<1, 3>();
300
1
    ASSERT_EQ(3, spanSub2.size());
301
1
    ASSERT_TRUE(std::equal(span.begin() + 1, span.begin() + 4, spanSub2.begin()));
302
303
1
    Span<int, 5> spanStatic(vec.data(), 3);
304
1
    Span<int> spanSubStatic1 = spanStatic.subspan<1>();
305
1
    ASSERT_EQ(4, spanSubStatic1.size());
306
1
    ASSERT_TRUE(std::equal(spanStatic.begin() + 1, spanStatic.begin() + 5, spanSubStatic1.begin()));
307
308
1
    Span<int, 3> spanSubStatic2 = spanStatic.subspan<1, 3>();
309
1
    ASSERT_EQ(3, spanSubStatic2.size());
310
1
    ASSERT_TRUE(std::equal(spanStatic.begin() + 1, spanStatic.begin() + 4, spanSubStatic2.begin()));
311
1
}
312
313
TEST(SpanTest, subspan)
314
1
{
315
1
    std::vector<int> vec = {0, 13, 42, 666, 13};
316
1
    Span<int> span(vec);
317
1
    Span<int> spanSubDyn1 = span.subspan(1);
318
1
    ASSERT_EQ(4, spanSubDyn1.size());
319
1
    ASSERT_TRUE(std::equal(span.begin() + 1, span.begin() + 5, spanSubDyn1.begin()));
320
321
1
    Span<int> spanSubDyn2 = span.subspan(1, 3);
322
1
    ASSERT_EQ(3, spanSubDyn2.size());
323
1
    ASSERT_TRUE(std::equal(span.begin() + 1, span.begin() + 4, spanSubDyn2.begin()));
324
325
1
    Span<int, 5> spanStatic(vec.data(), 3);
326
1
    Span<int> spanSubStatic1 = spanStatic.subspan(1);
327
1
    ASSERT_EQ(4, spanSubStatic1.size());
328
1
    ASSERT_TRUE(std::equal(spanStatic.begin() + 1, spanStatic.begin() + 5, spanSubStatic1.begin()));
329
330
1
    Span<int> spanSubStatic2 = spanStatic.subspan(1, 3);
331
1
    ASSERT_EQ(3, spanSubStatic2.size());
332
1
    ASSERT_TRUE(std::equal(spanStatic.begin() + 1, spanStatic.begin() + 4, spanSubStatic2.begin()));
333
1
}
334
335
} // namespace zserio