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
39namespace config = utils::config;
40
41
42namespace {
43
44
45/// Typed leaf node that specializes the validate() method.
46class 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.
62class 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
82ATF_TEST_CASE_WITHOUT_HEAD(bool_node__deep_copy);
83ATF_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
97ATF_TEST_CASE_WITHOUT_HEAD(bool_node__is_set_and_set);
98ATF_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
107ATF_TEST_CASE_WITHOUT_HEAD(bool_node__value_and_set);
108ATF_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
118ATF_TEST_CASE_WITHOUT_HEAD(bool_node__push_lua);
119ATF_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
132ATF_TEST_CASE_WITHOUT_HEAD(bool_node__set_lua__ok);
133ATF_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
145ATF_TEST_CASE_WITHOUT_HEAD(bool_node__set_lua__invalid_value);
146ATF_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
158ATF_TEST_CASE_WITHOUT_HEAD(bool_node__set_string__ok);
159ATF_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
169ATF_TEST_CASE_WITHOUT_HEAD(bool_node__set_string__invalid_value);
170ATF_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
178ATF_TEST_CASE_WITHOUT_HEAD(bool_node__to_string);
179ATF_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
189ATF_TEST_CASE_WITHOUT_HEAD(int_node__deep_copy);
190ATF_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
204ATF_TEST_CASE_WITHOUT_HEAD(int_node__is_set_and_set);
205ATF_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
214ATF_TEST_CASE_WITHOUT_HEAD(int_node__value_and_set);
215ATF_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
225ATF_TEST_CASE_WITHOUT_HEAD(int_node__push_lua);
226ATF_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
239ATF_TEST_CASE_WITHOUT_HEAD(int_node__set_lua__ok);
240ATF_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
255ATF_TEST_CASE_WITHOUT_HEAD(int_node__set_lua__invalid_value);
256ATF_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
268ATF_TEST_CASE_WITHOUT_HEAD(int_node__set_string__ok);
269ATF_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
279ATF_TEST_CASE_WITHOUT_HEAD(int_node__set_string__invalid_value);
280ATF_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
288ATF_TEST_CASE_WITHOUT_HEAD(int_node__to_string);
289ATF_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
299ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__deep_copy);
300ATF_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
315ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__is_set_and_set);
316ATF_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
325ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__value_and_set);
326ATF_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
336ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__push_lua);
337ATF_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
350ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__set_lua__ok);
351ATF_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
366ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__set_lua__invalid_value);
367ATF_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
383ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__set_string__ok);
384ATF_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
394ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__set_string__invalid_value);
395ATF_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
407ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__to_string);
408ATF_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
416ATF_TEST_CASE_WITHOUT_HEAD(string_node__deep_copy);
417ATF_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
431ATF_TEST_CASE_WITHOUT_HEAD(string_node__is_set_and_set);
432ATF_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
441ATF_TEST_CASE_WITHOUT_HEAD(string_node__value_and_set);
442ATF_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
452ATF_TEST_CASE_WITHOUT_HEAD(string_node__push_lua);
453ATF_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
466ATF_TEST_CASE_WITHOUT_HEAD(string_node__set_lua__ok);
467ATF_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
482ATF_TEST_CASE_WITHOUT_HEAD(string_node__set_lua__invalid_value);
483ATF_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
495ATF_TEST_CASE_WITHOUT_HEAD(string_node__set_string);
496ATF_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
506ATF_TEST_CASE_WITHOUT_HEAD(string_node__to_string);
507ATF_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
517ATF_TEST_CASE_WITHOUT_HEAD(strings_set_node__deep_copy);
518ATF_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
536ATF_TEST_CASE_WITHOUT_HEAD(strings_set_node__is_set_and_set);
537ATF_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
549ATF_TEST_CASE_WITHOUT_HEAD(strings_set_node__value_and_set);
550ATF_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
565ATF_TEST_CASE_WITHOUT_HEAD(strings_set_node__set_string);
566ATF_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
587ATF_TEST_CASE_WITHOUT_HEAD(strings_set_node__to_string);
588ATF_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
599ATF_TEST_CASE_WITHOUT_HEAD(typed_leaf_node__validate_set);
600ATF_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
609ATF_TEST_CASE_WITHOUT_HEAD(typed_leaf_node__validate_set_string);
610ATF_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
619ATF_TEST_CASE_WITHOUT_HEAD(base_set_node__validate_set);
620ATF_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
634ATF_TEST_CASE_WITHOUT_HEAD(base_set_node__validate_set_string);
635ATF_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
644ATF_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