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