Coverage Report

Created: 2023-12-13 14:58

test/zserio/WalkerTest.cpp
Line
Count
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
WalkerObject createWalkerObject(uint32_t identifier = 13, bool createNested = true)
31
12
{
32
12
    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
12
    WalkerChoice choiceField;
39
12
    choiceField.initialize(choiceSelector);
40
12
    if (createNested)
41
9
    {
42
9
        return WalkerObject(identifier, WalkerNested("nested"), "test", std::move(unionArray), NullOpt,
43
9
                choiceSelector, choiceField);
44
9
    }
45
3
    else
46
3
    {
47
3
        return WalkerObject(identifier, NullOpt, "test", std::move(unionArray), NullOpt,
48
3
                choiceSelector, choiceField);
49
3
    }
50
12
}
51
52
class TestWalkObserver : public IWalkObserver
53
{
54
public:
55
    using CapturesMap = std::map<StringView, std::vector<IReflectableConstPtr>>;
56
57
    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
    void beginRoot(const IReflectableConstPtr& compound) override
70
7
    {
71
7
        m_captures["beginRoot"_sv].push_back(compound);
72
7
    }
73
74
    void endRoot(const IReflectableConstPtr& compound) override
75
7
    {
76
7
        m_captures["endRoot"_sv].push_back(compound);
77
7
    }
78
79
    void beginArray(const IReflectableConstPtr& array, const FieldInfo&) override
80
6
    {
81
6
        m_captures["beginArray"_sv].push_back(array);
82
6
    }
83
84
    void endArray(const IReflectableConstPtr& array, const FieldInfo&) override
85
6
    {
86
6
        m_captures["endArray"_sv].push_back(array);
87
6
    }
88
89
    void beginCompound(const IReflectableConstPtr& compound, const FieldInfo&, size_t) override
90
15
    {
91
15
        m_captures["beginCompound"_sv].push_back(compound);
92
15
    }
93
94
    void endCompound(const IReflectableConstPtr& compound, const FieldInfo&, size_t) override
95
15
    {
96
15
        m_captures["endCompound"_sv].push_back(compound);
97
15
    }
98
99
    void visitValue(const IReflectableConstPtr& value, const FieldInfo&, size_t) override
100
29
    {
101
29
        m_captures["visitValue"_sv].push_back(value);
102
29
    }
103
104
    const std::vector<IReflectableConstPtr>& getCaptures(StringView captureName) const
105
120
    {
106
120
        return m_captures.find(captureName)->second;
107
120
    }
108
109
private:
110
    CapturesMap m_captures;
111
};
112
113
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
    TestWalkFilter& onlyFirstElement(bool onlyFirstElement)
119
1
    {
120
1
        m_onlyFirstElement = onlyFirstElement; return *this;
121
1
    }
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
    bool beforeArray(const IReflectableConstPtr&, const FieldInfo&) override
128
8
    {
129
8
        m_isFirstElement = true;
130
8
        return m_beforeArray;
131
8
    }
132
133
    bool afterArray(const IReflectableConstPtr&, const FieldInfo&) override
134
8
    {
135
8
        m_isFirstElement = false;
136
8
        return m_afterArray;
137
8
    }
138
139
    bool beforeCompound(const IReflectableConstPtr&, const FieldInfo&, size_t) override
140
15
    {
141
15
        return m_beforeCompound;
142
15
    }
143
144
    bool afterCompound(const IReflectableConstPtr&, const FieldInfo&, size_t) override
145
15
    {
146
15
        bool goToNext = !(m_onlyFirstElement && 
m_isFirstElement3
);
147
15
        m_isFirstElement = false;
148
15
        return goToNext && 
m_afterCompound14
;
149
15
    }
150
151
    bool beforeValue(const IReflectableConstPtr&, const FieldInfo&, size_t) override
152
19
    {
153
19
        return m_beforeValue;
154
19
    }
155
156
    bool afterValue(const IReflectableConstPtr&, const FieldInfo&, size_t) override
