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 = 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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 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