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