CoCalc -- nodes

GitHub Repository: freebsd/freebsd-src
Path: blob/main/contrib/kyua/utils/config/nodes_test.cpp
⁴⁸⁰⁸¹ views
1
// Copyright 2012 The Kyua Authors.
2
// All rights reserved.
3
//
4
// Redistribution and use in source and binary forms, with or without
5
// modification, are permitted provided that the following conditions are
6
// met:
7
//
8
// * Redistributions of source code must retain the above copyright
9
//   notice, this list of conditions and the following disclaimer.
10
// * Redistributions in binary form must reproduce the above copyright
11
//   notice, this list of conditions and the following disclaimer in the
12
//   documentation and/or other materials provided with the distribution.
13
// * Neither the name of Google Inc. nor the names of its contributors
14
//   may be used to endorse or promote products derived from this software
15
//   without specific prior written permission.
16
//
17
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28

29
#include "utils/config/nodes.ipp"
30

31
#include <atf-c++.hpp>
32

33
#include <lutok/state.ipp>
34

35
#include "utils/config/exceptions.hpp"
36
#include "utils/config/keys.hpp"
37
#include "utils/defs.hpp"
38

39
namespace config = utils::config;
40

41

42
namespace {
43

44

45
/// Typed leaf node that specializes the validate() method.
46
class validation_node : public config::int_node {
47
    /// Checks a given value for validity against a fake value.
48
    ///
49
    /// \param new_value The value to validate.
50
    ///
51
    /// \throw value_error If the value is not valid.
52
    void
53
    validate(const value_type& new_value) const
54
    {
55
        if (new_value == 12345)
56
            throw config::value_error("Custom validate method");
57
    }
58
};
59

60

61
/// Set node that specializes the validate() method.
62
class set_validation_node : public config::strings_set_node {
63
    /// Checks a given value for validity against a fake value.
64
    ///
65
    /// \param new_value The value to validate.
66
    ///
67
    /// \throw value_error If the value is not valid.
68
    void
69
    validate(const value_type& new_value) const
70
    {
71
        for (value_type::const_iterator iter = new_value.begin();
72
             iter != new_value.end(); ++iter)
73
            if (*iter == "throw")
74
                throw config::value_error("Custom validate method");
75
    }
76
};
77

78

79
}  // anonymous namespace
80

81

82
ATF_TEST_CASE_WITHOUT_HEAD(bool_node__deep_copy);
83
ATF_TEST_CASE_BODY(bool_node__deep_copy)
84
{
85
    config::bool_node node;
86
    node.set(true);
87
    config::detail::base_node* raw_copy = node.deep_copy();
88
    config::bool_node* copy = static_cast< config::bool_node* >(raw_copy);
89
    ATF_REQUIRE(copy->value());
90
    copy->set(false);
91
    ATF_REQUIRE(node.value());
92
    ATF_REQUIRE(!copy->value());
93
    delete copy;
94
}
95

96

97
ATF_TEST_CASE_WITHOUT_HEAD(bool_node__is_set_and_set);
98
ATF_TEST_CASE_BODY(bool_node__is_set_and_set)
99
{
100
    config::bool_node node;
101
    ATF_REQUIRE(!node.is_set());
102
    node.set(false);
103
    ATF_REQUIRE( node.is_set());
104
}
105

106

107
ATF_TEST_CASE_WITHOUT_HEAD(bool_node__value_and_set);
108
ATF_TEST_CASE_BODY(bool_node__value_and_set)
109
{
110
    config::bool_node node;
111
    node.set(false);
112
    ATF_REQUIRE(!node.value());
113
    node.set(true);
114
    ATF_REQUIRE( node.value());
115
}
116

117

