1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
|
#ifndef RYML_SINGLE_HEADER
#include "c4/yml/std/std.hpp"
#include "c4/yml/parse.hpp"
#include "c4/yml/emit.hpp"
#include <c4/format.hpp>
#include <c4/yml/detail/checks.hpp>
#include <c4/yml/detail/print.hpp>
#endif
#include "./test_lib/test_case.hpp"
#include "./test_lib/callbacks_tester.hpp"
#include <gtest/gtest.h>
namespace c4 {
namespace yml {
TEST(NodeType, type_str_preset)
{
// avoid coverage misses
EXPECT_EQ(to_csubstr(NodeType(KEYVAL).type_str()), "KEYVAL");
EXPECT_EQ(to_csubstr(NodeType(KEY).type_str()), "KEY");
EXPECT_EQ(to_csubstr(NodeType(VAL).type_str()), "VAL");
EXPECT_EQ(to_csubstr(NodeType(MAP).type_str()), "MAP");
EXPECT_EQ(to_csubstr(NodeType(SEQ).type_str()), "SEQ");
EXPECT_EQ(to_csubstr(NodeType(KEYMAP).type_str()), "KEYMAP");
EXPECT_EQ(to_csubstr(NodeType(KEYSEQ).type_str()), "KEYSEQ");
EXPECT_EQ(to_csubstr(NodeType(DOCSEQ).type_str()), "DOCSEQ");
EXPECT_EQ(to_csubstr(NodeType(DOCMAP).type_str()), "DOCMAP");
EXPECT_EQ(to_csubstr(NodeType(DOCVAL).type_str()), "DOCVAL");
EXPECT_EQ(to_csubstr(NodeType(DOC).type_str()), "DOC");
EXPECT_EQ(to_csubstr(NodeType(STREAM).type_str()), "STREAM");
EXPECT_EQ(to_csubstr(NodeType(NOTYPE).type_str()), "NOTYPE");
EXPECT_EQ(to_csubstr(NodeType(KEYVAL|KEYNIL).type_str()), "KEYVAL***");
EXPECT_EQ(to_csubstr(NodeType(KEYVAL|VALNIL).type_str()), "KEYVAL***");
EXPECT_EQ(to_csubstr(NodeType(KEYVAL|KEYREF).type_str()), "KEYVAL***");
EXPECT_EQ(to_csubstr(NodeType(KEYVAL|VALREF).type_str()), "KEYVAL***");
EXPECT_EQ(to_csubstr(NodeType(KEYVAL|KEYANCH).type_str()), "KEYVAL***");
EXPECT_EQ(to_csubstr(NodeType(KEYVAL|VALANCH).type_str()), "KEYVAL***");
EXPECT_EQ(to_csubstr(NodeType(KEYVAL|KEYREF|VALANCH).type_str()), "KEYVAL***");
EXPECT_EQ(to_csubstr(NodeType(KEYVAL|KEYANCH|VALREF).type_str()), "KEYVAL***");
EXPECT_EQ(to_csubstr(NodeType(KEYMAP|KEYREF).type_str()), "KEYMAP***");
EXPECT_EQ(to_csubstr(NodeType(KEYMAP|VALREF).type_str()), "KEYMAP***");
EXPECT_EQ(to_csubstr(NodeType(KEYMAP|KEYANCH).type_str()), "KEYMAP***");
EXPECT_EQ(to_csubstr(NodeType(KEYMAP|VALANCH).type_str()), "KEYMAP***");
EXPECT_EQ(to_csubstr(NodeType(KEYMAP|KEYREF|VALANCH).type_str()), "KEYMAP***");
EXPECT_EQ(to_csubstr(NodeType(KEYMAP|KEYANCH|VALREF).type_str()), "KEYMAP***");
EXPECT_EQ(to_csubstr(NodeType(KEYSEQ|KEYREF).type_str()), "KEYSEQ***");
EXPECT_EQ(to_csubstr(NodeType(KEYSEQ|VALREF).type_str()), "KEYSEQ***");
EXPECT_EQ(to_csubstr(NodeType(KEYSEQ|KEYANCH).type_str()), "KEYSEQ***");
EXPECT_EQ(to_csubstr(NodeType(KEYSEQ|VALANCH).type_str()), "KEYSEQ***");
EXPECT_EQ(to_csubstr(NodeType(KEYSEQ|KEYREF|VALANCH).type_str()), "KEYSEQ***");
EXPECT_EQ(to_csubstr(NodeType(KEYSEQ|KEYANCH|VALREF).type_str()), "KEYSEQ***");
EXPECT_EQ(to_csubstr(NodeType(DOCSEQ|VALANCH).type_str()), "DOCSEQ***");
EXPECT_EQ(to_csubstr(NodeType(DOCSEQ|VALREF).type_str()), "DOCSEQ***");
EXPECT_EQ(to_csubstr(NodeType(DOCMAP|VALANCH).type_str()), "DOCMAP***");
EXPECT_EQ(to_csubstr(NodeType(DOCMAP|VALREF).type_str()), "DOCMAP***");
EXPECT_EQ(to_csubstr(NodeType(DOCVAL|VALANCH).type_str()), "DOCVAL***");
EXPECT_EQ(to_csubstr(NodeType(DOCVAL|VALREF).type_str()), "DOCVAL***");
EXPECT_EQ(to_csubstr(NodeType(KEY|KEYREF).type_str()), "KEY***");
EXPECT_EQ(to_csubstr(NodeType(KEY|KEYANCH).type_str()), "KEY***");
EXPECT_EQ(to_csubstr(NodeType(VAL|VALREF).type_str()), "VAL***");
EXPECT_EQ(to_csubstr(NodeType(VAL|VALANCH).type_str()), "VAL***");
EXPECT_EQ(to_csubstr(NodeType(MAP|VALREF).type_str()), "MAP***");
EXPECT_EQ(to_csubstr(NodeType(MAP|VALANCH).type_str()), "MAP***");
EXPECT_EQ(to_csubstr(NodeType(SEQ|VALREF).type_str()), "SEQ***");
EXPECT_EQ(to_csubstr(NodeType(SEQ|VALANCH).type_str()), "SEQ***");
EXPECT_EQ(to_csubstr(NodeType(DOC|VALREF).type_str()), "DOC***");
EXPECT_EQ(to_csubstr(NodeType(DOC|VALANCH).type_str()), "DOC***");
EXPECT_EQ(to_csubstr(NodeType(KEYREF).type_str()), "(unk)");
EXPECT_EQ(to_csubstr(NodeType(VALREF).type_str()), "(unk)");
EXPECT_EQ(to_csubstr(NodeType(KEYANCH).type_str()), "(unk)");
EXPECT_EQ(to_csubstr(NodeType(VALANCH).type_str()), "(unk)");
EXPECT_EQ(to_csubstr(NodeType(NOTYPE).type_str()), "NOTYPE");
}
TEST(NodeType, type_str)
{
{
char bufsmall[2];
EXPECT_EQ(NodeType().type_str(bufsmall).len, 1 + 6); // NOTYPE
EXPECT_EQ(NodeType().type_str(bufsmall).str, nullptr); // NOTYPE
EXPECT_EQ(NodeType(VAL).type_str(bufsmall).len, 1 + 3);
EXPECT_EQ(NodeType(VAL).type_str(bufsmall).str, nullptr);
EXPECT_EQ(NodeType(KEYVAL).type_str(bufsmall).len, 1 + 7);
EXPECT_EQ(NodeType(KEYVAL|KEYANCH|VALANCH).type_str(bufsmall).len, 1 + 19);
EXPECT_EQ(NodeType(KEYVAL|KEYANCH|VALANCH).type_str(bufsmall).str, nullptr);
}
#define teststr(bits, str) \
{ \
char buf[128] = {0}; \
memset(buf, 1, sizeof(buf)); \
csubstr expected = str; \
csubstr actual = NodeType(bits).type_str(buf); \
ASSERT_LT(actual.len + 1, C4_COUNTOF(buf)); \
EXPECT_EQ(actual, expected); \
EXPECT_EQ(NodeType(bits).type_str(buf), expected); \
EXPECT_EQ(buf[expected.len], '\0'); \
}
teststr(0, "NOTYPE")
teststr(NOTYPE, "NOTYPE")
teststr(STREAM, "STREAM")
teststr(DOC, "DOC")
teststr(KEY, "KEY")
teststr(KEYNIL, "KNIL")
teststr(KEYTAG, "KTAG")
teststr(KEYANCH, "KANCH")
teststr(KEYREF, "KREF")
teststr(KEY_LITERAL, "KLITERAL")
teststr(KEY_FOLDED, "KFOLDED")
teststr(KEY_SQUO, "KSQUO")
teststr(KEY_DQUO, "KDQUO")
teststr(KEY_PLAIN, "KPLAIN")
teststr(KEY_UNFILT, "KUNFILT")
teststr(VAL, "VAL")
teststr(VALNIL, "VNIL")
teststr(VALTAG, "VTAG")
teststr(VALANCH, "VANCH")
teststr(VALREF, "VREF")
teststr(VAL_LITERAL, "VLITERAL")
teststr(VAL_FOLDED, "VFOLDED")
teststr(VAL_SQUO, "VSQUO")
teststr(VAL_DQUO, "VDQUO")
teststr(VAL_PLAIN, "VPLAIN")
teststr(VAL_UNFILT, "VUNFILT")
teststr(MAP, "MAP")
teststr(SEQ, "SEQ")
teststr(FLOW_SL, "FLOWSL")
teststr(FLOW_ML, "FLOWML")
teststr(BLOCK, "BLCK")
teststr(KEYVAL, "KEY|VAL")
teststr(KEYMAP, "KEY|MAP")
teststr(KEYVAL|KEYANCH|VALANCH, "KEY|KANCH|VAL|VANCH")
#undef teststr
}
TEST(NodeType, scalar_style_choose_json)
{
EXPECT_EQ(scalar_style_json_choose("true"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_json_choose("false"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_json_choose("null"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_json_choose("0.1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_json_choose("-0.1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_json_choose("+0.1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_json_choose(".1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_json_choose("+.1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_json_choose("-.1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_json_choose("01"), SCALAR_DQUO);
EXPECT_EQ(scalar_style_json_choose("foo"), SCALAR_DQUO);
EXPECT_EQ(scalar_style_json_choose("bar"), SCALAR_DQUO);
}
TEST(NodeType, scalar_style_choose)
{
EXPECT_EQ(scalar_style_choose(" \n\t"), SCALAR_DQUO);
EXPECT_EQ(scalar_style_choose("-.inf"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("-.INF"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("-.034"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("-.034x"), SCALAR_SQUO);
EXPECT_EQ(scalar_style_choose("2.35e-10"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("-2.35e-10"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("+2.35e-10"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("0.1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("-0.1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("+0.1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("01"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("0x1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("0o1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("0b1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("0x1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("0o1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("0b1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("-01"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("-0x1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("-0o1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("-0b1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("-0x1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("-0o1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("-0b1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("+01"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("+0x1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("+0o1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("+0b1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("+0x1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("+0o1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("+0b1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("01"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("0X1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("0O1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("0B1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("0X1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("0O1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("0B1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("-01"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("-0X1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("-0O1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("-0B1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("-0X1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("-0O1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("-0B1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("+01"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("+0X1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("+0O1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("+0B1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("+0X1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("+0O1"), SCALAR_PLAIN);
EXPECT_EQ(scalar_style_choose("+0B1"), SCALAR_PLAIN);
}
TEST(NodeType, scalar_style_query_plain)
{
EXPECT_TRUE(scalar_style_query_plain("-.inf"));
EXPECT_TRUE(scalar_style_query_plain("-.INF"));
EXPECT_TRUE(scalar_style_query_plain("-.034"));
EXPECT_FALSE(scalar_style_query_plain("-.034x"));
EXPECT_TRUE(scalar_style_query_plain("2.35e-10"));
EXPECT_TRUE(scalar_style_query_plain("-2.35e-10"));
EXPECT_TRUE(scalar_style_query_plain("+2.35e-10"));
EXPECT_TRUE(scalar_style_query_plain("0.1"));
EXPECT_TRUE(scalar_style_query_plain("-0.1"));
EXPECT_TRUE(scalar_style_query_plain("+0.1"));
EXPECT_TRUE(scalar_style_query_plain("01"));
EXPECT_TRUE(scalar_style_query_plain("0x1"));
EXPECT_TRUE(scalar_style_query_plain("0o1"));
EXPECT_TRUE(scalar_style_query_plain("0b1"));
EXPECT_TRUE(scalar_style_query_plain("0x1"));
EXPECT_TRUE(scalar_style_query_plain("0o1"));
EXPECT_TRUE(scalar_style_query_plain("0b1"));
EXPECT_TRUE(scalar_style_query_plain("+01"));
EXPECT_TRUE(scalar_style_query_plain("+0x1"));
EXPECT_TRUE(scalar_style_query_plain("+0o1"));
EXPECT_TRUE(scalar_style_query_plain("+0b1"));
EXPECT_TRUE(scalar_style_query_plain("+0x1"));
EXPECT_TRUE(scalar_style_query_plain("+0o1"));
EXPECT_TRUE(scalar_style_query_plain("+0b1"));
EXPECT_TRUE(scalar_style_query_plain("-01"));
EXPECT_TRUE(scalar_style_query_plain("-0x1"));
EXPECT_TRUE(scalar_style_query_plain("-0o1"));
EXPECT_TRUE(scalar_style_query_plain("-0b1"));
EXPECT_TRUE(scalar_style_query_plain("-0x1"));
EXPECT_TRUE(scalar_style_query_plain("-0o1"));
EXPECT_TRUE(scalar_style_query_plain("-0b1"));
EXPECT_TRUE(scalar_style_query_plain("0X1"));
EXPECT_TRUE(scalar_style_query_plain("0O1"));
EXPECT_TRUE(scalar_style_query_plain("0B1"));
EXPECT_TRUE(scalar_style_query_plain("0X1"));
EXPECT_TRUE(scalar_style_query_plain("0O1"));
EXPECT_TRUE(scalar_style_query_plain("0B1"));
EXPECT_TRUE(scalar_style_query_plain("+01"));
EXPECT_TRUE(scalar_style_query_plain("+0X1"));
EXPECT_TRUE(scalar_style_query_plain("+0O1"));
EXPECT_TRUE(scalar_style_query_plain("+0B1"));
EXPECT_TRUE(scalar_style_query_plain("+0X1"));
EXPECT_TRUE(scalar_style_query_plain("+0O1"));
EXPECT_TRUE(scalar_style_query_plain("+0B1"));
EXPECT_TRUE(scalar_style_query_plain("-01"));
EXPECT_TRUE(scalar_style_query_plain("-0X1"));
EXPECT_TRUE(scalar_style_query_plain("-0O1"));
EXPECT_TRUE(scalar_style_query_plain("-0B1"));
EXPECT_TRUE(scalar_style_query_plain("-0X1"));
EXPECT_TRUE(scalar_style_query_plain("-0O1"));
EXPECT_TRUE(scalar_style_query_plain("-0B1"));
}
TEST(NodeType, is_stream)
{
EXPECT_FALSE(NodeType(NOTYPE).is_stream());
EXPECT_TRUE(NodeType(STREAM).is_stream());
}
TEST(NodeType, is_doc)
{
EXPECT_FALSE(NodeType(NOTYPE).is_doc());
EXPECT_TRUE(NodeType(DOC).is_doc());
}
TEST(NodeType, is_container)
{
EXPECT_FALSE(NodeType(NOTYPE).is_container());
EXPECT_FALSE(NodeType(VAL).is_container());
EXPECT_FALSE(NodeType(KEY).is_container());
EXPECT_FALSE(NodeType(KEYVAL).is_container());
EXPECT_TRUE(NodeType(MAP).is_container());
EXPECT_TRUE(NodeType(SEQ).is_container());
EXPECT_TRUE(NodeType(KEYMAP).is_container());
EXPECT_TRUE(NodeType(KEYSEQ).is_container());
EXPECT_TRUE(NodeType(DOCMAP).is_container());
EXPECT_TRUE(NodeType(DOCSEQ).is_container());
}
TEST(NodeType, is_map)
{
EXPECT_FALSE(NodeType(NOTYPE).is_map());
EXPECT_FALSE(NodeType(VAL).is_map());
EXPECT_FALSE(NodeType(KEY).is_map());
EXPECT_TRUE(NodeType(MAP).is_map());
EXPECT_TRUE(NodeType(KEYMAP).is_map());
EXPECT_FALSE(NodeType(SEQ).is_map());
EXPECT_FALSE(NodeType(KEYSEQ).is_map());
}
TEST(NodeType, is_seq)
{
EXPECT_FALSE(NodeType(NOTYPE).is_seq());
EXPECT_FALSE(NodeType(VAL).is_seq());
EXPECT_FALSE(NodeType(KEY).is_seq());
EXPECT_FALSE(NodeType(MAP).is_seq());
EXPECT_FALSE(NodeType(KEYMAP).is_seq());
EXPECT_TRUE(NodeType(SEQ).is_seq());
EXPECT_TRUE(NodeType(KEYSEQ).is_seq());
}
TEST(NodeType, has_val)
{
EXPECT_FALSE(NodeType(NOTYPE).has_val());
EXPECT_FALSE(NodeType(KEY).has_val());
EXPECT_TRUE(NodeType(VAL).has_val());
EXPECT_TRUE(NodeType(DOCVAL).has_val());
EXPECT_TRUE(NodeType(KEYVAL).has_val());
EXPECT_FALSE(NodeType(KEYMAP).has_val());
EXPECT_FALSE(NodeType(KEYSEQ).has_val());
}
TEST(NodeType, is_val)
{
EXPECT_FALSE(NodeType(NOTYPE).is_val());
EXPECT_FALSE(NodeType(KEY).is_val());
EXPECT_TRUE(NodeType(VAL).is_val());
EXPECT_TRUE(NodeType(DOCVAL).is_val());
EXPECT_FALSE(NodeType(KEYVAL).is_val());
EXPECT_FALSE(NodeType(KEYMAP).is_val());
EXPECT_FALSE(NodeType(KEYSEQ).is_val());
}
TEST(NodeType, has_null_val)
{
EXPECT_FALSE(NodeType(NOTYPE).val_is_null());
EXPECT_FALSE(NodeType(VAL).val_is_null());
EXPECT_FALSE(NodeType(KEY|KEYNIL).val_is_null());
EXPECT_TRUE(NodeType(VAL|VALNIL).val_is_null());
EXPECT_FALSE(NodeType(KEYVAL).val_is_null());
EXPECT_FALSE(NodeType(KEYMAP).val_is_null());
EXPECT_FALSE(NodeType(KEYSEQ).val_is_null());
EXPECT_TRUE(NodeType(KEYVAL|VALNIL).val_is_null());
EXPECT_TRUE(NodeType(KEYMAP|VALNIL).val_is_null());
EXPECT_TRUE(NodeType(KEYSEQ|VALNIL).val_is_null());
}
TEST(NodeType, has_key)
{
EXPECT_FALSE(NodeType(NOTYPE).has_key());
EXPECT_TRUE(NodeType(KEY).has_key());
EXPECT_FALSE(NodeType(VAL).has_key());
EXPECT_TRUE(NodeType(KEYVAL).has_key());
EXPECT_TRUE(NodeType(KEYMAP).has_key());
EXPECT_TRUE(NodeType(KEYSEQ).has_key());
}
TEST(NodeType, key_is_null)
{
EXPECT_FALSE(NodeType(NOTYPE).key_is_null());
EXPECT_FALSE(NodeType(KEY).key_is_null());
EXPECT_TRUE(NodeType(KEY|KEYNIL).key_is_null());
EXPECT_FALSE(NodeType(VAL|VALNIL).key_is_null());
EXPECT_FALSE(NodeType(KEYVAL).key_is_null());
EXPECT_FALSE(NodeType(KEYMAP).key_is_null());
EXPECT_FALSE(NodeType(KEYSEQ).key_is_null());
EXPECT_TRUE(NodeType(KEYVAL|KEYNIL).key_is_null());
EXPECT_TRUE(NodeType(KEYMAP|KEYNIL).key_is_null());
EXPECT_TRUE(NodeType(KEYSEQ|KEYNIL).key_is_null());
}
TEST(NodeType, is_keyval)
{
EXPECT_FALSE(NodeType(NOTYPE).is_keyval());
EXPECT_FALSE(NodeType(KEY).is_keyval());
EXPECT_FALSE(NodeType(VAL).is_keyval());
EXPECT_TRUE(NodeType(KEYVAL).is_keyval());
EXPECT_FALSE(NodeType(DOCVAL).is_keyval());
EXPECT_FALSE(NodeType(KEYMAP).is_keyval());
EXPECT_FALSE(NodeType(KEYSEQ).is_keyval());
}
TEST(NodeType, has_key_tag)
{
EXPECT_FALSE(NodeType().has_key_tag());
EXPECT_TRUE(NodeType(KEYTAG).has_key_tag());
EXPECT_TRUE(NodeType(KEY|KEYTAG).has_key_tag());
}
TEST(NodeType, has_val_tag)
{
EXPECT_FALSE(NodeType().has_val_tag());
EXPECT_TRUE(NodeType(VALTAG).has_val_tag());
EXPECT_TRUE(NodeType(VAL|VALTAG).has_val_tag());
}
TEST(NodeType, has_key_anchor)
{
EXPECT_FALSE(NodeType().has_key_anchor());
EXPECT_TRUE(NodeType(KEYANCH).has_key_anchor());
EXPECT_TRUE(NodeType(KEY|KEYANCH).has_key_anchor());
}
TEST(NodeType, has_val_anchor)
{
EXPECT_FALSE(NodeType().has_val_anchor());
EXPECT_TRUE(NodeType(VALANCH).has_val_anchor());
EXPECT_TRUE(NodeType(VAL|VALANCH).has_val_anchor());
}
TEST(NodeType, has_anchor)
{
EXPECT_FALSE(NodeType().has_anchor());
EXPECT_TRUE(NodeType(VALANCH).has_anchor());
EXPECT_TRUE(NodeType(KEYANCH).has_anchor());
EXPECT_TRUE(NodeType(KEYANCH|VALANCH).has_anchor());
EXPECT_TRUE(NodeType(KEY|VALANCH).has_anchor());
EXPECT_TRUE(NodeType(VAL|KEYANCH).has_anchor());
EXPECT_TRUE(NodeType(KEY|KEYANCH).has_anchor());
EXPECT_TRUE(NodeType(VAL|VALANCH).has_anchor());
}
TEST(NodeType, is_key_ref)
{
EXPECT_FALSE(NodeType().is_key_ref());
EXPECT_TRUE(NodeType(KEYREF).is_key_ref());
EXPECT_TRUE(NodeType(KEY|KEYREF).is_key_ref());
}
TEST(NodeType, is_val_ref)
{
EXPECT_FALSE(NodeType().is_val_ref());
EXPECT_TRUE(NodeType(VALREF).is_val_ref());
EXPECT_TRUE(NodeType(VAL|VALREF).is_val_ref());
}
TEST(NodeType, is_ref)
{
EXPECT_FALSE(NodeType().is_ref());
EXPECT_FALSE(NodeType(KEYVAL).is_ref());
EXPECT_TRUE(NodeType(KEYREF).is_ref());
EXPECT_TRUE(NodeType(VALREF).is_ref());
EXPECT_TRUE(NodeType(KEY|VALREF).is_ref());
EXPECT_TRUE(NodeType(VAL|KEYREF).is_ref());
EXPECT_TRUE(NodeType(KEYREF|VALREF).is_ref());
}
TEST(NodeType, is_key_quoted)
{
EXPECT_FALSE(NodeType().is_key_quoted());
EXPECT_TRUE(NodeType(KEYQUO).is_key_quoted());
EXPECT_TRUE(NodeType(KEY|KEYQUO).is_key_quoted());
}
TEST(NodeType, is_val_quoted)
{
EXPECT_FALSE(NodeType().is_val_quoted());
EXPECT_TRUE(NodeType(VALQUO).is_val_quoted());
EXPECT_TRUE(NodeType(VAL|VALQUO).is_val_quoted());
}
TEST(NodeType, is_quoted)
{
EXPECT_FALSE(NodeType().is_quoted());
EXPECT_TRUE(NodeType(KEYQUO).is_quoted());
EXPECT_TRUE(NodeType(VALQUO).is_quoted());
EXPECT_TRUE(NodeType(KEYQUO|VALQUO).is_quoted());
EXPECT_TRUE(NodeType(KEY|KEYQUO).is_quoted());
EXPECT_TRUE(NodeType(VAL|VALQUO).is_quoted());
EXPECT_TRUE(NodeType(KEY|VALQUO).is_quoted());
EXPECT_TRUE(NodeType(VAL|KEYQUO).is_quoted());
}
} // namespace yml
} // namespace c4
|
