Coverage Report

Created: 2023-12-13 14:58

test/zserio/SpanTest.cpp
Line
Count
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
TEST(SpanTest, EmptyConstructor)
12
1
{
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
1
}
19
20
TEST(SpanTest, PtrCntConstructor)
21
1
{
22
1
    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
1
}
31
32
TEST(SpanTest, PtrPtrConstructor)
33
1
{
34
1
    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
1
}
43
44
TEST(SpanTest, ArrayConstructor)
45
1
{
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
1
}
55
56
TEST(SpanTest, StdArrayConstructor)
57
1
{
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
1
}
67
68
TEST(SpanTest, ConstStdArrayConstructor)
69
1
{
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
1
}
79
80
TEST(SpanTest, VectorConstructor)
81
1
{
82
1
    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
1
}
87
88
TEST(SpanTest, ConstVectorConstructor)
89
1
{
90
1
    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
1
}
95
96
TEST(SpanTest, SpanConstructor)
97
1
{
98
1
    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
1
}
115
116
TEST(SpanTest, BeginEnd)
117
1
{
118
1
    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, ++itVec3
)
123
3
    {
124
3
        ASSERT_EQ(*itVec, *it);
125
3
    }
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, ++itVec3
)
130
3
    {
131
3
        ASSERT_EQ(*itVec, *it);
132
3
    }
133
1
}
134
135
TEST(SpanTest, RbeginRend)
136
1
{
137
1
    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, ++itVec3
)
142
3
    {
143
3
        ASSERT_EQ(*itVec, *it);
144
3
    }
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, ++itVec3
)
149
3
    {
150
3
        ASSERT_EQ(*itVec, *it);
151
3
    }
152
1
}
153
154
TEST(SpanTest, Front)
155
1
{
156
1
    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
1
}
163
164
TEST(SpanTest, Back)
165
1
{
166
1
    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
1
}
173
174
TEST(SpanTest, ArrayAccess)
175
1
{
176
1
    std::vector<int> vec = { 13, 42, 666 };
177
1
    Span<int> span(vec);
178
179
4
    for (size_t i = 0; i < span.size(); 
++i3
)
180
3
    {
181
3
        ASSERT_EQ(vec[i], span[i]);
182
3
    }
183
184
1
    Span<int, 3> spanStatic(vec.data(), 3);
185
186
4
    for (size_t i = 0; i < spanStatic.size(); 
++i3
)
187
3
    {
188
3
        ASSERT_EQ(vec[i], spanStatic[i]);
189
3
    }
190
1
}
191
192
TEST(SpanTest, Data)
193
1
{
194
1
    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
1
}
201
202
TEST(SpanTest, Size)
203
1
{
204
1
    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
1
}
211
212
TEST(SpanTest, SizeBytes)
213
1
{
214
1
    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
1
}
221
222
TEST(SpanTest, Empty)
223
1
{
224
1
    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
1
}
235
236
TEST(SpanTest, staticFirst)
237
1
{
238
1
    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
1
}
249
250
TEST(SpanTest, first)
251
1
{
252
1
    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
1
}
263
264
TEST(SpanTest, staticLast)
265
1
{
266
1
    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
1
}
277
278
TEST(SpanTest, last)
279
1
{
280
1
    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
1
}
291
292
TEST(SpanTest, staticSubspan)
293
1
{
294
1
    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
1
}
313
314
TEST(SpanTest, subspan)
315
1
{
316
1
    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
1
}
335
336
} // namespace zserio
337