118
ATF_TEST_CASE_WITHOUT_HEAD(bool_node__push_lua);
119
ATF_TEST_CASE_BODY(bool_node__push_lua)
120
{
121
    lutok::state state;
122

123
    config::bool_node node;
124
    node.set(true);
125
    node.push_lua(state);
126
    ATF_REQUIRE(state.is_boolean(-1));
127
    ATF_REQUIRE(state.to_boolean(-1));
128
    state.pop(1);
129
}
130

131

132
ATF_TEST_CASE_WITHOUT_HEAD(bool_node__set_lua__ok);
133
ATF_TEST_CASE_BODY(bool_node__set_lua__ok)
134
{
135
    lutok::state state;
136

137
    config::bool_node node;
138
    state.push_boolean(false);
139
    node.set_lua(state, -1);
140
    state.pop(1);
141
    ATF_REQUIRE(!node.value());
142
}
143

144

145
ATF_TEST_CASE_WITHOUT_HEAD(bool_node__set_lua__invalid_value);
146
ATF_TEST_CASE_BODY(bool_node__set_lua__invalid_value)
147
{
148
    lutok::state state;
149

150
    config::bool_node node;
151
    state.push_string("foo bar");
152
    ATF_REQUIRE_THROW(config::value_error, node.set_lua(state, -1));
153
    state.pop(1);
154
    ATF_REQUIRE(!node.is_set());
155
}
156

157

158
ATF_TEST_CASE_WITHOUT_HEAD(bool_node__set_string__ok);
159
ATF_TEST_CASE_BODY(bool_node__set_string__ok)
160
{
161
    config::bool_node node;
162
    node.set_string("false");
163
    ATF_REQUIRE(!node.value());
164
    node.set_string("true");
165
    ATF_REQUIRE( node.value());
166
}
167

168

169
ATF_TEST_CASE_WITHOUT_HEAD(bool_node__set_string__invalid_value);
170
ATF_TEST_CASE_BODY(bool_node__set_string__invalid_value)
171
{
172
    config::bool_node node;
173
    ATF_REQUIRE_THROW(config::value_error, node.set_string("12345"));
174
    ATF_REQUIRE(!node.is_set());
175
}
176

177

178
ATF_TEST_CASE_WITHOUT_HEAD(bool_node__to_string);
179
ATF_TEST_CASE_BODY(bool_node__to_string)
180
{
181
    config::bool_node node;
182
    node.set(false);
183
    ATF_REQUIRE_EQ("false", node.to_string());
184
    node.set(true);
185
    ATF_REQUIRE_EQ("true", node.to_string());
186
}
187

188

189
ATF_TEST_CASE_WITHOUT_HEAD(int_node__deep_copy);
190
ATF_TEST_CASE_BODY(int_node__deep_copy)
191
{
192
    config::int_node node;
193
    node.set(5);
194
    config::detail::base_node* raw_copy = node.deep_copy();
195
    config::int_node* copy = static_cast< config::int_node* >(raw_copy);
196
    ATF_REQUIRE_EQ(5, copy->value());
197
    copy->set(10);
198
    ATF_REQUIRE_EQ(5, node.value());
199
    ATF_REQUIRE_EQ(10, copy->value());
200
    delete copy;
201
}
202

203

204
ATF_TEST_CASE_WITHOUT_HEAD(int_node__is_set_and_set);
205
ATF_TEST_CASE_BODY(int_node__is_set_and_set)
206
{
207
    config::int_node node;
208
    ATF_REQUIRE(!node.is_set());
209
    node.set(20);
210
    ATF_REQUIRE( node.is_set());
211
}
212

213

214
ATF_TEST_CASE_WITHOUT_HEAD(int_node__value_and_set);
215
ATF_TEST_CASE_BODY(int_node__value_and_set)
216
{
217
    config::int_node node;
218
    node.set(20);
219
    ATF_REQUIRE_EQ(20, node.value());
220
    node.set(0);
221
    ATF_REQUIRE_EQ(0, node.value());
222
}
223

224