157
19
    {
158
19
        return m_afterValue;
159
19
    }
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
TEST(WalkerTest, walkNull)
175
1
{
176
1
    DefaultWalkObserver defaultObserver;
177
1
    Walker walker(defaultObserver);
178
1
    ASSERT_THROW(walker.walk(nullptr), CppRuntimeException);
179
1
}
180
181
TEST(WalkerTest, walkNonCompound)
182
1
{
183
1
    DefaultWalkObserver defaultObserver;
184
1
    Walker walker(defaultObserver);
185
1
    WalkerBitmask walkerBitmask;
186
187
1
    ASSERT_THROW(walker.walk(walkerBitmask.reflectable()), CppRuntimeException);
188
1
}
189
190
TEST(WalkerTest, walk)
191
1
{
192
1
    TestWalkObserver observer;
193
1
    DefaultWalkFilter defaultFilter;
194
1
    Walker walker(observer, defaultFilter);
195
1
    WalkerObject walkerObject = createWalkerObject();
196
1
    walker.walk(walkerObject.reflectable());
197
198
1
    ASSERT_EQ("test_object.std_allocator.WalkerObject"_sv,
199
1
            observer.getCaptures("beginRoot"_sv).at(0)->getTypeInfo().getSchemaName());
200
1
    ASSERT_EQ("test_object.std_allocator.WalkerObject"_sv,
201
1
            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
1
            observer.getCaptures("beginArray"_sv).at(0)->getTypeInfo().getSchemaName());
206
1
    ASSERT_EQ("test_object.std_allocator.WalkerNested"_sv,
207
1
            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
1
            observer.getCaptures("endArray"_sv).at(0)->getTypeInfo().getSchemaName());
212
1
    ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv,
213
1
            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
1
            observer.getCaptures("beginCompound"_sv).at(0)->getTypeInfo().getSchemaName());
218
1
    ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv,
219
1
            observer.getCaptures("beginCompound"_sv).at(1)->getTypeInfo().getSchemaName());
220
1
    ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv,
221
1
            observer.getCaptures("beginCompound"_sv).at(2)->getTypeInfo().getSchemaName());
222
1
    ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv,
223
1
            observer.getCaptures("beginCompound"_sv).at(3)->getTypeInfo().getSchemaName());
224
1
    ASSERT_EQ("test_object.std_allocator.WalkerNested"_sv,
225
1
            observer.getCaptures("beginCompound"_sv).at(4)->getTypeInfo().getSchemaName());
226
1
    ASSERT_EQ("test_object.std_allocator.WalkerChoice"_sv,
227
1
            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
1
            observer.getCaptures("endCompound"_sv).at(0)->getTypeInfo().getSchemaName());
232
1
    ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv,
233
1
            observer.getCaptures("endCompound"_sv).at(1)->getTypeInfo().getSchemaName());
234
1
    ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv,
235
1
            observer.getCaptures("endCompound"_sv).at(2)->getTypeInfo().getSchemaName());
236
1
    ASSERT_EQ("test_object.std_allocator.WalkerNested"_sv,
237
1
            observer.getCaptures("endCompound"_sv).at(3)->getTypeInfo().getSchemaName());
238
1
    ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv,
239
1
            observer.getCaptures("endCompound"_sv).at(4)->getTypeInfo().getSchemaName());
240
1
    ASSERT_EQ("test_object.std_allocator.WalkerChoice"_sv,
241
1
            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
1
}
253
254
TEST(WalkerTest, walkWrongUnionField)
255
1
{
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
1
    using allocator_type = ::std::allocator<uint8_t>;
259
260
1
    class Reflectable : public ::zserio::ReflectableAllocatorHolderBase<allocator_type>
261
1
    {
262
1
    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
1
        {
269
1
            return ::zserio::makeStringView("wrong"); // this would be "value" in generated code
270
1
        }
271
1
    };
272
273
1
    TestWalkObserver observer;
274
1
    DefaultWalkFilter defaultFilter;
275
1
    Walker walker(observer, defaultFilter);
276
277
1
    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
1
            observer.getCaptures("beginRoot"_sv).at(0)->getTypeInfo().getSchemaName());
283
1
    ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv,
284
1
            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
1
}
294
295
TEST(WalkerTest, walkWrongOptionalCondition)
296
1
{
297
    // use case: optional condition states that the optional is used, but it is not set!
298
1
    TestWalkObserver observer;
299
1
    DefaultWalkFilter defaultFilter;
300
1
    Walker walker(observer, defaultFilter);
301
1
    WalkerObject walkerObject = createWalkerObject(13, false);
302
1
    walker.walk(walkerObject.reflectable());
303
304
1
    ASSERT_EQ("test_object.std_allocator.WalkerObject"_sv,
305
1
            observer.getCaptures("beginRoot"_sv).at(0)->getTypeInfo().getSchemaName());
306
1
    ASSERT_EQ("test_object.std_allocator.WalkerObject"_sv,
307
1
            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
1
            observer.getCaptures("beginArray"_sv).at(0)->getTypeInfo().getSchemaName());
312
1
    ASSERT_EQ("test_object.std_allocator.WalkerNested"_sv,
313
1
            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
1
            observer.getCaptures("endArray"_sv).at(0)->getTypeInfo().getSchemaName());
318
1
    ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv,
319
1
            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
1
            observer.getCaptures("beginCompound"_sv).at(0)->getTypeInfo().getSchemaName());
