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
validate(const value_type & new_value) const53 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
validate(const value_type & new_value) const69 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);
ATF_TEST_CASE_BODY(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 = dynamic_cast< config::bool_node* >(raw_copy);
89 ATF_REQUIRE(copy != nullptr);
90 ATF_REQUIRE(copy->value());
91 copy->set(false);
92 ATF_REQUIRE(node.value());
93 ATF_REQUIRE(!copy->value());
94 delete copy;
95 }
96
97
98 ATF_TEST_CASE_WITHOUT_HEAD(bool_node__is_set_and_set);
ATF_TEST_CASE_BODY(bool_node__is_set_and_set)99 ATF_TEST_CASE_BODY(bool_node__is_set_and_set)
100 {
101 config::bool_node node;
102 ATF_REQUIRE(!node.is_set());
103 node.set(false);
104 ATF_REQUIRE( node.is_set());
105 }
106
107
108 ATF_TEST_CASE_WITHOUT_HEAD(bool_node__value_and_set);
ATF_TEST_CASE_BODY(bool_node__value_and_set)109 ATF_TEST_CASE_BODY(bool_node__value_and_set)
110 {
111 config::bool_node node;
112 node.set(false);
113 ATF_REQUIRE(!node.value());
114 node.set(true);
115 ATF_REQUIRE( node.value());
116 }
117
118
119 ATF_TEST_CASE_WITHOUT_HEAD(bool_node__push_lua);
ATF_TEST_CASE_BODY(bool_node__push_lua)120 ATF_TEST_CASE_BODY(bool_node__push_lua)
121 {
122 lutok::state state;
123
124 config::bool_node node;
125 node.set(true);
126 node.push_lua(state);
127 ATF_REQUIRE(state.is_boolean(-1));
128 ATF_REQUIRE(state.to_boolean(-1));
129 state.pop(1);
130 }
131
132
133 ATF_TEST_CASE_WITHOUT_HEAD(bool_node__set_lua__ok);
ATF_TEST_CASE_BODY(bool_node__set_lua__ok)134 ATF_TEST_CASE_BODY(bool_node__set_lua__ok)
135 {
136 lutok::state state;
137
138 config::bool_node node;
139 state.push_boolean(false);
140 node.set_lua(state, -1);
141 state.pop(1);
142 ATF_REQUIRE(!node.value());
143 }
144
145
146 ATF_TEST_CASE_WITHOUT_HEAD(bool_node__set_lua__invalid_value);
ATF_TEST_CASE_BODY(bool_node__set_lua__invalid_value)147 ATF_TEST_CASE_BODY(bool_node__set_lua__invalid_value)
148 {
149 lutok::state state;
150
151 config::bool_node node;
152 state.push_string("foo bar");
153 ATF_REQUIRE_THROW(config::value_error, node.set_lua(state, -1));
154 state.pop(1);
155 ATF_REQUIRE(!node.is_set());
156 }
157
158
159 ATF_TEST_CASE_WITHOUT_HEAD(bool_node__set_string__ok);
ATF_TEST_CASE_BODY(bool_node__set_string__ok)160 ATF_TEST_CASE_BODY(bool_node__set_string__ok)
161 {
162 config::bool_node node;
163 node.set_string("false");
164 ATF_REQUIRE(!node.value());
165 node.set_string("true");
166 ATF_REQUIRE( node.value());
167 }
168
169
170 ATF_TEST_CASE_WITHOUT_HEAD(bool_node__set_string__invalid_value);
ATF_TEST_CASE_BODY(bool_node__set_string__invalid_value)171 ATF_TEST_CASE_BODY(bool_node__set_string__invalid_value)
172 {
173 config::bool_node node;
174 ATF_REQUIRE_THROW(config::value_error, node.set_string("12345"));
175 ATF_REQUIRE(!node.is_set());
176 }
177
178
179 ATF_TEST_CASE_WITHOUT_HEAD(bool_node__to_string);
ATF_TEST_CASE_BODY(bool_node__to_string)180 ATF_TEST_CASE_BODY(bool_node__to_string)
181 {
182 config::bool_node node;
183 node.set(false);
184 ATF_REQUIRE_EQ("false", node.to_string());
185 node.set(true);
186 ATF_REQUIRE_EQ("true", node.to_string());
187 }
188
189
190 ATF_TEST_CASE_WITHOUT_HEAD(int_node__deep_copy);
ATF_TEST_CASE_BODY(int_node__deep_copy)191 ATF_TEST_CASE_BODY(int_node__deep_copy)
192 {
193 config::int_node node;
194 node.set(5);
195 config::detail::base_node* raw_copy = node.deep_copy();
196 config::int_node* copy = dynamic_cast< config::int_node* >(raw_copy);
197 ATF_REQUIRE(copy != nullptr);
198 ATF_REQUIRE_EQ(5, copy->value());
199 copy->set(10);
200 ATF_REQUIRE_EQ(5, node.value());
201 ATF_REQUIRE_EQ(10, copy->value());
202 delete copy;
203 }
204
205
206 ATF_TEST_CASE_WITHOUT_HEAD(int_node__is_set_and_set);
ATF_TEST_CASE_BODY(int_node__is_set_and_set)207 ATF_TEST_CASE_BODY(int_node__is_set_and_set)
208 {
209 config::int_node node;
210 ATF_REQUIRE(!node.is_set());
211 node.set(20);
212 ATF_REQUIRE( node.is_set());
213 }
214
215
216 ATF_TEST_CASE_WITHOUT_HEAD(int_node__value_and_set);
ATF_TEST_CASE_BODY(int_node__value_and_set)217 ATF_TEST_CASE_BODY(int_node__value_and_set)
218 {
219 config::int_node node;
220 node.set(20);
221 ATF_REQUIRE_EQ(20, node.value());
222 node.set(0);
223 ATF_REQUIRE_EQ(0, node.value());
224 }
225
226
227 ATF_TEST_CASE_WITHOUT_HEAD(int_node__push_lua);
ATF_TEST_CASE_BODY(int_node__push_lua)228 ATF_TEST_CASE_BODY(int_node__push_lua)
229 {
230 lutok::state state;
231
232 config::int_node node;
233 node.set(754);
234 node.push_lua(state);
235 ATF_REQUIRE(state.is_number(-1));
236 ATF_REQUIRE_EQ(754, state.to_integer(-1));
237 state.pop(1);
238 }
239
240
241 ATF_TEST_CASE_WITHOUT_HEAD(int_node__set_lua__ok);
ATF_TEST_CASE_BODY(int_node__set_lua__ok)242 ATF_TEST_CASE_BODY(int_node__set_lua__ok)
243 {
244 lutok::state state;
245
246 config::int_node node;
247 state.push_integer(123);
248 state.push_string("456");
249 node.set_lua(state, -2);
250 ATF_REQUIRE_EQ(123, node.value());
251 node.set_lua(state, -1);
252 ATF_REQUIRE_EQ(456, node.value());
253 state.pop(2);
254 }
255
256
257 ATF_TEST_CASE_WITHOUT_HEAD(int_node__set_lua__invalid_value);
ATF_TEST_CASE_BODY(int_node__set_lua__invalid_value)258 ATF_TEST_CASE_BODY(int_node__set_lua__invalid_value)
259 {
260 lutok::state state;
261
262 config::int_node node;
263 state.push_boolean(true);
264 ATF_REQUIRE_THROW(config::value_error, node.set_lua(state, -1));
265 state.pop(1);
266 ATF_REQUIRE(!node.is_set());
267 }
268
269
270 ATF_TEST_CASE_WITHOUT_HEAD(int_node__set_string__ok);
ATF_TEST_CASE_BODY(int_node__set_string__ok)271 ATF_TEST_CASE_BODY(int_node__set_string__ok)
272 {
273 config::int_node node;
274 node.set_string("178");
275 ATF_REQUIRE_EQ(178, node.value());
276 node.set_string("-123");
277 ATF_REQUIRE_EQ(-123, node.value());
278 }
279
280
281 ATF_TEST_CASE_WITHOUT_HEAD(int_node__set_string__invalid_value);
ATF_TEST_CASE_BODY(int_node__set_string__invalid_value)282 ATF_TEST_CASE_BODY(int_node__set_string__invalid_value)
283 {
284 config::int_node node;
285 ATF_REQUIRE_THROW(config::value_error, node.set_string(" 23"));
286 ATF_REQUIRE(!node.is_set());
287 }
288
289
290 ATF_TEST_CASE_WITHOUT_HEAD(int_node__to_string);
ATF_TEST_CASE_BODY(int_node__to_string)291 ATF_TEST_CASE_BODY(int_node__to_string)
292 {
293 config::int_node node;
294 node.set(89);
295 ATF_REQUIRE_EQ("89", node.to_string());
296 node.set(-57);
297 ATF_REQUIRE_EQ("-57", node.to_string());
298 }
299
300
301 ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__deep_copy);
ATF_TEST_CASE_BODY(positive_int_node__deep_copy)302 ATF_TEST_CASE_BODY(positive_int_node__deep_copy)
303 {
304 config::positive_int_node node;
305 node.set(5);
306 config::detail::base_node* raw_copy = node.deep_copy();
307 config::positive_int_node* copy = dynamic_cast< config::positive_int_node* >(
308 raw_copy);
309 ATF_REQUIRE(copy != nullptr);
310 ATF_REQUIRE_EQ(5, copy->value());
311 copy->set(10);
312 ATF_REQUIRE_EQ(5, node.value());
313 ATF_REQUIRE_EQ(10, copy->value());
314 delete copy;
315 }
316
317
318 ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__is_set_and_set);
ATF_TEST_CASE_BODY(positive_int_node__is_set_and_set)319 ATF_TEST_CASE_BODY(positive_int_node__is_set_and_set)
320 {
321 config::positive_int_node node;
322 ATF_REQUIRE(!node.is_set());
323 node.set(20);
324 ATF_REQUIRE( node.is_set());
325 }
326
327
328 ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__value_and_set);
ATF_TEST_CASE_BODY(positive_int_node__value_and_set)329 ATF_TEST_CASE_BODY(positive_int_node__value_and_set)
330 {
331 config::positive_int_node node;
332 node.set(20);
333 ATF_REQUIRE_EQ(20, node.value());
334 node.set(1);
335 ATF_REQUIRE_EQ(1, node.value());
336 }
337
338
339 ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__push_lua);
ATF_TEST_CASE_BODY(positive_int_node__push_lua)340 ATF_TEST_CASE_BODY(positive_int_node__push_lua)
341 {
342 lutok::state state;
343
344 config::positive_int_node node;
345 node.set(754);
346 node.push_lua(state);
347 ATF_REQUIRE(state.is_number(-1));
348 ATF_REQUIRE_EQ(754, state.to_integer(-1));
349 state.pop(1);
350 }
351
352
353 ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__set_lua__ok);
ATF_TEST_CASE_BODY(positive_int_node__set_lua__ok)354 ATF_TEST_CASE_BODY(positive_int_node__set_lua__ok)
355 {
356 lutok::state state;
357
358 config::positive_int_node node;
359 state.push_integer(123);
360 state.push_string("456");
361 node.set_lua(state, -2);
362 ATF_REQUIRE_EQ(123, node.value());
363 node.set_lua(state, -1);
364 ATF_REQUIRE_EQ(456, node.value());
365 state.pop(2);
366 }
367
368
369 ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__set_lua__invalid_value);
ATF_TEST_CASE_BODY(positive_int_node__set_lua__invalid_value)370 ATF_TEST_CASE_BODY(positive_int_node__set_lua__invalid_value)
371 {
372 lutok::state state;
373
374 config::positive_int_node node;
375 state.push_boolean(true);
376 ATF_REQUIRE_THROW(config::value_error, node.set_lua(state, -1));
377 state.pop(1);
378 ATF_REQUIRE(!node.is_set());
379 state.push_integer(0);
380 ATF_REQUIRE_THROW(config::value_error, node.set_lua(state, -1));
381 state.pop(1);
382 ATF_REQUIRE(!node.is_set());
383 }
384
385
386 ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__set_string__ok);
ATF_TEST_CASE_BODY(positive_int_node__set_string__ok)387 ATF_TEST_CASE_BODY(positive_int_node__set_string__ok)
388 {
389 config::positive_int_node node;
390 node.set_string("1");
391 ATF_REQUIRE_EQ(1, node.value());
392 node.set_string("178");
393 ATF_REQUIRE_EQ(178, node.value());
394 }
395
396
397 ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__set_string__invalid_value);
ATF_TEST_CASE_BODY(positive_int_node__set_string__invalid_value)398 ATF_TEST_CASE_BODY(positive_int_node__set_string__invalid_value)
399 {
400 config::positive_int_node node;
401 ATF_REQUIRE_THROW(config::value_error, node.set_string(" 23"));
402 ATF_REQUIRE(!node.is_set());
403 ATF_REQUIRE_THROW(config::value_error, node.set_string("0"));
404 ATF_REQUIRE(!node.is_set());
405 ATF_REQUIRE_THROW(config::value_error, node.set_string("-5"));
406 ATF_REQUIRE(!node.is_set());
407 }
408
409
410 ATF_TEST_CASE_WITHOUT_HEAD(positive_int_node__to_string);
ATF_TEST_CASE_BODY(positive_int_node__to_string)411 ATF_TEST_CASE_BODY(positive_int_node__to_string)
412 {
413 config::positive_int_node node;
414 node.set(89);
415 ATF_REQUIRE_EQ("89", node.to_string());
416 }
417
418
419 ATF_TEST_CASE_WITHOUT_HEAD(string_node__deep_copy);
ATF_TEST_CASE_BODY(string_node__deep_copy)420 ATF_TEST_CASE_BODY(string_node__deep_copy)
421 {
422 config::string_node node;
423 node.set("first");
424 config::detail::base_node* raw_copy = node.deep_copy();
425 config::string_node* copy = dynamic_cast< config::string_node* >(raw_copy);
426 ATF_REQUIRE(copy != nullptr);
427 ATF_REQUIRE_EQ("first", copy->value());
428 copy->set("second");
429 ATF_REQUIRE_EQ("first", node.value());
430 ATF_REQUIRE_EQ("second", copy->value());
431 delete copy;
432 }
433
434
435 ATF_TEST_CASE_WITHOUT_HEAD(string_node__is_set_and_set);
ATF_TEST_CASE_BODY(string_node__is_set_and_set)436 ATF_TEST_CASE_BODY(string_node__is_set_and_set)
437 {
438 config::string_node node;
439 ATF_REQUIRE(!node.is_set());
440 node.set("foo");
441 ATF_REQUIRE( node.is_set());
442 }
443
444
445 ATF_TEST_CASE_WITHOUT_HEAD(string_node__value_and_set);
ATF_TEST_CASE_BODY(string_node__value_and_set)446 ATF_TEST_CASE_BODY(string_node__value_and_set)
447 {
448 config::string_node node;
449 node.set("foo");
450 ATF_REQUIRE_EQ("foo", node.value());
451 node.set("");
452 ATF_REQUIRE_EQ("", node.value());
453 }
454
455
456 ATF_TEST_CASE_WITHOUT_HEAD(string_node__push_lua);
ATF_TEST_CASE_BODY(string_node__push_lua)457 ATF_TEST_CASE_BODY(string_node__push_lua)
458 {
459 lutok::state state;
460
461 config::string_node node;
462 node.set("some message");
463 node.push_lua(state);
464 ATF_REQUIRE(state.is_string(-1));
465 ATF_REQUIRE_EQ("some message", state.to_string(-1));
466 state.pop(1);
467 }
468
469
470 ATF_TEST_CASE_WITHOUT_HEAD(string_node__set_lua__ok);
ATF_TEST_CASE_BODY(string_node__set_lua__ok)471 ATF_TEST_CASE_BODY(string_node__set_lua__ok)
472 {
473 lutok::state state;
474
475 config::string_node node;
476 state.push_string("text 1");
477 state.push_integer(231);
478 node.set_lua(state, -2);
479 ATF_REQUIRE_EQ("text 1", node.value());
480 node.set_lua(state, -1);
481 ATF_REQUIRE_EQ("231", node.value());
482 state.pop(2);
483 }
484
485
486 ATF_TEST_CASE_WITHOUT_HEAD(string_node__set_lua__invalid_value);
ATF_TEST_CASE_BODY(string_node__set_lua__invalid_value)487 ATF_TEST_CASE_BODY(string_node__set_lua__invalid_value)
488 {
489 lutok::state state;
490
491 config::bool_node node;
492 state.new_table();
493 ATF_REQUIRE_THROW(config::value_error, node.set_lua(state, -1));
494 state.pop(1);
495 ATF_REQUIRE(!node.is_set());
496 }
497
498
499 ATF_TEST_CASE_WITHOUT_HEAD(string_node__set_string);
ATF_TEST_CASE_BODY(string_node__set_string)500 ATF_TEST_CASE_BODY(string_node__set_string)
501 {
502 config::string_node node;
503 node.set_string("abcd efgh");
504 ATF_REQUIRE_EQ("abcd efgh", node.value());
505 node.set_string(" 1234 ");
506 ATF_REQUIRE_EQ(" 1234 ", node.value());
507 }
508
509
510 ATF_TEST_CASE_WITHOUT_HEAD(string_node__to_string);
ATF_TEST_CASE_BODY(string_node__to_string)511 ATF_TEST_CASE_BODY(string_node__to_string)
512 {
513 config::string_node node;
514 node.set("");
515 ATF_REQUIRE_EQ("", node.to_string());
516 node.set("aaa");
517 ATF_REQUIRE_EQ("aaa", node.to_string());
518 }
519
520
521 ATF_TEST_CASE_WITHOUT_HEAD(strings_set_node__deep_copy);
ATF_TEST_CASE_BODY(strings_set_node__deep_copy)522 ATF_TEST_CASE_BODY(strings_set_node__deep_copy)
523 {
524 std::set< std::string > value;
525 config::strings_set_node node;
526 value.insert("foo");
527 node.set(value);
528 config::detail::base_node* raw_copy = node.deep_copy();
529 config::strings_set_node* copy =
530 dynamic_cast< config::strings_set_node* >(raw_copy);
531 ATF_REQUIRE(copy != nullptr);
532 value.insert("bar");
533 ATF_REQUIRE_EQ(1, copy->value().size());
534 copy->set(value);
535 ATF_REQUIRE_EQ(1, node.value().size());
536 ATF_REQUIRE_EQ(2, copy->value().size());
537 delete copy;
538 }
539
540
541 ATF_TEST_CASE_WITHOUT_HEAD(strings_set_node__is_set_and_set);
ATF_TEST_CASE_BODY(strings_set_node__is_set_and_set)542 ATF_TEST_CASE_BODY(strings_set_node__is_set_and_set)
543 {
544 std::set< std::string > value;
545 value.insert("foo");
546
547 config::strings_set_node node;
548 ATF_REQUIRE(!node.is_set());
549 node.set(value);
550 ATF_REQUIRE( node.is_set());
551 }
552
553
554 ATF_TEST_CASE_WITHOUT_HEAD(strings_set_node__value_and_set);
ATF_TEST_CASE_BODY(strings_set_node__value_and_set)555 ATF_TEST_CASE_BODY(strings_set_node__value_and_set)
556 {
557 std::set< std::string > value;
558 value.insert("first");
559
560 config::strings_set_node node;
561 node.set(value);
562 ATF_REQUIRE(value == node.value());
563 value.clear();
564 node.set(value);
565 value.insert("second");
566 ATF_REQUIRE(node.value().empty());
567 }
568
569
570 ATF_TEST_CASE_WITHOUT_HEAD(strings_set_node__set_string);
ATF_TEST_CASE_BODY(strings_set_node__set_string)571 ATF_TEST_CASE_BODY(strings_set_node__set_string)
572 {
573 config::strings_set_node node;
574 {
575 std::set< std::string > expected;
576 expected.insert("abcd");
577 expected.insert("efgh");
578
579 node.set_string("abcd efgh");
580 ATF_REQUIRE(expected == node.value());
581 }
582 {
583 std::set< std::string > expected;
584 expected.insert("1234");
585
586 node.set_string(" 1234 ");
587 ATF_REQUIRE(expected == node.value());
588 }
589 }
590
591
592 ATF_TEST_CASE_WITHOUT_HEAD(strings_set_node__to_string);
ATF_TEST_CASE_BODY(strings_set_node__to_string)593 ATF_TEST_CASE_BODY(strings_set_node__to_string)
594 {
595 std::set< std::string > value;
596 config::strings_set_node node;
597 value.insert("second");
598 value.insert("first");
599 node.set(value);
600 ATF_REQUIRE_EQ("first second", node.to_string());
601 }
602
603
604 ATF_TEST_CASE_WITHOUT_HEAD(typed_leaf_node__validate_set);
ATF_TEST_CASE_BODY(typed_leaf_node__validate_set)605 ATF_TEST_CASE_BODY(typed_leaf_node__validate_set)
606 {
607 validation_node node;
608 node.set(1234);
609 ATF_REQUIRE_THROW_RE(config::value_error, "Custom validate method",
610 node.set(12345));
611 }
612
613
614 ATF_TEST_CASE_WITHOUT_HEAD(typed_leaf_node__validate_set_string);
ATF_TEST_CASE_BODY(typed_leaf_node__validate_set_string)615 ATF_TEST_CASE_BODY(typed_leaf_node__validate_set_string)
616 {
617 validation_node node;
618 node.set_string("1234");
619 ATF_REQUIRE_THROW_RE(config::value_error, "Custom validate method",
620 node.set_string("12345"));
621 }
622
623
624 ATF_TEST_CASE_WITHOUT_HEAD(base_set_node__validate_set);
ATF_TEST_CASE_BODY(base_set_node__validate_set)625 ATF_TEST_CASE_BODY(base_set_node__validate_set)
626 {
627 set_validation_node node;
628 set_validation_node::value_type values;
629 values.insert("foo");
630 values.insert("bar");
631 node.set(values);
632 values.insert("throw");
633 values.insert("baz");
634 ATF_REQUIRE_THROW_RE(config::value_error, "Custom validate method",
635 node.set(values));
636 }
637
638
639 ATF_TEST_CASE_WITHOUT_HEAD(base_set_node__validate_set_string);
ATF_TEST_CASE_BODY(base_set_node__validate_set_string)640 ATF_TEST_CASE_BODY(base_set_node__validate_set_string)
641 {
642 set_validation_node node;
643 node.set_string("foo bar");
644 ATF_REQUIRE_THROW_RE(config::value_error, "Custom validate method",
645 node.set_string("foo bar throw baz"));
646 }
647
648
ATF_INIT_TEST_CASES(tcs)649 ATF_INIT_TEST_CASES(tcs)
650 {
651 ATF_ADD_TEST_CASE(tcs, bool_node__deep_copy);
652 ATF_ADD_TEST_CASE(tcs, bool_node__is_set_and_set);
653 ATF_ADD_TEST_CASE(tcs, bool_node__value_and_set);
654 ATF_ADD_TEST_CASE(tcs, bool_node__push_lua);
655 ATF_ADD_TEST_CASE(tcs, bool_node__set_lua__ok);
656 ATF_ADD_TEST_CASE(tcs, bool_node__set_lua__invalid_value);
657 ATF_ADD_TEST_CASE(tcs, bool_node__set_string__ok);
658 ATF_ADD_TEST_CASE(tcs, bool_node__set_string__invalid_value);
659 ATF_ADD_TEST_CASE(tcs, bool_node__to_string);
660
661 ATF_ADD_TEST_CASE(tcs, int_node__deep_copy);
662 ATF_ADD_TEST_CASE(tcs, int_node__is_set_and_set);
663 ATF_ADD_TEST_CASE(tcs, int_node__value_and_set);
664 ATF_ADD_TEST_CASE(tcs, int_node__push_lua);
665 ATF_ADD_TEST_CASE(tcs, int_node__set_lua__ok);
666 ATF_ADD_TEST_CASE(tcs, int_node__set_lua__invalid_value);
667 ATF_ADD_TEST_CASE(tcs, int_node__set_string__ok);
668 ATF_ADD_TEST_CASE(tcs, int_node__set_string__invalid_value);
669 ATF_ADD_TEST_CASE(tcs, int_node__to_string);
670
671 ATF_ADD_TEST_CASE(tcs, positive_int_node__deep_copy);
672 ATF_ADD_TEST_CASE(tcs, positive_int_node__is_set_and_set);
673 ATF_ADD_TEST_CASE(tcs, positive_int_node__value_and_set);
674 ATF_ADD_TEST_CASE(tcs, positive_int_node__push_lua);
675 ATF_ADD_TEST_CASE(tcs, positive_int_node__set_lua__ok);
676 ATF_ADD_TEST_CASE(tcs, positive_int_node__set_lua__invalid_value);
677 ATF_ADD_TEST_CASE(tcs, positive_int_node__set_string__ok);
678 ATF_ADD_TEST_CASE(tcs, positive_int_node__set_string__invalid_value);
679 ATF_ADD_TEST_CASE(tcs, positive_int_node__to_string);
680
681 ATF_ADD_TEST_CASE(tcs, string_node__deep_copy);
682 ATF_ADD_TEST_CASE(tcs, string_node__is_set_and_set);
683 ATF_ADD_TEST_CASE(tcs, string_node__value_and_set);
684 ATF_ADD_TEST_CASE(tcs, string_node__push_lua);
685 ATF_ADD_TEST_CASE(tcs, string_node__set_lua__ok);
686 ATF_ADD_TEST_CASE(tcs, string_node__set_lua__invalid_value);
687 ATF_ADD_TEST_CASE(tcs, string_node__set_string);
688 ATF_ADD_TEST_CASE(tcs, string_node__to_string);
689
690 ATF_ADD_TEST_CASE(tcs, strings_set_node__deep_copy);
691 ATF_ADD_TEST_CASE(tcs, strings_set_node__is_set_and_set);
692 ATF_ADD_TEST_CASE(tcs, strings_set_node__value_and_set);
693 ATF_ADD_TEST_CASE(tcs, strings_set_node__set_string);
694 ATF_ADD_TEST_CASE(tcs, strings_set_node__to_string);
695
696 ATF_ADD_TEST_CASE(tcs, typed_leaf_node__validate_set);
697 ATF_ADD_TEST_CASE(tcs, typed_leaf_node__validate_set_string);
698 ATF_ADD_TEST_CASE(tcs, base_set_node__validate_set);
699 ATF_ADD_TEST_CASE(tcs, base_set_node__validate_set_string);
700 }
701