225
ATF_TEST_CASE_WITHOUT_HEAD(int_node__push_lua);
226
ATF_TEST_CASE_BODY(int_node__push_lua)
227
{
228
    lutok::state state;
229

230
    config::int_node node;
231
    node.set(754);
232
    node.push_lua(state);
233
    ATF_REQUIRE(state.is_number(-1));
234
    ATF_REQUIRE_EQ(754, state.to_integer(-1));
235
    state.pop(1);
236
}
237

238

239
ATF_TEST_CASE_WITHOUT_HEAD(int_node__set_lua__ok);
240
ATF_TEST_CASE_BODY(int_node__set_lua__ok)
241
{
242
    lutok::state state;
243

244
    config::int_node node;
245
    state.push_integer(123);
246
    state.push_string("456");
247
    node.set_lua(state, -2);
248
    ATF_REQUIRE_EQ(123, node.value());
249
    node.set_lua(state, -1);
250
    ATF_REQUIRE_EQ(456, node.value());
251
    state.pop(2);
252
}
253

254

255
ATF_TEST_CASE_WITHOUT_HEAD(int_node__set_lua__invalid_value);
256
ATF_TEST_CASE_BODY(int_node__set_lua__invalid_value)
257
{
258
    lutok::state state;
259

260
    config::int_node node;
261
    state.push_boolean(true);
262
    ATF_REQUIRE_THROW(config::value_error, node.set_lua(state, -1));
263
    state.pop(1);
264
    ATF_REQUIRE(!node.is_set());
265
}
266

267

268
ATF_TEST_CASE_WITHOUT_HEAD(int_node__set_string__ok);
269
ATF_TEST_CASE_BODY(int_node__set_string__ok)
270
{
271
    config::int_node node;
272
    node.set_string("178");
273
    ATF_REQUIRE_EQ(178, node.value());
274
    node.set_string("-123");
275
    ATF_REQUIRE_EQ(-123, node.value());
276
}
277

278

279
ATF_TEST_CASE_WITHOUT_HEAD(int_node__set_string__invalid_value);
280
ATF_TEST_CASE_BODY(int_node__set_string__invalid_value)
281
{
282
    config::int_node node;
283
    ATF_REQUIRE_THROW(config::value_error, node.set_string(" 23"));
284
    ATF_REQUIRE(!node.is_set());
285
}
286

287

288
ATF_TEST_CASE_WITHOUT_HEAD(int_node__to_string);
289
ATF_TEST_CASE_BODY(int_node__to_string)
290
{
291
    config::int_node node;
292
    node.set(89);
293
    ATF_REQUIRE_EQ("89", node.to_string());
294
    node.set(-57);
295
    ATF_REQUIRE_EQ("-57", node.to_string());
296
}
297

298

299
ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__deep_copy);
300
ATF_TEST_CASE_BODY(positive_int_node__deep_copy)
301
{
302
    config::positive_int_node node;
303
    node.set(5);
304
    config::detail::base_node* raw_copy = node.deep_copy();
305
    config::positive_int_node* copy = static_cast< config::positive_int_node* >(
306
        raw_copy);
307
    ATF_REQUIRE_EQ(5, copy->value());
308
    copy->set(10);
309
    ATF_REQUIRE_EQ(5, node.value());
310
    ATF_REQUIRE_EQ(10, copy->value());
311
    delete copy;
312
}
313

314

315
ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__is_set_and_set);
316
ATF_TEST_CASE_BODY(positive_int_node__is_set_and_set)
317
{
318
    config::positive_int_node node;
319
    ATF_REQUIRE(!node.is_set());
320
    node.set(20);
321
    ATF_REQUIRE( node.is_set());
322
}
323

324

325
ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__value_and_set);
326
ATF_TEST_CASE_BODY(positive_int_node__value_and_set)
327
{
328
    config::positive_int_node node;
329
    node.set(20);
330
    ATF_REQUIRE_EQ(20, node.value());
331
    node.set(1);
332
    ATF_REQUIRE_EQ(1, node.value());
333
}
334