324
1
    ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv,
325
1
            observer.getCaptures("beginCompound"_sv).at(1)->getTypeInfo().getSchemaName());
326
1
    ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv,
327
1
            observer.getCaptures("beginCompound"_sv).at(2)->getTypeInfo().getSchemaName());
328
1
    ASSERT_EQ("test_object.std_allocator.WalkerNested"_sv,
329
1
            observer.getCaptures("beginCompound"_sv).at(3)->getTypeInfo().getSchemaName());
330
1
    ASSERT_EQ("test_object.std_allocator.WalkerChoice"_sv,
331
1
            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
1
            observer.getCaptures("endCompound"_sv).at(0)->getTypeInfo().getSchemaName());
336
1
    ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv,
337
1
            observer.getCaptures("endCompound"_sv).at(1)->getTypeInfo().getSchemaName());
338
1
    ASSERT_EQ("test_object.std_allocator.WalkerNested"_sv,
339
1
            observer.getCaptures("endCompound"_sv).at(2)->getTypeInfo().getSchemaName());
340
1
    ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv,
341
1
            observer.getCaptures("endCompound"_sv).at(3)->getTypeInfo().getSchemaName());
342
1
    ASSERT_EQ("test_object.std_allocator.WalkerChoice"_sv,
343
1
            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
1
}
355
356
TEST(WalkerTest, walkSkipCompound)
357
1
{
358
1
    TestWalkObserver observer;
359
1
    TestWalkFilter filter;
360
1
    filter.beforeCompound(false);
361
1
    Walker walker(observer, filter);
362
1
    WalkerObject walkerObject = createWalkerObject();
363
1
    walker.walk(walkerObject.reflectable());
364
365
1
    ASSERT_EQ("test_object.std_allocator.WalkerObject"_sv,
366
1
            observer.getCaptures("beginRoot"_sv).at(0)->getTypeInfo().getSchemaName());
367
1
    ASSERT_EQ("test_object.std_allocator.WalkerObject"_sv,
368
1
            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
1
            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
1
            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
1
}
387
388
TEST(WalkerTest, walkSkipSiblings)
389
1
{
390
1
    TestWalkObserver observer;
391
1
    TestWalkFilter filter;
392
1
    filter.afterValue(false);
393
1
    Walker walker(observer, filter);
394
1
    WalkerObject walkerObject = createWalkerObject();
395
1
    walker.walk(walkerObject.reflectable());
396
397
1
    ASSERT_EQ("test_object.std_allocator.WalkerObject"_sv,
398
1
            observer.getCaptures("beginRoot"_sv).at(0)->getTypeInfo().getSchemaName());
399
1
    ASSERT_EQ("test_object.std_allocator.WalkerObject"_sv,
400
1
            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
1
}
411
412
TEST(WalkerTest, walkSkipAfterNested)
413
1
{
414
1
    TestWalkObserver observer;
415
1
    TestWalkFilter filter;
416
1
    filter.afterCompound(false);
417
1
    Walker walker(observer, filter);
418
1
    WalkerObject walkerObject = createWalkerObject();
419
1
    walker.walk(walkerObject.reflectable());
420
421
1
    ASSERT_EQ("test_object.std_allocator.WalkerObject"_sv,
422
1
            observer.getCaptures("beginRoot"_sv).at(0)->getTypeInfo().getSchemaName());
423
1
    ASSERT_EQ("test_object.std_allocator.WalkerObject"_sv,
424
1
            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
1
            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
1
            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
1
}
441
442
TEST(WalkerTest, walkOnlyFirstElement)
443
1
{
444
1
    TestWalkObserver observer;
445
1
    TestWalkFilter filter;
446
1
    filter.onlyFirstElement(true);
447
1
    Walker walker(observer, filter);
448
1
    WalkerObject walkerObject = createWalkerObject();
449
1
    walker.walk(walkerObject.reflectable());
450
451
1
    ASSERT_EQ("test_object.std_allocator.WalkerObject"_sv,
452
1
            observer.getCaptures("beginRoot"_sv).at(0)->getTypeInfo().getSchemaName());
453
1
    ASSERT_EQ("test_object.std_allocator.WalkerObject"_sv,
454
1
            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
1
            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
1
            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
1
            observer.getCaptures("beginCompound"_sv).at(0)->getTypeInfo().getSchemaName());
467
1
    ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv,
468
1
            observer.getCaptures("beginCompound"_sv).at(1)->getTypeInfo().getSchemaName());
469
1
    ASSERT_EQ("test_object.std_allocator.WalkerChoice"_sv,
470
1
            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
1
            observer.getCaptures("endCompound"_sv).at(0)->getTypeInfo().getSchemaName());
475
1
    ASSERT_EQ("test_object.std_allocator.WalkerUnion"_sv,
476
1
            observer.getCaptures("endCompound"_sv).at(1)->getTypeInfo().getSchemaName());
477
1
    ASSERT_EQ("test_object.std_allocator.WalkerChoice"_sv,
478
1
            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
1
}
488
489
TEST(DefaultWalkObserverTest, allMethods)
490
1
{
491
1
    DefaultWalkObserver defaultObserver;
492
1
    IWalkObserver& walkObserver = defaultObserver;
493
1
    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
1
}
504
505
TEST(DefaultWalkFilterTest, allMethods)
506
1
{
507
1
    DefaultWalkFilter defaultFilter;
508
1
    IWalkFilter& walkFilter = defaultFilter;
509
1
    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
1
}
519
520
TEST(DepthFilterTest, depth0)
521
1
{
522
1
    DepthWalkFilter depthWalkFilter(0);
523
1
    IWalkFilter& walkFilter = depthWalkFilter;
524
1
    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
1
}
536
537
TEST(DepthFilterTest, depth1)
538
1
{
539
1
    DepthWalkFilter depthWalkFilter(1);
540
1
    IWalkFilter& walkFilter = depthWalkFilter;
541
1
    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
1
}
565
566
TEST(RegexWalkFilterTest, regexAllMatch)
567
1
{
568
1
    RegexWalkFilter regexWalkFilter(".*");
569
1
    IWalkFilter& walkFilter = regexWalkFilter;
570
1
    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
1
}
581
582
TEST(RegexWalkFilterTest, regexPrefixMatch)
583
1
{
584
1
    RegexWalkFilter regexWalkFilter("nested\\..*");
585
1
    IWalkFilter& walkFilter = regexWalkFilter;
586
1
    WalkerObject walkerObject = createWalkerObject();
587
1
    IReflectableConstPtr walkerReflectable = walkerObject.reflectable();
588
589
1
    const FieldInfo& identifierFieldInfo = walkerObject.typeInfo().getFields()[0];
590
1
    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
1
    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
1
    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
1
    IReflectableConstPtr unionArrayReflectable = walkerReflectable->getField("unionArray");
607
1
    ASSERT_FALSE(walkFilter.beforeArray(unionArrayReflectable, unionArrayFieldInfo));
608
1
    ASSERT_TRUE(walkFilter.afterArray(unionArrayReflectable, unionArrayFieldInfo));
609
1
}
610
611
TEST(RegexWalkFilterTest, regexArrayMatch)
612
1
{
613
1
    RegexWalkFilter regexWalkFilter("unionArray\\[\\d+\\]\\.nes.*");
614
1
    IWalkFilter& walkFilter = regexWalkFilter;
615
1
    WalkerObject walkerObject = createWalkerObject();
616
1
    IReflectableConstPtr walkerReflectable = walkerObject.reflectable();
617
618
1
    const FieldInfo& unionArrayFieldInfo = walkerObject.typeInfo().getFields()[3];
619
1
    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
1
}
633
634
TEST(RegexWalkFilterTest, regexArrayNoMatch)
635
1
{
636
1
    RegexWalkFilter regexWalkFilter("^unionArray\\[\\d*\\]\\.te.*");
637
1
    IWalkFilter& walkFilter = regexWalkFilter;
638
639
1
    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
1
    WalkerChoice choiceField;
644
1
    choiceField.setValue8(0xAB);
645
1
    WalkerObject walkerObject (13, WalkerNested("nested"), "test", std::move(unionArray), NullOpt,
646
1
            choiceSelector, choiceField);
647
1
    IReflectableConstPtr walkerReflectable = walkerObject.reflectable();
648
649
1
    const FieldInfo& unionArrayFieldInfo = walkerObject.typeInfo().getFields()[3];
650
1
    IReflectableConstPtr unionArrayReflectable = walkerReflectable->getField("unionArray");
651
1
    ASSERT_FALSE(walkFilter.beforeArray(unionArrayReflectable, unionArrayFieldInfo));
652
1
    ASSERT_TRUE(walkFilter.afterArray(unionArrayReflectable, unionArrayFieldInfo));
653
1
}
654
655
TEST(RegexWalkFilterTest, regexNullCompoundMatch)
656
1
{
657
1
    RegexWalkFilter regexWalkFilter("nested");
658
1
    IWalkFilter& walkFilter = regexWalkFilter;
659
660
1
    WalkerObject walkerObject = createWalkerObject(0, false);
661
1
    IReflectableConstPtr walkerReflectable = walkerObject.reflectable();
662
663
1
    const FieldInfo& nestedFieldInfo = walkerObject.typeInfo().getFields()[1];
664
1
    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
1
}
670
671
TEST(RegexWalkFilterTest, regexNullCompoundNoMatch)
672
1
{
673
1
    RegexWalkFilter regexWalkFilter("^nested\\.text$");
674
1
    IWalkFilter& walkFilter = regexWalkFilter;
675
676
1
    WalkerObject walkerObject = createWalkerObject(0, false);
677
1
    IReflectableConstPtr walkerReflectable = walkerObject.reflectable();
678
679
1
    const FieldInfo& nestedFieldInfo = walkerObject.typeInfo().getFields()[1];
680
1
    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
1
}
686
687
TEST(RegexWalkFilterTest, regexNullArrayMatch)
688
1
{
689
1
    RegexWalkFilter regexWalkFilter("optionalUnionArray");
690
1
    IWalkFilter& walkFilter = regexWalkFilter;
691
692
1
    WalkerObject walkerObject = createWalkerObject();
693
1
    IReflectableConstPtr walkerReflectable = walkerObject.reflectable();
694
695
1
    const FieldInfo& optionalUnionArrayFieldInfo = walkerObject.typeInfo().getFields()[4];
696
1
    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
1
            WALKER_NOT_ELEMENT));
701
1
    ASSERT_TRUE(walkFilter.afterValue(optionalUnionArrayReflectable, optionalUnionArrayFieldInfo,
702
1
            WALKER_NOT_ELEMENT));
703
1
}
704
705
TEST(RegexWalkFilterTest, regexNullArrayNoMatch)
706
1
{
707
1
    RegexWalkFilter regexWalkFilter("^optionalUnionArray\\.\\[\\d+\\]\\.nestedArray.*");
708
1
    IWalkFilter& walkFilter = regexWalkFilter;
709
710
1
    WalkerObject walkerObject = createWalkerObject();
711
1
    IReflectableConstPtr walkerReflectable = walkerObject.reflectable();
712
713
1
    const FieldInfo& optionalUnionArrayFieldInfo = walkerObject.typeInfo().getFields()[4];
714
1
    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
1
            WALKER_NOT_ELEMENT));
