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