335

336
ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__push_lua);
337
ATF_TEST_CASE_BODY(positive_int_node__push_lua)
338
{
339
    lutok::state state;
340

341
    config::positive_int_node node;
342
    node.set(754);
343
    node.push_lua(state);
344
    ATF_REQUIRE(state.is_number(-1));
345
    ATF_REQUIRE_EQ(754, state.to_integer(-1));
346
    state.pop(1);
347
}
348

349

350
ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__set_lua__ok);
351
ATF_TEST_CASE_BODY(positive_int_node__set_lua__ok)
352
{
353
    lutok::state state;
354

355
    config::positive_int_node node;
356
    state.push_integer(123);
357
    state.push_string("456");
358
    node.set_lua(state, -2);
359
    ATF_REQUIRE_EQ(123, node.value());
360
    node.set_lua(state, -1);
361
    ATF_REQUIRE_EQ(456, node.value());
362
    state.pop(2);
363
}
364

365

366
ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__set_lua__invalid_value);
367
ATF_TEST_CASE_BODY(positive_int_node__set_lua__invalid_value)
368
{
369
    lutok::state state;
370

371
    config::positive_int_node node;
372
    state.push_boolean(true);
373
    ATF_REQUIRE_THROW(config::value_error, node.set_lua(state, -1));
374
    state.pop(1);
375
    ATF_REQUIRE(!node.is_set());
376
    state.push_integer(0);
377
    ATF_REQUIRE_THROW(config::value_error, node.set_lua(state, -1));
378
    state.pop(1);
379
    ATF_REQUIRE(!node.is_set());
380
}
381

382

383
ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__set_string__ok);
384
ATF_TEST_CASE_BODY(positive_int_node__set_string__ok)
385
{
386
    config::positive_int_node node;
387
    node.set_string("1");
388
    ATF_REQUIRE_EQ(1, node.value());
389
    node.set_string("178");
390
    ATF_REQUIRE_EQ(178, node.value());
391
}
392

393

394
ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__set_string__invalid_value);
395
ATF_TEST_CASE_BODY(positive_int_node__set_string__invalid_value)
396
{
397
    config::positive_int_node node;
398
    ATF_REQUIRE_THROW(config::value_error, node.set_string(" 23"));
399
    ATF_REQUIRE(!node.is_set());
400
    ATF_REQUIRE_THROW(config::value_error, node.set_string("0"));
401
    ATF_REQUIRE(!node.is_set());
402
    ATF_REQUIRE_THROW(config::value_error, node.set_string("-5"));
403
    ATF_REQUIRE(!node.is_set());
404
}
405

406

407
ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__to_string);
408
ATF_TEST_CASE_BODY(positive_int_node__to_string)
409
{
410
    config::positive_int_node node;
411
    node.set(89);
412
    ATF_REQUIRE_EQ("89", node.to_string());
413
}
414

415

416
ATF_TEST_CASE_WITHOUT_HEAD(string_node__deep_copy);
417
ATF_TEST_CASE_BODY(string_node__deep_copy)
418
{
419
    config::string_node node;
420
    node.set("first");
421
    config::detail::base_node* raw_copy = node.deep_copy();
422
    config::string_node* copy = static_cast< config::string_node* >(raw_copy);
423
    ATF_REQUIRE_EQ("first", copy->value());
424
    copy->set("second");
425
    ATF_REQUIRE_EQ("first", node.value());
426
    ATF_REQUIRE_EQ("second", copy->value());
427
    delete copy;
428
}
429

430

431
ATF_TEST_CASE_WITHOUT_HEAD(string_node__is_set_and_set);
432
ATF_TEST_CASE_BODY(string_node__is_set_and_set)
433
{
434
    config::string_node node;
435
    ATF_REQUIRE(!node.is_set());
436
    node.set("foo");
437
    ATF_REQUIRE( node.is_set());
438
}
439

