GCC Code Coverage Report | |||||||||||||||||||||
|
|||||||||||||||||||||
Line | Branch | Exec | Source |
1 |
#include "gtest/gtest.h" |
||
2 |
|||
3 |
#include "zserio/Walker.h" |
||
4 |
#include "zserio/Traits.h" |
||
5 |
#include "zserio/TypeInfo.h" |
||
6 |
#include "zserio/Reflectable.h" |
||
7 |
#include "zserio/Array.h" |
||
8 |
#include "zserio/ArrayTraits.h" |
||
9 |
#include "zserio/BitStreamWriter.h" |
||
10 |
#include "zserio/OptionalHolder.h" |
||
11 |
|||
12 |
#include "test_object/std_allocator/WalkerBitmask.h" |
||
13 |
#include "test_object/std_allocator/WalkerNested.h" |
||
14 |
#include "test_object/std_allocator/WalkerUnion.h" |
||
15 |
#include "test_object/std_allocator/WalkerChoice.h" |
||
16 |
#include "test_object/std_allocator/WalkerObject.h" |
||
17 |
|||
18 |
using test_object::std_allocator::WalkerBitmask; |
||
19 |
using test_object::std_allocator::WalkerNested; |
||
20 |
using test_object::std_allocator::WalkerUnion; |
||
21 |
using test_object::std_allocator::WalkerChoice; |
||
22 |
using test_object::std_allocator::WalkerObject; |
||
23 |
|||
24 |
namespace zserio |
||
25 |
{ |
||
26 |
|||
27 |
namespace |
||
28 |
{ |
||
29 |
|||
30 |
12 |
WalkerObject createWalkerObject(uint32_t identifier = 13, bool createNested = true) |
|
31 |
{ |
||
32 |
24 |
std::vector<WalkerUnion> unionArray; |
|
33 |
✓✗ | 12 |
unionArray.resize(3); |
34 |
✓✗✓✗ |
12 |
unionArray[0].setText("1"); |
35 |
✓✗ | 12 |
unionArray[1].setValue(2); |
36 |
✓✗✓✗ ✓✗✓✓ ✗✗ |
12 |
unionArray[2].setNestedArray(std::vector<WalkerNested>{{WalkerNested{"nestedArray"}}}); |
37 |
12 |
const uint8_t choiceSelector = 0; |
|
38 |
24 |
WalkerChoice choiceField; |
|
39 |
✓✗ | 12 |
choiceField.initialize(choiceSelector); |
40 |
✓✓ | 12 |
if (createNested) |
41 |
{ |
||
42 |
9 |
return WalkerObject(identifier, WalkerNested("nested"), "test", std::move(unionArray), NullOpt, |
|
43 |
✓✗✓✗ |
18 |
choiceSelector, choiceField); |
44 |
} |
||
45 |
else |
||
46 |
{ |
||
47 |
3 |
return WalkerObject(identifier, NullOpt, "test", std::move(unionArray), NullOpt, |
|
48 |
✓✗ | 6 |
choiceSelector, choiceField); |
49 |
} |
||
50 |
} |
||
51 |
|||
52 |
✗✓ | 7 |
class TestWalkObserver : public IWalkObserver |
53 |
{ |
||
54 |
public: |
||
55 |
using CapturesMap = std::map<StringView, std::vector<IReflectableConstPtr>>; |
||
56 |
|||
57 |
7 |
TestWalkObserver() |
|
58 |
7 |
{ |
|
59 |
// initialize empty captures |
||
60 |
✓✗ | 7 |
m_captures["beginRoot"_sv]; |
61 |
✓✗ | 7 |
m_captures["endRoot"_sv]; |
62 |
✓✗ | 7 |
m_captures["beginArray"_sv]; |
63 |
✓✗ | 7 |
m_captures["endArray"_sv]; |
64 |
✓✗ | 7 |
m_captures["beginCompound"_sv]; |
65 |
✓✗ | 7 |
m_captures["endCompound"_sv]; |
66 |
✓✗ | 7 |
m_captures["visitValue"_sv]; |
67 |
7 |
} |
|
68 |
|||
69 |
7 |
void beginRoot(const IReflectableConstPtr& compound) override |
|
70 |
{ |
||
71 |
✓✗✓✗ |
7 |
m_captures["beginRoot"_sv].push_back(compound); |
72 |
7 |
} |
|
73 |
|||
74 |
7 |
void endRoot(const IReflectableConstPtr& compound) override |
|
75 |
{ |
||
76 |
✓✗✓✗ |
7 |
m_captures["endRoot"_sv].push_back(compound); |
77 |
7 |
} |
|
78 |
|||
79 |
6 |
void beginArray(const IReflectableConstPtr& array, const FieldInfo&) override |
|
80 |
{ |
||
81 |
✓✗✓✗ |
6 |
m_captures["beginArray"_sv].push_back(array); |
82 |
6 |
} |
|
83 |
|||
84 |
6 |
void endArray(const IReflectableConstPtr& array, const FieldInfo&) override |
|
85 |
{ |
||
86 |
✓✗✓✗ |
6 |
m_captures["endArray"_sv].push_back(array); |
87 |
6 |
} |
|
88 |
|||
89 |
15 |
void beginCompound(const IReflectableConstPtr& compound, const FieldInfo&, size_t) override |
|
90 |
{ |
||
91 |
✓✗✓✗ |
15 |
m_captures["beginCompound"_sv].push_back(compound); |
92 |
15 |
} |
|
93 |
|||
94 |
15 |
void endCompound(const IReflectableConstPtr& compound, const FieldInfo&, size_t) override |
|
95 |
{ |
||
96 |
✓✗✓✗ |
15 |
m_captures["endCompound"_sv].push_back(compound); |
97 |
15 |
} |
|
98 |
|||
99 |
29 |
void visitValue(const IReflectableConstPtr& value, const FieldInfo&, size_t) override |
|
100 |
{ |
||
101 |
✓✗✓✗ |
29 |
m_captures["visitValue"_sv].push_back(value); |
102 |
29 |
} |
|
103 |
|||
104 |
120 |
const std::vector<IReflectableConstPtr>& getCaptures(StringView captureName) const |
|
105 |
{ |
||
106 |
120 |
return m_captures.find(captureName)->second; |
|
107 |
} |
||
108 |
|||
109 |
private: |
||
110 |
CapturesMap m_captures; |
||
111 |
}; |
||
112 |
|||
113 |
✗✓ | 10 |
class TestWalkFilter : public IWalkFilter |
114 |
{ |
||
115 |
public: |
||
116 |
3 |
TestWalkFilter& beforeArray(bool beforeArray) { m_beforeArray = beforeArray; return *this; } |
|
117 |
3 |
TestWalkFilter& afterArray(bool afterArray) { m_afterArray = afterArray; return *this; } |
|
118 |
1 |
TestWalkFilter& onlyFirstElement(bool onlyFirstElement) |
|
119 |
{ |
||
120 |
1 |
m_onlyFirstElement = onlyFirstElement; return *this; |
|
121 |
} |
||
122 |
4 |
TestWalkFilter& beforeCompound(bool beforeCompound) { m_beforeCompound = beforeCompound; return *this; } |
|
123 |
4 |
TestWalkFilter& afterCompound(bool afterCompound) { m_afterCompound = afterCompound; return *this; } |
|
124 |
3 |
TestWalkFilter& beforeValue(bool beforeValue) { m_beforeValue = beforeValue; return *this; } |
|
125 |
4 |
TestWalkFilter& afterValue(bool afterValue) { m_afterValue = afterValue; return *this; } |
|
126 |
|||
127 |
8 |
bool beforeArray(const IReflectableConstPtr&, const FieldInfo&) override |
|
128 |
{ |
||
129 |
8 |
m_isFirstElement = true; |
|
130 |
8 |
return m_beforeArray; |
|
131 |
} |
||
132 |
|||
133 |
8 |
bool afterArray(const IReflectableConstPtr&, const FieldInfo&) override |
|
134 |
{ |
||
135 |
8 |
m_isFirstElement = false; |
|
136 |
8 |
return m_afterArray; |
|
137 |
} |
||
138 |
|||
139 |
15 |
bool beforeCompound(const IReflectableConstPtr&, const FieldInfo&, size_t) override |
|
140 |
{ |
||
141 |
15 |
return m_beforeCompound; |
|
142 |
} |
||
143 |
|||
144 |
15 |
bool afterCompound(const IReflectableConstPtr&, const FieldInfo&, size_t) override |
|
145 |
{ |
||
146 |
✓✓✓✓ |
15 |
bool goToNext = !(m_onlyFirstElement && m_isFirstElement); |
147 |
15 |
m_isFirstElement = false; |
|
148 |
✓✓✓✓ |
15 |
return goToNext && m_afterCompound; |
149 |
} |
||
150 |
|||
151 |
19 |
bool beforeValue(const IReflectableConstPtr&, const FieldInfo&, size_t) override |
|
152 |
{ |
||
153 |
19 |
return m_beforeValue; |
|
154 |
} |
||
155 |
|||
156 |
19 |
bool afterValue(const IReflectableConstPtr&, const FieldInfo&, size_t) override |
|
157 |
{ |
||
158 |
19 |
return m_afterValue; |
|
159 |
} |
||
160 |
|||
161 |
private: |
||
162 |
bool m_beforeArray = true; |
||
163 |
bool m_afterArray = true; |
||
164 |
bool m_onlyFirstElement = false; |
||
165 |
bool m_beforeCompound = true; |
||
166 |
bool m_afterCompound = true; |
||
167 |
bool m_beforeValue = true; |
||
168 |
bool m_afterValue = true; |
||
169 |
bool m_isFirstElement = false; |
||
170 |
}; |
||
171 |
|||
172 |
} // namespace |
||
173 |
|||
174 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(WalkerTest, walkNull) |
175 |
{ |
||
176 |
2 |
DefaultWalkObserver defaultObserver; |
|
177 |
✓✗ | 2 |
Walker walker(defaultObserver); |
178 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(walker.walk(nullptr), CppRuntimeException); |
179 |
} |
||
180 |
|||
181 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(WalkerTest, walkNonCompound) |
182 |
{ |
||
183 |
2 |
DefaultWalkObserver defaultObserver; |
|
184 |
✓✗ | 2 |
Walker walker(defaultObserver); |
185 |
1 |
WalkerBitmask walkerBitmask; |
|
186 |
|||
187 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(walker.walk(walkerBitmask.reflectable()), CppRuntimeException); |
188 |
} |
||
189 |
|||
190 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(WalkerTest, walk) |
191 |
{ |
||
192 |
✓✗ | 2 |
TestWalkObserver observer; |
193 |
✓✗ | 2 |
DefaultWalkFilter defaultFilter; |
194 |
✓✗ | 2 |
Walker walker(observer, defaultFilter); |
195 |
✓✗✓✗ |
2 |
WalkerObject walkerObject = createWalkerObject(); |
196 |
✓✗✓✗ |
1 |
walker.walk(walkerObject.reflectable()); |
197 |
|||
198 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerObject"_sv, |
199 |
observer.getCaptures("beginRoot"_sv).at(0)->getTypeInfo().getSchemaName()); |
||
200 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerObject"_sv, |
201 |
observer.getCaptures("endRoot"_sv).at(0)->getTypeInfo().getSchemaName()); |
||
202 |
|||
203 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(2, observer.getCaptures("beginArray"_sv).size()); |
204 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv, |
205 |
observer.getCaptures("beginArray"_sv).at(0)->getTypeInfo().getSchemaName()); |
||
206 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerNested"_sv, |
207 |
observer.getCaptures("beginArray"_sv).at(1)->getTypeInfo().getSchemaName()); |
||
208 |
|||
209 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(2, observer.getCaptures("endArray"_sv).size()); |
210 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerNested"_sv, |
211 |
observer.getCaptures("endArray"_sv).at(0)->getTypeInfo().getSchemaName()); |
||
212 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv, |
213 |
observer.getCaptures("endArray"_sv).at(1)->getTypeInfo().getSchemaName()); |
||
214 |
|||
215 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(6, observer.getCaptures("beginCompound"_sv).size()); |
216 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerNested"_sv, |
217 |
observer.getCaptures("beginCompound"_sv).at(0)->getTypeInfo().getSchemaName()); |
||
218 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv, |
219 |
observer.getCaptures("beginCompound"_sv).at(1)->getTypeInfo().getSchemaName()); |
||
220 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv, |
221 |
observer.getCaptures("beginCompound"_sv).at(2)->getTypeInfo().getSchemaName()); |
||
222 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv, |
223 |
observer.getCaptures("beginCompound"_sv).at(3)->getTypeInfo().getSchemaName()); |
||
224 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerNested"_sv, |
225 |
observer.getCaptures("beginCompound"_sv).at(4)->getTypeInfo().getSchemaName()); |
||
226 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerChoice"_sv, |
227 |
observer.getCaptures("beginCompound"_sv).at(5)->getTypeInfo().getSchemaName()); |
||
228 |
|||
229 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(6, observer.getCaptures("endCompound"_sv).size()); |
230 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerNested"_sv, |
231 |
observer.getCaptures("endCompound"_sv).at(0)->getTypeInfo().getSchemaName()); |
||
232 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv, |
233 |
observer.getCaptures("endCompound"_sv).at(1)->getTypeInfo().getSchemaName()); |
||
234 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv, |
235 |
observer.getCaptures("endCompound"_sv).at(2)->getTypeInfo().getSchemaName()); |
||
236 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerNested"_sv, |
237 |
observer.getCaptures("endCompound"_sv).at(3)->getTypeInfo().getSchemaName()); |
||
238 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv, |
239 |
observer.getCaptures("endCompound"_sv).at(4)->getTypeInfo().getSchemaName()); |
||
240 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerChoice"_sv, |
241 |
observer.getCaptures("endCompound"_sv).at(5)->getTypeInfo().getSchemaName()); |
||
242 |
|||
243 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(8, observer.getCaptures("visitValue"_sv).size()); |
244 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(13, observer.getCaptures("visitValue"_sv).at(0)->toUInt()); |
245 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ("nested", observer.getCaptures("visitValue"_sv).at(1)->toString()); |
246 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ("test", observer.getCaptures("visitValue"_sv).at(2)->toString()); |
247 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ("1", observer.getCaptures("visitValue"_sv).at(3)->toString()); |
248 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(2, observer.getCaptures("visitValue"_sv).at(4)->toUInt()); |
249 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ("nestedArray", observer.getCaptures("visitValue"_sv).at(5)->toString()); |
250 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(nullptr, observer.getCaptures("visitValue"_sv).at(6)); |
251 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ |
1 |
ASSERT_EQ(0, observer.getCaptures("visitValue"_sv).at(7)->toUInt()); |
252 |
} |
||
253 |
|||
254 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(WalkerTest, walkWrongUnionField) |
255 |
{ |
||
256 |
// use case: union field has wrong field name in type info (this cannot happen in generated code, |
||
257 |
// therefore we need some wrong reflectable here) |
||
258 |
using allocator_type = ::std::allocator<uint8_t>; |
||
259 |
|||
260 |
✗✓ | 1 |
class Reflectable : public ::zserio::ReflectableAllocatorHolderBase<allocator_type> |
261 |
{ |
||
262 |
public: |
||
263 |
1 |
explicit Reflectable(WalkerUnion&, const allocator_type& allocator) : |
|
264 |
1 |
::zserio::ReflectableAllocatorHolderBase<allocator_type>(WalkerUnion::typeInfo(), allocator) |
|
265 |
1 |
{} |
|
266 |
|||
267 |
1 |
::zserio::StringView getChoice() const override |
|
268 |
{ |
||
269 |
1 |
return ::zserio::makeStringView("wrong"); // this would be "value" in generated code |
|
270 |
} |
||
271 |
}; |
||
272 |
|||
273 |
✓✗ | 2 |
TestWalkObserver observer; |
274 |
✓✗ | 2 |
DefaultWalkFilter defaultFilter; |
275 |
✓✗ | 2 |
Walker walker(observer, defaultFilter); |
276 |
|||
277 |
✓✗ | 2 |
WalkerUnion walkerUnion; |
278 |
✓✗ | 1 |
walkerUnion.setValue(0); |
279 |
✓✗✓✗ |
1 |
walker.walk(std::allocate_shared<Reflectable>(allocator_type(), walkerUnion, allocator_type())); |
280 |
|||
281 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv, |
282 |
observer.getCaptures("beginRoot"_sv).at(0)->getTypeInfo().getSchemaName()); |
||
283 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv, |
284 |
observer.getCaptures("endRoot"_sv).at(0)->getTypeInfo().getSchemaName()); |
||
285 |
|||
286 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(0, observer.getCaptures("beginArray"_sv).size()); |
287 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(0, observer.getCaptures("endArray"_sv).size()); |
288 |
|||
289 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(0, observer.getCaptures("beginCompound"_sv).size()); |
290 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(0, observer.getCaptures("endCompound"_sv).size()); |
291 |
|||
292 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ |
1 |
ASSERT_EQ(0, observer.getCaptures("visitValue"_sv).size()); |
293 |
} |
||
294 |
|||
295 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(WalkerTest, walkWrongOptionalCondition) |
296 |
{ |
||
297 |
// use case: optional condition states that the optional is used, but it is not set! |
||
298 |
✓✗ | 2 |
TestWalkObserver observer; |
299 |
✓✗ | 2 |
DefaultWalkFilter defaultFilter; |
300 |
✓✗ | 2 |
Walker walker(observer, defaultFilter); |
301 |
✓✗✓✗ |
2 |
WalkerObject walkerObject = createWalkerObject(13, false); |
302 |
✓✗✓✗ |
1 |
walker.walk(walkerObject.reflectable()); |
303 |
|||
304 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerObject"_sv, |
305 |
observer.getCaptures("beginRoot"_sv).at(0)->getTypeInfo().getSchemaName()); |
||
306 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerObject"_sv, |
307 |
observer.getCaptures("endRoot"_sv).at(0)->getTypeInfo().getSchemaName()); |
||
308 |
|||
309 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(2, observer.getCaptures("beginArray"_sv).size()); |
310 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv, |
311 |
observer.getCaptures("beginArray"_sv).at(0)->getTypeInfo().getSchemaName()); |
||
312 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerNested"_sv, |
313 |
observer.getCaptures("beginArray"_sv).at(1)->getTypeInfo().getSchemaName()); |
||
314 |
|||
315 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(2, observer.getCaptures("endArray"_sv).size()); |
316 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerNested"_sv, |
317 |
observer.getCaptures("endArray"_sv).at(0)->getTypeInfo().getSchemaName()); |
||
318 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv, |
319 |
observer.getCaptures("endArray"_sv).at(1)->getTypeInfo().getSchemaName()); |
||
320 |
|||
321 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(5, observer.getCaptures("beginCompound"_sv).size()); |
322 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv, |
323 |
observer.getCaptures("beginCompound"_sv).at(0)->getTypeInfo().getSchemaName()); |
||
324 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv, |
325 |
observer.getCaptures("beginCompound"_sv).at(1)->getTypeInfo().getSchemaName()); |
||
326 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv, |
327 |
observer.getCaptures("beginCompound"_sv).at(2)->getTypeInfo().getSchemaName()); |
||
328 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerNested"_sv, |
329 |
observer.getCaptures("beginCompound"_sv).at(3)->getTypeInfo().getSchemaName()); |
||
330 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerChoice"_sv, |
331 |
observer.getCaptures("beginCompound"_sv).at(4)->getTypeInfo().getSchemaName()); |
||
332 |
|||
333 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(5, observer.getCaptures("endCompound"_sv).size()); |
334 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv, |
335 |
observer.getCaptures("endCompound"_sv).at(0)->getTypeInfo().getSchemaName()); |
||
336 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv, |
337 |
observer.getCaptures("endCompound"_sv).at(1)->getTypeInfo().getSchemaName()); |
||
338 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerNested"_sv, |
339 |
observer.getCaptures("endCompound"_sv).at(2)->getTypeInfo().getSchemaName()); |
||
340 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv, |
341 |
observer.getCaptures("endCompound"_sv).at(3)->getTypeInfo().getSchemaName()); |
||
342 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerChoice"_sv, |
343 |
observer.getCaptures("endCompound"_sv).at(4)->getTypeInfo().getSchemaName()); |
||
344 |
|||
345 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(8, observer.getCaptures("visitValue"_sv).size()); |
346 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(13, observer.getCaptures("visitValue"_sv).at(0)->toUInt()); |
347 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(nullptr, observer.getCaptures("visitValue"_sv).at(1)); |
348 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ("test", observer.getCaptures("visitValue"_sv).at(2)->toString()); |
349 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ("1", observer.getCaptures("visitValue"_sv).at(3)->toString()); |
350 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(2, observer.getCaptures("visitValue"_sv).at(4)->toUInt()); |
351 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ("nestedArray", observer.getCaptures("visitValue"_sv).at(5)->toString()); |
352 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(nullptr, observer.getCaptures("visitValue"_sv).at(6)); |
353 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ |
1 |
ASSERT_EQ(0, observer.getCaptures("visitValue"_sv).at(7)->toUInt()); |
354 |
} |
||
355 |
|||
356 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(WalkerTest, walkSkipCompound) |
357 |
{ |
||
358 |
✓✗ | 2 |
TestWalkObserver observer; |
359 |
✓✗ | 2 |
TestWalkFilter filter; |
360 |
1 |
filter.beforeCompound(false); |
|
361 |
✓✗ | 2 |
Walker walker(observer, filter); |
362 |
✓✗✓✗ |
2 |
WalkerObject walkerObject = createWalkerObject(); |
363 |
✓✗✓✗ |
1 |
walker.walk(walkerObject.reflectable()); |
364 |
|||
365 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerObject"_sv, |
366 |
observer.getCaptures("beginRoot"_sv).at(0)->getTypeInfo().getSchemaName()); |
||
367 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerObject"_sv, |
368 |
observer.getCaptures("endRoot"_sv).at(0)->getTypeInfo().getSchemaName()); |
||
369 |
|||
370 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, observer.getCaptures("beginArray"_sv).size()); |
371 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv, |
372 |
observer.getCaptures("beginArray"_sv).at(0)->getTypeInfo().getSchemaName()); |
||
373 |
|||
374 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, observer.getCaptures("endArray"_sv).size()); |
375 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv, |
376 |
observer.getCaptures("endArray"_sv).at(0)->getTypeInfo().getSchemaName()); |
||
377 |
|||
378 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(observer.getCaptures("beginCompound"_sv).empty()); |
379 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(observer.getCaptures("endCompound"_sv).empty()); |
380 |
|||
381 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(4, observer.getCaptures("visitValue"_sv).size()); |
382 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(13, observer.getCaptures("visitValue"_sv).at(0)->toUInt()); |
383 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ("test", observer.getCaptures("visitValue"_sv).at(1)->toString()); |
384 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(nullptr, observer.getCaptures("visitValue"_sv).at(2)); |
385 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ |
1 |
ASSERT_EQ(0, observer.getCaptures("visitValue"_sv).at(3)->toUInt()); |
386 |
} |
||
387 |
|||
388 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(WalkerTest, walkSkipSiblings) |
389 |
{ |
||
390 |
✓✗ | 2 |
TestWalkObserver observer; |
391 |
✓✗ | 2 |
TestWalkFilter filter; |
392 |
1 |
filter.afterValue(false); |
|
393 |
✓✗ | 2 |
Walker walker(observer, filter); |
394 |
✓✗✓✗ |
2 |
WalkerObject walkerObject = createWalkerObject(); |
395 |
✓✗✓✗ |
1 |
walker.walk(walkerObject.reflectable()); |
396 |
|||
397 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerObject"_sv, |
398 |
observer.getCaptures("beginRoot"_sv).at(0)->getTypeInfo().getSchemaName()); |
||
399 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerObject"_sv, |
400 |
observer.getCaptures("endRoot"_sv).at(0)->getTypeInfo().getSchemaName()); |
||
401 |
|||
402 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(observer.getCaptures("beginArray"_sv).empty()); |
403 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(observer.getCaptures("endArray"_sv).empty()); |
404 |
|||
405 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(observer.getCaptures("beginCompound"_sv).empty()); |
406 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(observer.getCaptures("endCompound"_sv).empty()); |
407 |
|||
408 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, observer.getCaptures("visitValue"_sv).size()); |
409 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ |
1 |
ASSERT_EQ(13, observer.getCaptures("visitValue"_sv).at(0)->toUInt()); |
410 |
} |
||
411 |
|||
412 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(WalkerTest, walkSkipAfterNested) |
413 |
{ |
||
414 |
✓✗ | 2 |
TestWalkObserver observer; |
415 |
✓✗ | 2 |
TestWalkFilter filter; |
416 |
1 |
filter.afterCompound(false); |
|
417 |
✓✗ | 2 |
Walker walker(observer, filter); |
418 |
✓✗✓✗ |
2 |
WalkerObject walkerObject = createWalkerObject(); |
419 |
✓✗✓✗ |
1 |
walker.walk(walkerObject.reflectable()); |
420 |
|||
421 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerObject"_sv, |
422 |
observer.getCaptures("beginRoot"_sv).at(0)->getTypeInfo().getSchemaName()); |
||
423 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerObject"_sv, |
424 |
observer.getCaptures("endRoot"_sv).at(0)->getTypeInfo().getSchemaName()); |
||
425 |
|||
426 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(observer.getCaptures("beginArray"_sv).empty()); |
427 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(observer.getCaptures("endArray"_sv).empty()); |
428 |
|||
429 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, observer.getCaptures("beginCompound"_sv).size()); |
430 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerNested"_sv, |
431 |
observer.getCaptures("beginCompound"_sv).at(0)->getTypeInfo().getSchemaName()); |
||
432 |
|||
433 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, observer.getCaptures("endCompound"_sv).size()); |
434 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerNested"_sv, |
435 |
observer.getCaptures("endCompound"_sv).at(0)->getTypeInfo().getSchemaName()); |
||
436 |
|||
437 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(2, observer.getCaptures("visitValue"_sv).size()); |
438 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(13, observer.getCaptures("visitValue"_sv).at(0)->toUInt()); |
439 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ |
1 |
ASSERT_EQ("nested", observer.getCaptures("visitValue"_sv).at(1)->toString()); |
440 |
} |
||
441 |
|||
442 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(WalkerTest, walkOnlyFirstElement) |
443 |
{ |
||
444 |
✓✗ | 2 |
TestWalkObserver observer; |
445 |
✓✗ | 2 |
TestWalkFilter filter; |
446 |
1 |
filter.onlyFirstElement(true); |
|
447 |
✓✗ | 2 |
Walker walker(observer, filter); |
448 |
✓✗✓✗ |
2 |
WalkerObject walkerObject = createWalkerObject(); |
449 |
✓✗✓✗ |
1 |
walker.walk(walkerObject.reflectable()); |
450 |
|||
451 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerObject"_sv, |
452 |
observer.getCaptures("beginRoot"_sv).at(0)->getTypeInfo().getSchemaName()); |
||
453 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerObject"_sv, |
454 |
observer.getCaptures("endRoot"_sv).at(0)->getTypeInfo().getSchemaName()); |
||
455 |
|||
456 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, observer.getCaptures("beginArray"_sv).size()); |
457 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv, |
458 |
observer.getCaptures("beginArray"_sv).at(0)->getTypeInfo().getSchemaName()); |
||
459 |
|||
460 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, observer.getCaptures("endArray"_sv).size()); |
461 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv, |
462 |
observer.getCaptures("endArray"_sv).at(0)->getTypeInfo().getSchemaName()); |
||
463 |
|||
464 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(3, observer.getCaptures("beginCompound"_sv).size()); |
465 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerNested"_sv, |
466 |
observer.getCaptures("beginCompound"_sv).at(0)->getTypeInfo().getSchemaName()); |
||
467 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv, |
468 |
observer.getCaptures("beginCompound"_sv).at(1)->getTypeInfo().getSchemaName()); |
||
469 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerChoice"_sv, |
470 |
observer.getCaptures("beginCompound"_sv).at(2)->getTypeInfo().getSchemaName()); |
||
471 |
|||
472 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(3, observer.getCaptures("endCompound"_sv).size()); |
473 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerNested"_sv, |
474 |
observer.getCaptures("endCompound"_sv).at(0)->getTypeInfo().getSchemaName()); |
||
475 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv, |
476 |
observer.getCaptures("endCompound"_sv).at(1)->getTypeInfo().getSchemaName()); |
||
477 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("test_object.std_allocator.WalkerChoice"_sv, |
478 |
observer.getCaptures("endCompound"_sv).at(2)->getTypeInfo().getSchemaName()); |
||
479 |
|||
480 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(6, observer.getCaptures("visitValue"_sv).size()); |
481 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(13, observer.getCaptures("visitValue"_sv).at(0)->toUInt()); |
482 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ("nested", observer.getCaptures("visitValue"_sv).at(1)->toString()); |
483 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ("test", observer.getCaptures("visitValue"_sv).at(2)->toString()); |
484 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ("1", observer.getCaptures("visitValue"_sv).at(3)->toString()); |
485 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(nullptr, observer.getCaptures("visitValue"_sv).at(4)); |
486 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ |
1 |
ASSERT_EQ(0, observer.getCaptures("visitValue"_sv).at(5)->toUInt()); |
487 |
} |
||
488 |
|||
489 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(DefaultWalkObserverTest, allMethods) |
490 |
{ |
||
491 |
2 |
DefaultWalkObserver defaultObserver; |
|
492 |
1 |
IWalkObserver& walkObserver = defaultObserver; |
|
493 |
✓✗ | 2 |
IReflectablePtr walkerReflectable = nullptr; |
494 |
✓✗✓✗ |
1 |
const FieldInfo& walkerFieldInfo = WalkerObject::typeInfo().getFields()[0]; |
495 |
|||
496 |
✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
1 |
ASSERT_NO_THROW(walkObserver.beginRoot(walkerReflectable)); |
497 |
✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
1 |
ASSERT_NO_THROW(walkObserver.endRoot(walkerReflectable)); |
498 |
✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
1 |
ASSERT_NO_THROW(walkObserver.beginArray(walkerReflectable, walkerFieldInfo)); |
499 |
✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
1 |
ASSERT_NO_THROW(walkObserver.endArray(walkerReflectable, walkerFieldInfo)); |
500 |
✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
1 |
ASSERT_NO_THROW(walkObserver.beginCompound(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); |
501 |
✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
1 |
ASSERT_NO_THROW(walkObserver.endCompound(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); |
502 |
✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
1 |
ASSERT_NO_THROW(walkObserver.visitValue(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); |
503 |
} |
||
504 |
|||
505 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(DefaultWalkFilterTest, allMethods) |
506 |
{ |
||
507 |
2 |
DefaultWalkFilter defaultFilter; |
|
508 |
1 |
IWalkFilter& walkFilter = defaultFilter; |
|
509 |
✓✗ | 2 |
IReflectablePtr walkerReflectable = nullptr; |
510 |
✓✗✓✗ |
1 |
const FieldInfo& walkerFieldInfo = WalkerObject::typeInfo().getFields()[0]; |
511 |
|||
512 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.beforeArray(walkerReflectable, walkerFieldInfo)); |
513 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterArray(walkerReflectable, walkerFieldInfo)); |
514 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.beforeCompound(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); |
515 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterCompound(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); |
516 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.beforeValue(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); |
517 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterValue(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); |
518 |
} |
||
519 |
|||
520 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(DepthFilterTest, depth0) |
521 |
{ |
||
522 |
2 |
DepthWalkFilter depthWalkFilter(0); |
|
523 |
1 |
IWalkFilter& walkFilter = depthWalkFilter; |
|
524 |
✓✗ | 2 |
IReflectablePtr walkerReflectable = nullptr; |
525 |
✓✗✓✗ |
1 |
const FieldInfo& walkerFieldInfo = WalkerObject::typeInfo().getFields()[0]; |
526 |
|||
527 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(walkFilter.beforeArray(walkerReflectable, walkerFieldInfo)); // 0 |
528 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterArray(walkerReflectable, walkerFieldInfo)); // 0 |
529 |
|||
530 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(walkFilter.beforeCompound(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); // 0 |
531 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterCompound(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); // 0 |
532 |
|||
533 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(walkFilter.beforeValue(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); // 0 |
534 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterValue(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); // 0 |
535 |
} |
||
536 |
|||
537 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(DepthFilterTest, depth1) |
538 |
{ |
||
539 |
2 |
DepthWalkFilter depthWalkFilter(1); |
|
540 |
1 |
IWalkFilter& walkFilter = depthWalkFilter; |
|
541 |
✓✗ | 2 |
IReflectablePtr walkerReflectable = nullptr; |
542 |
✓✗✓✗ |
1 |
const FieldInfo& walkerFieldInfo = WalkerObject::typeInfo().getFields()[0]; |
543 |
|||
544 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.beforeArray(walkerReflectable, walkerFieldInfo)); // 0 |
545 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(walkFilter.beforeArray(walkerReflectable, walkerFieldInfo)); // 1 |
546 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterArray(walkerReflectable, walkerFieldInfo)); // 1 |
547 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(walkFilter.beforeCompound(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); // 1 |
548 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterCompound(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); // 1 |
549 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(walkFilter.beforeValue(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); // 1 |
550 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterValue(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); // 1 |
551 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterArray(walkerReflectable, walkerFieldInfo)); // 0 |
552 |
|||
553 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.beforeCompound(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); // 0 |
554 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(walkFilter.beforeArray(walkerReflectable, walkerFieldInfo)); // 1 |
555 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterArray(walkerReflectable, walkerFieldInfo)); // 1 |
556 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(walkFilter.beforeCompound(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); // 1 |
557 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterCompound(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); // 1 |
558 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(walkFilter.beforeValue(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); // 1 |
559 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterValue(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); // 1 |
560 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterCompound(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); // 0 |
561 |
|||
562 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.beforeValue(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); // 0 |
563 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterValue(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); // 0 |
564 |
} |
||
565 |
|||
566 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(RegexWalkFilterTest, regexAllMatch) |
567 |
{ |
||
568 |
✓✗ | 2 |
RegexWalkFilter regexWalkFilter(".*"); |
569 |
1 |
IWalkFilter& walkFilter = regexWalkFilter; |
|
570 |
✓✗ | 2 |
IReflectablePtr walkerReflectable = nullptr; |
571 |
✓✗✓✗ |
1 |
const FieldInfo& walkerFieldInfo = WalkerObject::typeInfo().getFields()[0]; |
572 |
✓✗✓✗ |
1 |
const FieldInfo& walkerArrayFieldInfo = WalkerObject::typeInfo().getFields()[3]; |
573 |
|||
574 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.beforeArray(walkerReflectable, walkerArrayFieldInfo)); |
575 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterArray(walkerReflectable, walkerArrayFieldInfo)); |
576 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.beforeCompound(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); |
577 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterCompound(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); |
578 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.beforeValue(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); |
579 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterValue(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); |
580 |
} |
||
581 |
|||
582 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(RegexWalkFilterTest, regexPrefixMatch) |
583 |
{ |
||
584 |
✓✗ | 2 |
RegexWalkFilter regexWalkFilter("nested\\..*"); |
585 |
1 |
IWalkFilter& walkFilter = regexWalkFilter; |
|
586 |
✓✗✓✗ |
2 |
WalkerObject walkerObject = createWalkerObject(); |
587 |
✓✗✓✗ |
2 |
IReflectableConstPtr walkerReflectable = walkerObject.reflectable(); |
588 |
|||
589 |
✓✗✓✗ |
1 |
const FieldInfo& identifierFieldInfo = walkerObject.typeInfo().getFields()[0]; |
590 |
✓✗✓✗ |
2 |
IReflectableConstPtr identifierReflectable = walkerReflectable->getField("identifier"); |
591 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(walkFilter.beforeValue(identifierReflectable, identifierFieldInfo, WALKER_NOT_ELEMENT)); |
592 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterValue(identifierReflectable, identifierFieldInfo, WALKER_NOT_ELEMENT)); |
593 |
|||
594 |
✓✗✓✗ |
1 |
const FieldInfo& nestedFieldInfo = walkerObject.typeInfo().getFields()[1]; |
595 |
✓✗✓✗ |
2 |
IReflectableConstPtr nestedReflectable = walkerReflectable->getField("nested"); |
596 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.beforeCompound(nestedReflectable, nestedFieldInfo, WALKER_NOT_ELEMENT)); |
597 |
✓✗ | 1 |
const FieldInfo& textFieldInfo = nestedFieldInfo.typeInfo.getFields()[0]; |
598 |
✓✗✓✗ |
2 |
IReflectableConstPtr textReflectable = nestedReflectable->getField("text"); |
599 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.beforeValue(textReflectable, textFieldInfo, WALKER_NOT_ELEMENT)); |
600 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterValue(textReflectable, textFieldInfo, WALKER_NOT_ELEMENT)); |
601 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterCompound(nestedReflectable, nestedFieldInfo, WALKER_NOT_ELEMENT)); |
602 |
|||
603 |
// ignore text |
||
604 |
|||
605 |
✓✗✓✗ |
1 |
const FieldInfo& unionArrayFieldInfo = walkerObject.typeInfo().getFields()[3]; |
606 |
✓✗✓✗ |
2 |
IReflectableConstPtr unionArrayReflectable = walkerReflectable->getField("unionArray"); |
607 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(walkFilter.beforeArray(unionArrayReflectable, unionArrayFieldInfo)); |
608 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterArray(unionArrayReflectable, unionArrayFieldInfo)); |
609 |
} |
||
610 |
|||
611 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(RegexWalkFilterTest, regexArrayMatch) |
612 |
{ |
||
613 |
✓✗ | 2 |
RegexWalkFilter regexWalkFilter("unionArray\\[\\d+\\]\\.nes.*"); |
614 |
1 |
IWalkFilter& walkFilter = regexWalkFilter; |
|
615 |
✓✗✓✗ |
2 |
WalkerObject walkerObject = createWalkerObject(); |
616 |
✓✗✓✗ |
2 |
IReflectableConstPtr walkerReflectable = walkerObject.reflectable(); |
617 |
|||
618 |
✓✗✓✗ |
1 |
const FieldInfo& unionArrayFieldInfo = walkerObject.typeInfo().getFields()[3]; |
619 |
✓✗✓✗ |
2 |
IReflectableConstPtr unionArrayReflectable = walkerReflectable->getField("unionArray"); |
620 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.beforeArray(unionArrayReflectable, unionArrayFieldInfo)); |
621 |
|||
622 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_FALSE(walkFilter.beforeCompound(unionArrayReflectable->at(0), unionArrayFieldInfo, 0)); |
623 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterCompound(unionArrayReflectable->at(0), unionArrayFieldInfo, 0)); |
624 |
|||
625 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_FALSE(walkFilter.beforeCompound(unionArrayReflectable->at(1), unionArrayFieldInfo, 1)); |
626 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterCompound(unionArrayReflectable->at(1), unionArrayFieldInfo, 1)); |
627 |
|||
628 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_TRUE(walkFilter.beforeCompound(unionArrayReflectable->at(2), unionArrayFieldInfo, 2)); |
629 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterCompound(unionArrayReflectable->at(2), unionArrayFieldInfo, 2)); |
630 |
|||
631 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterArray(unionArrayReflectable, unionArrayFieldInfo)); |
632 |
} |
||
633 |
|||
634 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(RegexWalkFilterTest, regexArrayNoMatch) |
635 |
{ |
||
636 |
✓✗ | 2 |
RegexWalkFilter regexWalkFilter("^unionArray\\[\\d*\\]\\.te.*"); |
637 |
1 |
IWalkFilter& walkFilter = regexWalkFilter; |
|
638 |
|||
639 |
✓✗ | 2 |
std::vector<WalkerUnion> unionArray; |
640 |
✓✗ | 1 |
unionArray.resize(1); |
641 |
✓✗✓✗ ✓✗✓✓ ✗✗ |
1 |
unionArray[0].setNestedArray(std::vector<WalkerNested>{{WalkerNested{"nestedArray"}}}); |
642 |
1 |
const uint8_t choiceSelector = 8; |
|
643 |
✓✗ | 2 |
WalkerChoice choiceField; |
644 |
✓✗ | 1 |
choiceField.setValue8(0xAB); |
645 |
1 |
WalkerObject walkerObject (13, WalkerNested("nested"), "test", std::move(unionArray), NullOpt, |
|
646 |
✓✗✓✗ ✓✗ |
3 |
choiceSelector, choiceField); |
647 |
✓✗✓✗ |
2 |
IReflectableConstPtr walkerReflectable = walkerObject.reflectable(); |
648 |
|||
649 |
✓✗✓✗ |
1 |
const FieldInfo& unionArrayFieldInfo = walkerObject.typeInfo().getFields()[3]; |
650 |
✓✗✓✗ |
2 |
IReflectableConstPtr unionArrayReflectable = walkerReflectable->getField("unionArray"); |
651 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(walkFilter.beforeArray(unionArrayReflectable, unionArrayFieldInfo)); |
652 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterArray(unionArrayReflectable, unionArrayFieldInfo)); |
653 |
} |
||
654 |
|||
655 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(RegexWalkFilterTest, regexNullCompoundMatch) |
656 |
{ |
||
657 |
✓✗ | 2 |
RegexWalkFilter regexWalkFilter("nested"); |
658 |
1 |
IWalkFilter& walkFilter = regexWalkFilter; |
|
659 |
|||
660 |
✓✗✓✗ |
2 |
WalkerObject walkerObject = createWalkerObject(0, false); |
661 |
✓✗✓✗ |
2 |
IReflectableConstPtr walkerReflectable = walkerObject.reflectable(); |
662 |
|||
663 |
✓✗✓✗ |
1 |
const FieldInfo& nestedFieldInfo = walkerObject.typeInfo().getFields()[1]; |
664 |
✓✗✓✗ |
2 |
IReflectableConstPtr nestedReflectable = walkerReflectable->getField("nested"); |
665 |
✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(nullptr, nestedReflectable); |
666 |
// note that the null compounds are processed as values! |
||
667 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.beforeValue(nestedReflectable, nestedFieldInfo, WALKER_NOT_ELEMENT)); |
668 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterValue(nestedReflectable, nestedFieldInfo, WALKER_NOT_ELEMENT)); |
669 |
} |
||
670 |
|||
671 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(RegexWalkFilterTest, regexNullCompoundNoMatch) |
672 |
{ |
||
673 |
✓✗ | 2 |
RegexWalkFilter regexWalkFilter("^nested\\.text$"); |
674 |
1 |
IWalkFilter& walkFilter = regexWalkFilter; |
|
675 |
|||
676 |
✓✗✓✗ |
2 |
WalkerObject walkerObject = createWalkerObject(0, false); |
677 |
✓✗✓✗ |
2 |
IReflectableConstPtr walkerReflectable = walkerObject.reflectable(); |
678 |
|||
679 |
✓✗✓✗ |
1 |
const FieldInfo& nestedFieldInfo = walkerObject.typeInfo().getFields()[1]; |
680 |
✓✗✓✗ |
2 |
IReflectableConstPtr nestedReflectable = walkerReflectable->getField("nested"); |
681 |
✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(nullptr, nestedReflectable); |
682 |
// note that the null compounds are processed as values! |
||
683 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(walkFilter.beforeValue(nestedReflectable, nestedFieldInfo, WALKER_NOT_ELEMENT)); |
684 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterValue(nestedReflectable, nestedFieldInfo, WALKER_NOT_ELEMENT)); |
685 |
} |
||
686 |
|||
687 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(RegexWalkFilterTest, regexNullArrayMatch) |
688 |
{ |
||
689 |
✓✗ | 2 |
RegexWalkFilter regexWalkFilter("optionalUnionArray"); |
690 |
1 |
IWalkFilter& walkFilter = regexWalkFilter; |
|
691 |
|||
692 |
✓✗✓✗ |
2 |
WalkerObject walkerObject = createWalkerObject(); |
693 |
✓✗✓✗ |
2 |
IReflectableConstPtr walkerReflectable = walkerObject.reflectable(); |
694 |
|||
695 |
✓✗✓✗ |
1 |
const FieldInfo& optionalUnionArrayFieldInfo = walkerObject.typeInfo().getFields()[4]; |
696 |
✓✗✓✗ |
2 |
IReflectableConstPtr optionalUnionArrayReflectable = walkerReflectable->getField("optionalUnionArray"); |
697 |
✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(nullptr, optionalUnionArrayReflectable); |
698 |
// note that the null arrays are processed as values! |
||
699 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.beforeValue(optionalUnionArrayReflectable, optionalUnionArrayFieldInfo, |
700 |
WALKER_NOT_ELEMENT)); |
||
701 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterValue(optionalUnionArrayReflectable, optionalUnionArrayFieldInfo, |
702 |
WALKER_NOT_ELEMENT)); |
||
703 |
} |
||
704 |
|||
705 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(RegexWalkFilterTest, regexNullArrayNoMatch) |
706 |
{ |
||
707 |
✓✗ | 2 |
RegexWalkFilter regexWalkFilter("^optionalUnionArray\\.\\[\\d+\\]\\.nestedArray.*"); |
708 |
1 |
IWalkFilter& walkFilter = regexWalkFilter; |
|
709 |
|||
710 |
✓✗✓✗ |
2 |
WalkerObject walkerObject = createWalkerObject(); |
711 |
✓✗✓✗ |
2 |
IReflectableConstPtr walkerReflectable = walkerObject.reflectable(); |
712 |
|||
713 |
✓✗✓✗ |
1 |
const FieldInfo& optionalUnionArrayFieldInfo = walkerObject.typeInfo().getFields()[4]; |
714 |
✓✗✓✗ |
2 |
IReflectableConstPtr optionalUnionArrayReflectable = walkerReflectable->getField("optionalUnionArray"); |
715 |
✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(nullptr, optionalUnionArrayReflectable); |
716 |
// note that the null arrays are processed as values! |
||
717 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(walkFilter.beforeValue(optionalUnionArrayReflectable, optionalUnionArrayFieldInfo, |
718 |
WALKER_NOT_ELEMENT)); |
||
719 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterValue(optionalUnionArrayReflectable, optionalUnionArrayFieldInfo, |
720 |
WALKER_NOT_ELEMENT)); |
||
721 |
} |
||
722 |
|||
723 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(ArrayLengthWalkFilterTest, length0) |
724 |
{ |
||
725 |
2 |
ArrayLengthWalkFilter arrayLengthWalkFilter(0); |
|
726 |
1 |
IWalkFilter& walkFilter = arrayLengthWalkFilter; |
|
727 |
✓✗ | 2 |
IReflectableConstPtr walkerReflectable = nullptr; |
728 |
✓✗✓✗ |
1 |
const FieldInfo& walkerFieldInfo = WalkerObject::typeInfo().getFields()[0]; |
729 |
✓✗✓✗ |
1 |
const FieldInfo& walkerArrayFieldInfo = WalkerObject::typeInfo().getFields()[3]; |
730 |
|||
731 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.beforeArray(walkerReflectable, walkerArrayFieldInfo)); |
732 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(walkFilter.beforeCompound(walkerReflectable, walkerFieldInfo, 0)); |
733 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(walkFilter.afterCompound(walkerReflectable, walkerFieldInfo, 0)); |
734 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(walkFilter.beforeValue(walkerReflectable, walkerFieldInfo, 1)); |
735 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(walkFilter.afterValue(walkerReflectable, walkerFieldInfo, 1)); |
736 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterArray(walkerReflectable, walkerArrayFieldInfo)); |
737 |
|||
738 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.beforeCompound(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); |
739 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.beforeValue(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); |
740 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterValue(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); |
741 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.beforeArray(walkerReflectable, walkerArrayFieldInfo)); |
742 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(walkFilter.beforeValue(walkerReflectable, walkerFieldInfo, 0)); |
743 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(walkFilter.afterValue(walkerReflectable, walkerFieldInfo, 0)); |
744 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterArray(walkerReflectable, walkerArrayFieldInfo)); |
745 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterCompound(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); |
746 |
} |
||
747 |
|||
748 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(AndWalkFilterTest, empty) |
749 |
{ |
||
750 |
✓✗ | 2 |
AndWalkFilter andWalkFilter({}); |
751 |
1 |
IWalkFilter& walkFilter = andWalkFilter; |
|
752 |
✓✗ | 2 |
IReflectableConstPtr walkerReflectable = nullptr; |
753 |
✓✗✓✗ |
1 |
const FieldInfo& walkerFieldInfo = WalkerObject::typeInfo().getFields()[0]; |
754 |
✓✗✓✗ |
1 |
const FieldInfo& walkerArrayFieldInfo = WalkerObject::typeInfo().getFields()[3]; |
755 |
|||
756 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.beforeArray(walkerReflectable, walkerArrayFieldInfo)); |
757 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterArray(walkerReflectable, walkerArrayFieldInfo)); |
758 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.beforeCompound(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); |
759 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterCompound(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); |
760 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.beforeValue(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); |
761 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterValue(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); |
762 |
} |
||
763 |
|||
764 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(AndWalkFilterTest, trueTrue) |
765 |
{ |
||
766 |
2 |
TestWalkFilter trueFilter1; |
|
767 |
✓✗ | 2 |
TestWalkFilter trueFilter2; |
768 |
✓✗✓✗ ✓✗ |
2 |
AndWalkFilter andWalkFilter({std::ref<IWalkFilter>(trueFilter1), std::ref<IWalkFilter>(trueFilter2)}); |
769 |
1 |
IWalkFilter& walkFilter = andWalkFilter; |
|
770 |
✓✗ | 2 |
IReflectableConstPtr walkerReflectable = nullptr; |
771 |
✓✗✓✗ |
1 |
const FieldInfo& walkerFieldInfo = WalkerObject::typeInfo().getFields()[0]; |
772 |
✓✗✓✗ |
1 |
const FieldInfo& walkerArrayFieldInfo = WalkerObject::typeInfo().getFields()[3]; |
773 |
|||
774 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.beforeArray(walkerReflectable, walkerArrayFieldInfo)); |
775 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterArray(walkerReflectable, walkerArrayFieldInfo)); |
776 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.beforeCompound(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); |
777 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterCompound(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); |
778 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(walkFilter.beforeValue(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); |
779 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ |
1 |
ASSERT_TRUE(walkFilter.afterValue(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); |
780 |
} |
||
781 |
|||
782 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(AndWalkFilterTest, falseFalse) |
783 |
{ |
||
784 |
2 |
TestWalkFilter falseFilter1; |
|
785 |
1 |
falseFilter1.beforeArray(false); |
|
786 |
1 |
falseFilter1.afterArray(false); |
|
787 |
1 |
falseFilter1.beforeCompound(false); |
|
788 |
1 |
falseFilter1.afterCompound(false); |
|
789 |
1 |
falseFilter1.beforeValue(false); |
|
790 |
1 |
falseFilter1.afterValue(false); |
|
791 |
✓✗ | 2 |
TestWalkFilter falseFilter2; |
792 |
1 |
falseFilter2.beforeArray(false); |
|
793 |
1 |
falseFilter2.afterArray(false); |
|
794 |
1 |
falseFilter2.beforeCompound(false); |
|
795 |
1 |
falseFilter2.afterCompound(false); |
|
796 |
1 |
falseFilter2.beforeValue(false); |
|
797 |
1 |
falseFilter2.afterValue(false); |
|
798 |
✓✗✓✗ ✓✗ |
2 |
AndWalkFilter andWalkFilter({std::ref<IWalkFilter>(falseFilter1), std::ref<IWalkFilter>(falseFilter2)}); |
799 |
1 |
IWalkFilter& walkFilter = andWalkFilter; |
|
800 |
✓✗ | 2 |
IReflectablePtr walkerReflectable = nullptr; |
801 |
✓✗✓✗ |
1 |
const FieldInfo& walkerFieldInfo = WalkerObject::typeInfo().getFields()[0]; |
802 |
✓✗✓✗ |
1 |
const FieldInfo& walkerArrayFieldInfo = WalkerObject::typeInfo().getFields()[3]; |
803 |
|||
804 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(walkFilter.beforeArray(walkerReflectable, walkerArrayFieldInfo)); |
805 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(walkFilter.afterArray(walkerReflectable, walkerArrayFieldInfo)); |
806 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(walkFilter.beforeCompound(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); |
807 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(walkFilter.afterCompound(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); |
808 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(walkFilter.beforeValue(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); |
809 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ |
1 |
ASSERT_FALSE(walkFilter.afterValue(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); |
810 |
} |
||
811 |
|||
812 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(AndWalkFilterTest, trueFalse) |
813 |
{ |
||
814 |
2 |
TestWalkFilter trueFilter; |
|
815 |
✓✗ | 2 |
TestWalkFilter falseFilter; |
816 |
1 |
falseFilter.beforeArray(false); |
|
817 |
1 |
falseFilter.afterArray(false); |
|
818 |
1 |
falseFilter.beforeCompound(false); |
|
819 |
1 |
falseFilter.afterCompound(false); |
|
820 |
1 |
falseFilter.beforeValue(false); |
|
821 |
1 |
falseFilter.afterValue(false); |
|
822 |
✓✗✓✗ ✓✗ |
2 |
AndWalkFilter andWalkFilter({std::ref<IWalkFilter>(trueFilter), std::ref<IWalkFilter>(falseFilter)}); |
823 |
1 |
IWalkFilter& walkFilter = andWalkFilter; |
|
824 |
✓✗ | 2 |
IReflectablePtr walkerReflectable = nullptr; |
825 |
✓✗✓✗ |
1 |
const FieldInfo& walkerFieldInfo = WalkerObject::typeInfo().getFields()[0]; |
826 |
✓✗✓✗ |
1 |
const FieldInfo& walkerArrayFieldInfo = WalkerObject::typeInfo().getFields()[3]; |
827 |
|||
828 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(walkFilter.beforeArray(walkerReflectable, walkerArrayFieldInfo)); |
829 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(walkFilter.afterArray(walkerReflectable, walkerArrayFieldInfo)); |
830 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(walkFilter.beforeCompound(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); |
831 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(walkFilter.afterCompound(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); |
832 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(walkFilter.beforeValue(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); |
833 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ |
1 |
ASSERT_FALSE(walkFilter.afterValue(walkerReflectable, walkerFieldInfo, WALKER_NOT_ELEMENT)); |
834 |
} |
||
835 |
|||
836 |
✓✗✓✗ |
2394 |
} // namespace zserio |
Generated by: GCOVR (Version 4.2) |