719
1
    ASSERT_TRUE(walkFilter.afterValue(optionalUnionArrayReflectable, optionalUnionArrayFieldInfo,
720
1
            WALKER_NOT_ELEMENT));
721
1
}
722
723
TEST(ArrayLengthWalkFilterTest, length0)
724
1
{
725
1
    ArrayLengthWalkFilter arrayLengthWalkFilter(0);
726
1
    IWalkFilter& walkFilter = arrayLengthWalkFilter;
727
1
    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
1
}
747
748
TEST(AndWalkFilterTest, empty)
749
1
{
750
1
    AndWalkFilter andWalkFilter({});
751
1
    IWalkFilter& walkFilter = andWalkFilter;
752
1
    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
1
}
763
764
TEST(AndWalkFilterTest, trueTrue)
765
1
{
766
1
    TestWalkFilter trueFilter1;
767
1
    TestWalkFilter trueFilter2;
768
1
    AndWalkFilter andWalkFilter({std::ref<IWalkFilter>(trueFilter1), std::ref<IWalkFilter>(trueFilter2)});
769
1
    IWalkFilter& walkFilter = andWalkFilter;
770
1
    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
1
}
781
782
TEST(AndWalkFilterTest, falseFalse)
783
1
{
784
1
    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
1
    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
1
    AndWalkFilter andWalkFilter({std::ref<IWalkFilter>(falseFilter1), std::ref<IWalkFilter>(falseFilter2)});
799
1
    IWalkFilter& walkFilter = andWalkFilter;
800
1
    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
1
}
811
812
TEST(AndWalkFilterTest, trueFalse)
813
1
{
814
1
    TestWalkFilter trueFilter;
815
1
    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
1
    AndWalkFilter andWalkFilter({std::ref<IWalkFilter>(trueFilter), std::ref<IWalkFilter>(falseFilter)});
823
1
    IWalkFilter& walkFilter = andWalkFilter;
824
1
    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
1
}
835
836
} // namespace zserio