440

441
ATF_TEST_CASE_WITHOUT_HEAD(string_node__value_and_set);
442
ATF_TEST_CASE_BODY(string_node__value_and_set)
443
{
444
    config::string_node node;
445
    node.set("foo");
446
    ATF_REQUIRE_EQ("foo", node.value());
447
    node.set("");
448
    ATF_REQUIRE_EQ("", node.value());
449
}
450

451

452
ATF_TEST_CASE_WITHOUT_HEAD(string_node__push_lua);
453
ATF_TEST_CASE_BODY(string_node__push_lua)
454
{
455
    lutok::state state;
456

457
    config::string_node node;
458
    node.set("some message");
459
    node.push_lua(state);
460
    ATF_REQUIRE(state.is_string(-1));
461
    ATF_REQUIRE_EQ("some message", state.to_string(-1));
462
    state.pop(1);
463
}
464

465

466
ATF_TEST_CASE_WITHOUT_HEAD(string_node__set_lua__ok);
467
ATF_TEST_CASE_BODY(string_node__set_lua__ok)
468
{
469
    lutok::state state;
470

471
    config::string_node node;
472
    state.push_string("text 1");
473
    state.push_integer(231);
474
    node.set_lua(state, -2);
475
    ATF_REQUIRE_EQ("text 1", node.value());
476
    node.set_lua(state, -1);
477
    ATF_REQUIRE_EQ("231", node.value());
478
    state.pop(2);
479
}
480

481

482
ATF_TEST_CASE_WITHOUT_HEAD(string_node__set_lua__invalid_value);
483
ATF_TEST_CASE_BODY(string_node__set_lua__invalid_value)
484
{
485
    lutok::state state;
486

487
    config::bool_node node;
488
    state.new_table();
489
    ATF_REQUIRE_THROW(config::value_error, node.set_lua(state, -1));
490
    state.pop(1);
491
    ATF_REQUIRE(!node.is_set());
492
}
493

494

495
ATF_TEST_CASE_WITHOUT_HEAD(string_node__set_string);
496
ATF_TEST_CASE_BODY(string_node__set_string)
497
{
498
    config::string_node node;
499
    node.set_string("abcd efgh");
500
    ATF_REQUIRE_EQ("abcd efgh", node.value());
501
    node.set_string("  1234  ");
502
    ATF_REQUIRE_EQ("  1234  ", node.value());
503
}
504

505

506
ATF_TEST_CASE_WITHOUT_HEAD(string_node__to_string);
507
ATF_TEST_CASE_BODY(string_node__to_string)
508
{
509
    config::string_node node;
510
    node.set("");
511
    ATF_REQUIRE_EQ("", node.to_string());
512
    node.set("aaa");
513
    ATF_REQUIRE_EQ("aaa", node.to_string());
514
}
515

516

517
ATF_TEST_CASE_WITHOUT_HEAD(strings_set_node__deep_copy);
518
ATF_TEST_CASE_BODY(strings_set_node__deep_copy)
519
{
520
    std::set< std::string > value;
521
    config::strings_set_node node;
522
    value.insert("foo");
523
    node.set(value);
524
    config::detail::base_node* raw_copy = node.deep_copy();
525
    config::strings_set_node* copy =
526
        static_cast< config::strings_set_node* >(raw_copy);
527
    value.insert("bar");
528
    ATF_REQUIRE_EQ(1, copy->value().size());
529
    copy->set(value);
530
    ATF_REQUIRE_EQ(1, node.value().size());
531
    ATF_REQUIRE_EQ(2, copy->value().size());
532
    delete copy;
533
}
534

535

536
ATF_TEST_CASE_WITHOUT_HEAD(strings_set_node__is_set_and_set);
537
ATF_TEST_CASE_BODY(strings_set_node__is_set_and_set)
538
{
539
    std::set< std::string > value;
540
    value.insert("foo");
541

542
    config::strings_set_node node;
543
    ATF_REQUIRE(!node.is_set());
544
    node.set(value);
545
    ATF_REQUIRE( node.is_set());
546
}
547

