GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: test/zserio/WalkerTest.cpp Lines: 509 509 100.0 %
Date: 2023-12-13 14:51:09 Branches: 1433 4648 30.8 %

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