GCC Code Coverage Report | |||||||||||||||||||||
|
|||||||||||||||||||||
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 |
Generated by: GCOVR (Version 4.2) |