548

549
ATF_TEST_CASE_WITHOUT_HEAD(strings_set_node__value_and_set);
550
ATF_TEST_CASE_BODY(strings_set_node__value_and_set)
551
{
552
    std::set< std::string > value;
553
    value.insert("first");
554

555
    config::strings_set_node node;
556
    node.set(value);
557
    ATF_REQUIRE(value == node.value());
558
    value.clear();
559
    node.set(value);
560
    value.insert("second");
561
    ATF_REQUIRE(node.value().empty());
562
}
563

564

565
ATF_TEST_CASE_WITHOUT_HEAD(strings_set_node__set_string);
566
ATF_TEST_CASE_BODY(strings_set_node__set_string)
567
{
568
    config::strings_set_node node;
569
    {
570
        std::set< std::string > expected;
571
        expected.insert("abcd");
572
        expected.insert("efgh");
573

574
        node.set_string("abcd efgh");
575
        ATF_REQUIRE(expected == node.value());
576
    }
577
    {
578
        std::set< std::string > expected;
579
        expected.insert("1234");
580

581
        node.set_string("  1234  ");
582
        ATF_REQUIRE(expected == node.value());
583
    }
584
}
585

586

587
ATF_TEST_CASE_WITHOUT_HEAD(strings_set_node__to_string);
588
ATF_TEST_CASE_BODY(strings_set_node__to_string)
589
{
590
    std::set< std::string > value;
591
    config::strings_set_node node;
592
    value.insert("second");
593
    value.insert("first");
594
    node.set(value);
595
    ATF_REQUIRE_EQ("first second", node.to_string());
596
}
597

598

599
ATF_TEST_CASE_WITHOUT_HEAD(typed_leaf_node__validate_set);
600
ATF_TEST_CASE_BODY(typed_leaf_node__validate_set)
601
{
602
    validation_node node;
603
    node.set(1234);
604
    ATF_REQUIRE_THROW_RE(config::value_error, "Custom validate method",
605
                         node.set(12345));
606
}
607

608

609
ATF_TEST_CASE_WITHOUT_HEAD(typed_leaf_node__validate_set_string);
610
ATF_TEST_CASE_BODY(typed_leaf_node__validate_set_string)
611
{
612
    validation_node node;
613
    node.set_string("1234");
614
    ATF_REQUIRE_THROW_RE(config::value_error, "Custom validate method",
615
                         node.set_string("12345"));
616
}
617

618

619
ATF_TEST_CASE_WITHOUT_HEAD(base_set_node__validate_set);
620
ATF_TEST_CASE_BODY(base_set_node__validate_set)
621
{
622
    set_validation_node node;
623
    set_validation_node::value_type values;
624
    values.insert("foo");
625
    values.insert("bar");
626
    node.set(values);
627
    values.insert("throw");
628
    values.insert("baz");
629
    ATF_REQUIRE_THROW_RE(config::value_error, "Custom validate method",
630
                         node.set(values));
631
}
632

633

634
ATF_TEST_CASE_WITHOUT_HEAD(base_set_node__validate_set_string);
635
ATF_TEST_CASE_BODY(base_set_node__validate_set_string)
636
{
637
    set_validation_node node;
638
    node.set_string("foo bar");
639
    ATF_REQUIRE_THROW_RE(config::value_error, "Custom validate method",
640
                         node.set_string("foo bar throw baz"));
641
}
642

643

