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 = 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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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);
ATF_TEST_CASE_BODY(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
ATF_INIT_TEST_CASES(tcs)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