xref: /freebsd/contrib/kyua/utils/config/nodes_test.cpp (revision 02e9120893770924227138ba49df1edb3896112a) 
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