Coverage Report

Created: 2024-04-30 09:35

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