644
ATF_INIT_TEST_CASES(tcs)
645
{
646
    ATF_ADD_TEST_CASE(tcs, bool_node__deep_copy);
647
    ATF_ADD_TEST_CASE(tcs, bool_node__is_set_and_set);
648
    ATF_ADD_TEST_CASE(tcs, bool_node__value_and_set);
649
    ATF_ADD_TEST_CASE(tcs, bool_node__push_lua);
650
    ATF_ADD_TEST_CASE(tcs, bool_node__set_lua__ok);
651
    ATF_ADD_TEST_CASE(tcs, bool_node__set_lua__invalid_value);
652
    ATF_ADD_TEST_CASE(tcs, bool_node__set_string__ok);
653
    ATF_ADD_TEST_CASE(tcs, bool_node__set_string__invalid_value);
654
    ATF_ADD_TEST_CASE(tcs, bool_node__to_string);
655

656
    ATF_ADD_TEST_CASE(tcs, int_node__deep_copy);
657
    ATF_ADD_TEST_CASE(tcs, int_node__is_set_and_set);
658
    ATF_ADD_TEST_CASE(tcs, int_node__value_and_set);
659
    ATF_ADD_TEST_CASE(tcs, int_node__push_lua);
660
    ATF_ADD_TEST_CASE(tcs, int_node__set_lua__ok);
661
    ATF_ADD_TEST_CASE(tcs, int_node__set_lua__invalid_value);
662
    ATF_ADD_TEST_CASE(tcs, int_node__set_string__ok);
663
    ATF_ADD_TEST_CASE(tcs, int_node__set_string__invalid_value);
664
    ATF_ADD_TEST_CASE(tcs, int_node__to_string);
665

666
    ATF_ADD_TEST_CASE(tcs, positive_int_node__deep_copy);
667
    ATF_ADD_TEST_CASE(tcs, positive_int_node__is_set_and_set);
668
    ATF_ADD_TEST_CASE(tcs, positive_int_node__value_and_set);
669
    ATF_ADD_TEST_CASE(tcs, positive_int_node__push_lua);
670
    ATF_ADD_TEST_CASE(tcs, positive_int_node__set_lua__ok);
671
    ATF_ADD_TEST_CASE(tcs, positive_int_node__set_lua__invalid_value);
672
    ATF_ADD_TEST_CASE(tcs, positive_int_node__set_string__ok);
673
    ATF_ADD_TEST_CASE(tcs, positive_int_node__set_string__invalid_value);
674
    ATF_ADD_TEST_CASE(tcs, positive_int_node__to_string);
675

676
    ATF_ADD_TEST_CASE(tcs, string_node__deep_copy);
677
    ATF_ADD_TEST_CASE(tcs, string_node__is_set_and_set);
678
    ATF_ADD_TEST_CASE(tcs, string_node__value_and_set);
679
    ATF_ADD_TEST_CASE(tcs, string_node__push_lua);
680
    ATF_ADD_TEST_CASE(tcs, string_node__set_lua__ok);
681
    ATF_ADD_TEST_CASE(tcs, string_node__set_lua__invalid_value);
682
    ATF_ADD_TEST_CASE(tcs, string_node__set_string);
683
    ATF_ADD_TEST_CASE(tcs, string_node__to_string);
684

685
    ATF_ADD_TEST_CASE(tcs, strings_set_node__deep_copy);
686
    ATF_ADD_TEST_CASE(tcs, strings_set_node__is_set_and_set);
687
    ATF_ADD_TEST_CASE(tcs, strings_set_node__value_and_set);
688
    ATF_ADD_TEST_CASE(tcs, strings_set_node__set_string);
689
    ATF_ADD_TEST_CASE(tcs, strings_set_node__to_string);
690

691
    ATF_ADD_TEST_CASE(tcs, typed_leaf_node__validate_set);
692
    ATF_ADD_TEST_CASE(tcs, typed_leaf_node__validate_set_string);
693
    ATF_ADD_TEST_CASE(tcs, base_set_node__validate_set);
694
    ATF_ADD_TEST_CASE(tcs, base_set_node__validate_set_string);
695
}
696

697
Product

Resources

Company
