templates_test.cpp revision 1.1.1.1.4.2
1 // Copyright 2012 Google Inc. 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/text/templates.hpp" 30 31 #include <fstream> 32 #include <sstream> 33 34 #include <atf-c++.hpp> 35 36 #include "utils/fs/operations.hpp" 37 #include "utils/fs/path.hpp" 38 #include "utils/text/exceptions.hpp" 39 40 namespace fs = utils::fs; 41 namespace text = utils::text; 42 43 44 namespace { 45 46 47 /// Applies a set of templates to an input string and validates the output. 48 /// 49 /// This fails the test case if exp_output does not match the document generated 50 /// by the application of the templates. 51 /// 52 /// \param templates The templates to apply. 53 /// \param input_str The input document to which to apply the templates. 54 /// \param exp_output The expected output document. 55 static void 56 do_test_ok(const text::templates_def& templates, const std::string& input_str, 57 const std::string& exp_output) 58 { 59 std::istringstream input(input_str); 60 std::ostringstream output; 61 62 text::instantiate(templates, input, output); 63 ATF_REQUIRE_EQ(exp_output, output.str()); 64 } 65 66 67 /// Applies a set of templates to an input string and checks for an error. 68 /// 69 /// This fails the test case if the exception raised by the template processing 70 /// does not match the expected message. 71 /// 72 /// \param templates The templates to apply. 73 /// \param input_str The input document to which to apply the templates. 74 /// \param exp_message The expected error message in the raised exception. 75 static void 76 do_test_fail(const text::templates_def& templates, const std::string& input_str, 77 const std::string& exp_message) 78 { 79 std::istringstream input(input_str); 80 std::ostringstream output; 81 82 ATF_REQUIRE_THROW_RE(text::syntax_error, exp_message, 83 text::instantiate(templates, input, output)); 84 } 85 86 87 } // anonymous namespace 88 89 90 ATF_TEST_CASE_WITHOUT_HEAD(templates_def__add_variable__first); 91 ATF_TEST_CASE_BODY(templates_def__add_variable__first) 92 { 93 text::templates_def templates; 94 templates.add_variable("the-name", "first-value"); 95 ATF_REQUIRE_EQ("first-value", templates.get_variable("the-name")); 96 } 97 98 99 ATF_TEST_CASE_WITHOUT_HEAD(templates_def__add_variable__replace); 100 ATF_TEST_CASE_BODY(templates_def__add_variable__replace) 101 { 102 text::templates_def templates; 103 templates.add_variable("the-name", "first-value"); 104 templates.add_variable("the-name", "second-value"); 105 ATF_REQUIRE_EQ("second-value", templates.get_variable("the-name")); 106 } 107 108 109 ATF_TEST_CASE_WITHOUT_HEAD(templates_def__remove_variable); 110 ATF_TEST_CASE_BODY(templates_def__remove_variable) 111 { 112 text::templates_def templates; 113 templates.add_variable("the-name", "the-value"); 114 templates.get_variable("the-name"); // Should not throw. 115 templates.remove_variable("the-name"); 116 ATF_REQUIRE_THROW(text::syntax_error, templates.get_variable("the-name")); 117 } 118 119 120 ATF_TEST_CASE_WITHOUT_HEAD(templates_def__add_vector__first); 121 ATF_TEST_CASE_BODY(templates_def__add_vector__first) 122 { 123 text::templates_def templates; 124 templates.add_vector("the-name"); 125 ATF_REQUIRE(templates.get_vector("the-name").empty()); 126 } 127 128 129 ATF_TEST_CASE_WITHOUT_HEAD(templates_def__add_vector__replace); 130 ATF_TEST_CASE_BODY(templates_def__add_vector__replace) 131 { 132 text::templates_def templates; 133 templates.add_vector("the-name"); 134 templates.add_to_vector("the-name", "foo"); 135 ATF_REQUIRE(!templates.get_vector("the-name").empty()); 136 templates.add_vector("the-name"); 137 ATF_REQUIRE(templates.get_vector("the-name").empty()); 138 } 139 140 141 ATF_TEST_CASE_WITHOUT_HEAD(templates_def__add_to_vector); 142 ATF_TEST_CASE_BODY(templates_def__add_to_vector) 143 { 144 text::templates_def templates; 145 templates.add_vector("the-name"); 146 ATF_REQUIRE_EQ(0, templates.get_vector("the-name").size()); 147 templates.add_to_vector("the-name", "first"); 148 ATF_REQUIRE_EQ(1, templates.get_vector("the-name").size()); 149 templates.add_to_vector("the-name", "second"); 150 ATF_REQUIRE_EQ(2, templates.get_vector("the-name").size()); 151 templates.add_to_vector("the-name", "third"); 152 ATF_REQUIRE_EQ(3, templates.get_vector("the-name").size()); 153 154 std::vector< std::string > expected; 155 expected.push_back("first"); 156 expected.push_back("second"); 157 expected.push_back("third"); 158 ATF_REQUIRE(expected == templates.get_vector("the-name")); 159 } 160 161 162 ATF_TEST_CASE_WITHOUT_HEAD(templates_def__exists__variable); 163 ATF_TEST_CASE_BODY(templates_def__exists__variable) 164 { 165 text::templates_def templates; 166 ATF_REQUIRE(!templates.exists("some-name")); 167 templates.add_variable("some-name ", "foo"); 168 ATF_REQUIRE(!templates.exists("some-name")); 169 templates.add_variable("some-name", "foo"); 170 ATF_REQUIRE(templates.exists("some-name")); 171 } 172 173 174 ATF_TEST_CASE_WITHOUT_HEAD(templates_def__exists__vector); 175 ATF_TEST_CASE_BODY(templates_def__exists__vector) 176 { 177 text::templates_def templates; 178 ATF_REQUIRE(!templates.exists("some-name")); 179 templates.add_vector("some-name "); 180 ATF_REQUIRE(!templates.exists("some-name")); 181 templates.add_vector("some-name"); 182 ATF_REQUIRE(templates.exists("some-name")); 183 } 184 185 186 ATF_TEST_CASE_WITHOUT_HEAD(templates_def__get_variable__ok); 187 ATF_TEST_CASE_BODY(templates_def__get_variable__ok) 188 { 189 text::templates_def templates; 190 templates.add_variable("foo", ""); 191 templates.add_variable("bar", " baz "); 192 ATF_REQUIRE_EQ("", templates.get_variable("foo")); 193 ATF_REQUIRE_EQ(" baz ", templates.get_variable("bar")); 194 } 195 196 197 ATF_TEST_CASE_WITHOUT_HEAD(templates_def__get_variable__unknown); 198 ATF_TEST_CASE_BODY(templates_def__get_variable__unknown) 199 { 200 text::templates_def templates; 201 templates.add_variable("foo", ""); 202 ATF_REQUIRE_THROW_RE(text::syntax_error, "Unknown variable 'foo '", 203 templates.get_variable("foo ")); 204 } 205 206 207 ATF_TEST_CASE_WITHOUT_HEAD(templates_def__get_vector__ok); 208 ATF_TEST_CASE_BODY(templates_def__get_vector__ok) 209 { 210 text::templates_def templates; 211 templates.add_vector("foo"); 212 templates.add_vector("bar"); 213 templates.add_to_vector("bar", "baz"); 214 ATF_REQUIRE_EQ(0, templates.get_vector("foo").size()); 215 ATF_REQUIRE_EQ(1, templates.get_vector("bar").size()); 216 } 217 218 219 ATF_TEST_CASE_WITHOUT_HEAD(templates_def__get_vector__unknown); 220 ATF_TEST_CASE_BODY(templates_def__get_vector__unknown) 221 { 222 text::templates_def templates; 223 templates.add_vector("foo"); 224 ATF_REQUIRE_THROW_RE(text::syntax_error, "Unknown vector 'foo '", 225 templates.get_vector("foo ")); 226 } 227 228 229 ATF_TEST_CASE_WITHOUT_HEAD(templates_def__evaluate__variable__ok); 230 ATF_TEST_CASE_BODY(templates_def__evaluate__variable__ok) 231 { 232 text::templates_def templates; 233 templates.add_variable("foo", ""); 234 templates.add_variable("bar", " baz "); 235 ATF_REQUIRE_EQ("", templates.evaluate("foo")); 236 ATF_REQUIRE_EQ(" baz ", templates.evaluate("bar")); 237 } 238 239 240 ATF_TEST_CASE_WITHOUT_HEAD(templates_def__evaluate__variable__unknown); 241 ATF_TEST_CASE_BODY(templates_def__evaluate__variable__unknown) 242 { 243 text::templates_def templates; 244 templates.add_variable("foo", ""); 245 ATF_REQUIRE_THROW_RE(text::syntax_error, "Unknown variable 'foo1'", 246 templates.evaluate("foo1")); 247 } 248 249 250 ATF_TEST_CASE_WITHOUT_HEAD(templates_def__evaluate__vector__ok); 251 ATF_TEST_CASE_BODY(templates_def__evaluate__vector__ok) 252 { 253 text::templates_def templates; 254 templates.add_vector("v"); 255 templates.add_to_vector("v", "foo"); 256 templates.add_to_vector("v", "bar"); 257 templates.add_to_vector("v", "baz"); 258 259 templates.add_variable("index", "0"); 260 ATF_REQUIRE_EQ("foo", templates.evaluate("v(index)")); 261 templates.add_variable("index", "1"); 262 ATF_REQUIRE_EQ("bar", templates.evaluate("v(index)")); 263 templates.add_variable("index", "2"); 264 ATF_REQUIRE_EQ("baz", templates.evaluate("v(index)")); 265 } 266 267 268 ATF_TEST_CASE_WITHOUT_HEAD(templates_def__evaluate__vector__unknown_vector); 269 ATF_TEST_CASE_BODY(templates_def__evaluate__vector__unknown_vector) 270 { 271 text::templates_def templates; 272 templates.add_vector("v"); 273 templates.add_to_vector("v", "foo"); 274 templates.add_variable("index", "0"); 275 ATF_REQUIRE_THROW_RE(text::syntax_error, "Unknown vector 'fooz'", 276 templates.evaluate("fooz(index)")); 277 } 278 279 280 ATF_TEST_CASE_WITHOUT_HEAD(templates_def__evaluate__vector__unknown_index); 281 ATF_TEST_CASE_BODY(templates_def__evaluate__vector__unknown_index) 282 { 283 text::templates_def templates; 284 templates.add_vector("v"); 285 templates.add_to_vector("v", "foo"); 286 templates.add_variable("index", "0"); 287 ATF_REQUIRE_THROW_RE(text::syntax_error, "Unknown variable 'indexz'", 288 templates.evaluate("v(indexz)")); 289 } 290 291 292 ATF_TEST_CASE_WITHOUT_HEAD(templates_def__evaluate__vector__out_of_range); 293 ATF_TEST_CASE_BODY(templates_def__evaluate__vector__out_of_range) 294 { 295 text::templates_def templates; 296 templates.add_vector("v"); 297 templates.add_to_vector("v", "foo"); 298 templates.add_variable("index", "1"); 299 ATF_REQUIRE_THROW_RE(text::syntax_error, "Index 'index' out of range " 300 "at position '1'", templates.evaluate("v(index)")); 301 } 302 303 304 ATF_TEST_CASE_WITHOUT_HEAD(templates_def__evaluate__defined); 305 ATF_TEST_CASE_BODY(templates_def__evaluate__defined) 306 { 307 text::templates_def templates; 308 templates.add_vector("the-variable"); 309 templates.add_vector("the-vector"); 310 ATF_REQUIRE_EQ("false", templates.evaluate("defined(the-variabl)")); 311 ATF_REQUIRE_EQ("false", templates.evaluate("defined(the-vecto)")); 312 ATF_REQUIRE_EQ("true", templates.evaluate("defined(the-variable)")); 313 ATF_REQUIRE_EQ("true", templates.evaluate("defined(the-vector)")); 314 } 315 316 317 ATF_TEST_CASE_WITHOUT_HEAD(templates_def__evaluate__length__ok); 318 ATF_TEST_CASE_BODY(templates_def__evaluate__length__ok) 319 { 320 text::templates_def templates; 321 templates.add_vector("v"); 322 ATF_REQUIRE_EQ("0", templates.evaluate("length(v)")); 323 templates.add_to_vector("v", "foo"); 324 ATF_REQUIRE_EQ("1", templates.evaluate("length(v)")); 325 templates.add_to_vector("v", "bar"); 326 ATF_REQUIRE_EQ("2", templates.evaluate("length(v)")); 327 templates.add_to_vector("v", "baz"); 328 ATF_REQUIRE_EQ("3", templates.evaluate("length(v)")); 329 } 330 331 332 ATF_TEST_CASE_WITHOUT_HEAD(templates_def__evaluate__length__unknown_vector); 333 ATF_TEST_CASE_BODY(templates_def__evaluate__length__unknown_vector) 334 { 335 text::templates_def templates; 336 templates.add_vector("foo1"); 337 ATF_REQUIRE_THROW_RE(text::syntax_error, "Unknown vector 'foo'", 338 templates.evaluate("length(foo)")); 339 } 340 341 342 ATF_TEST_CASE_WITHOUT_HEAD(templates_def__evaluate__parenthesis_error); 343 ATF_TEST_CASE_BODY(templates_def__evaluate__parenthesis_error) 344 { 345 text::templates_def templates; 346 ATF_REQUIRE_THROW_RE(text::syntax_error, 347 "Expected '\\)' in.*'foo\\(abc'", 348 templates.evaluate("foo(abc")); 349 ATF_REQUIRE_THROW_RE(text::syntax_error, 350 "Unexpected text.*'\\)' in.*'a\\(b\\)c'", 351 templates.evaluate("a(b)c")); 352 } 353 354 355 ATF_TEST_CASE_WITHOUT_HEAD(instantiate__empty_input); 356 ATF_TEST_CASE_BODY(instantiate__empty_input) 357 { 358 const text::templates_def templates; 359 do_test_ok(templates, "", ""); 360 } 361 362 363 ATF_TEST_CASE_WITHOUT_HEAD(instantiate__value__ok); 364 ATF_TEST_CASE_BODY(instantiate__value__ok) 365 { 366 const std::string input = 367 "first line\n" 368 "%%testvar1%%\n" 369 "third line\n" 370 "%%testvar2%% %%testvar3%%%%testvar4%%\n" 371 "fifth line\n"; 372 373 const std::string exp_output = 374 "first line\n" 375 "second line\n" 376 "third line\n" 377 "fourth line.\n" 378 "fifth line\n"; 379 380 text::templates_def templates; 381 templates.add_variable("testvar1", "second line"); 382 templates.add_variable("testvar2", "fourth"); 383 templates.add_variable("testvar3", "line"); 384 templates.add_variable("testvar4", "."); 385 386 do_test_ok(templates, input, exp_output); 387 } 388 389 390 ATF_TEST_CASE_WITHOUT_HEAD(instantiate__value__unknown_variable); 391 ATF_TEST_CASE_BODY(instantiate__value__unknown_variable) 392 { 393 const std::string input = 394 "%%testvar1%%\n"; 395 396 text::templates_def templates; 397 templates.add_variable("testvar2", "fourth line"); 398 399 do_test_fail(templates, input, "Unknown variable 'testvar1'"); 400 } 401 402 403 ATF_TEST_CASE_WITHOUT_HEAD(instantiate__vector_length__ok); 404 ATF_TEST_CASE_BODY(instantiate__vector_length__ok) 405 { 406 const std::string input = 407 "%%length(testvector1)%%\n" 408 "%%length(testvector2)%% - %%length(testvector3)%%\n"; 409 410 const std::string exp_output = 411 "4\n" 412 "0 - 1\n"; 413 414 text::templates_def templates; 415 templates.add_vector("testvector1"); 416 templates.add_to_vector("testvector1", "000"); 417 templates.add_to_vector("testvector1", "111"); 418 templates.add_to_vector("testvector1", "543"); 419 templates.add_to_vector("testvector1", "999"); 420 templates.add_vector("testvector2"); 421 templates.add_vector("testvector3"); 422 templates.add_to_vector("testvector3", "123"); 423 424 do_test_ok(templates, input, exp_output); 425 } 426 427 428 ATF_TEST_CASE_WITHOUT_HEAD(instantiate__vector_length__unknown_vector); 429 ATF_TEST_CASE_BODY(instantiate__vector_length__unknown_vector) 430 { 431 const std::string input = 432 "%%length(testvector)%%\n"; 433 434 text::templates_def templates; 435 templates.add_vector("testvector2"); 436 437 do_test_fail(templates, input, "Unknown vector 'testvector'"); 438 } 439 440 441 ATF_TEST_CASE_WITHOUT_HEAD(instantiate__vector_value__ok); 442 ATF_TEST_CASE_BODY(instantiate__vector_value__ok) 443 { 444 const std::string input = 445 "first line\n" 446 "%%testvector1(i)%%\n" 447 "third line\n" 448 "%%testvector2(j)%%\n" 449 "fifth line\n"; 450 451 const std::string exp_output = 452 "first line\n" 453 "543\n" 454 "third line\n" 455 "123\n" 456 "fifth line\n"; 457 458 text::templates_def templates; 459 templates.add_variable("i", "2"); 460 templates.add_variable("j", "0"); 461 templates.add_vector("testvector1"); 462 templates.add_to_vector("testvector1", "000"); 463 templates.add_to_vector("testvector1", "111"); 464 templates.add_to_vector("testvector1", "543"); 465 templates.add_to_vector("testvector1", "999"); 466 templates.add_vector("testvector2"); 467 templates.add_to_vector("testvector2", "123"); 468 469 do_test_ok(templates, input, exp_output); 470 } 471 472 473 ATF_TEST_CASE_WITHOUT_HEAD(instantiate__vector_value__unknown_vector); 474 ATF_TEST_CASE_BODY(instantiate__vector_value__unknown_vector) 475 { 476 const std::string input = 477 "%%testvector(j)%%\n"; 478 479 text::templates_def templates; 480 templates.add_vector("testvector2"); 481 482 do_test_fail(templates, input, "Unknown vector 'testvector'"); 483 } 484 485 486 ATF_TEST_CASE_WITHOUT_HEAD(instantiate__vector_value__out_of_range__empty); 487 ATF_TEST_CASE_BODY(instantiate__vector_value__out_of_range__empty) 488 { 489 const std::string input = 490 "%%testvector(j)%%\n"; 491 492 text::templates_def templates; 493 templates.add_vector("testvector"); 494 templates.add_variable("j", "0"); 495 496 do_test_fail(templates, input, "Index 'j' out of range at position '0'"); 497 } 498 499 500 ATF_TEST_CASE_WITHOUT_HEAD(instantiate__vector_value__out_of_range__not_empty); 501 ATF_TEST_CASE_BODY(instantiate__vector_value__out_of_range__not_empty) 502 { 503 const std::string input = 504 "%%testvector(j)%%\n"; 505 506 text::templates_def templates; 507 templates.add_vector("testvector"); 508 templates.add_to_vector("testvector", "a"); 509 templates.add_to_vector("testvector", "b"); 510 templates.add_variable("j", "2"); 511 512 do_test_fail(templates, input, "Index 'j' out of range at position '2'"); 513 } 514 515 516 ATF_TEST_CASE_WITHOUT_HEAD(instantiate__if__one_level__taken); 517 ATF_TEST_CASE_BODY(instantiate__if__one_level__taken) 518 { 519 const std::string input = 520 "first line\n" 521 "%if defined(some_var)\n" 522 "hello from within the variable conditional\n" 523 "%endif\n" 524 "%if defined(some_vector)\n" 525 "hello from within the vector conditional\n" 526 "%else\n" 527 "bye from within the vector conditional\n" 528 "%endif\n" 529 "some more\n"; 530 531 const std::string exp_output = 532 "first line\n" 533 "hello from within the variable conditional\n" 534 "hello from within the vector conditional\n" 535 "some more\n"; 536 537 text::templates_def templates; 538 templates.add_variable("some_var", "zzz"); 539 templates.add_vector("some_vector"); 540 541 do_test_ok(templates, input, exp_output); 542 } 543 544 545 ATF_TEST_CASE_WITHOUT_HEAD(instantiate__if__one_level__not_taken); 546 ATF_TEST_CASE_BODY(instantiate__if__one_level__not_taken) 547 { 548 const std::string input = 549 "first line\n" 550 "%if defined(some_var)\n" 551 "hello from within the variable conditional\n" 552 "%endif\n" 553 "%if defined(some_vector)\n" 554 "hello from within the vector conditional\n" 555 "%else\n" 556 "bye from within the vector conditional\n" 557 "%endif\n" 558 "some more\n"; 559 560 const std::string exp_output = 561 "first line\n" 562 "bye from within the vector conditional\n" 563 "some more\n"; 564 565 text::templates_def templates; 566 567 do_test_ok(templates, input, exp_output); 568 } 569 570 571 ATF_TEST_CASE_WITHOUT_HEAD(instantiate__if__multiple_levels__taken); 572 ATF_TEST_CASE_BODY(instantiate__if__multiple_levels__taken) 573 { 574 const std::string input = 575 "first line\n" 576 "%if defined(var1)\n" 577 "first before\n" 578 "%if length(var2)\n" 579 "second before\n" 580 "%if defined(var3)\n" 581 "third before\n" 582 "hello from within the conditional\n" 583 "third after\n" 584 "%endif\n" 585 "second after\n" 586 "%else\n" 587 "second after not shown\n" 588 "%endif\n" 589 "first after\n" 590 "%endif\n" 591 "some more\n"; 592 593 const std::string exp_output = 594 "first line\n" 595 "first before\n" 596 "second before\n" 597 "third before\n" 598 "hello from within the conditional\n" 599 "third after\n" 600 "second after\n" 601 "first after\n" 602 "some more\n"; 603 604 text::templates_def templates; 605 templates.add_variable("var1", "false"); 606 templates.add_vector("var2"); 607 templates.add_to_vector("var2", "not-empty"); 608 templates.add_variable("var3", "foobar"); 609 610 do_test_ok(templates, input, exp_output); 611 } 612 613 614 ATF_TEST_CASE_WITHOUT_HEAD(instantiate__if__multiple_levels__not_taken); 615 ATF_TEST_CASE_BODY(instantiate__if__multiple_levels__not_taken) 616 { 617 const std::string input = 618 "first line\n" 619 "%if defined(var1)\n" 620 "first before\n" 621 "%if length(var2)\n" 622 "second before\n" 623 "%if defined(var3)\n" 624 "third before\n" 625 "hello from within the conditional\n" 626 "third after\n" 627 "%else\n" 628 "will not be shown either\n" 629 "%endif\n" 630 "second after\n" 631 "%else\n" 632 "second after shown\n" 633 "%endif\n" 634 "first after\n" 635 "%endif\n" 636 "some more\n"; 637 638 const std::string exp_output = 639 "first line\n" 640 "first before\n" 641 "second after shown\n" 642 "first after\n" 643 "some more\n"; 644 645 text::templates_def templates; 646 templates.add_variable("var1", "false"); 647 templates.add_vector("var2"); 648 templates.add_vector("var3"); 649 650 do_test_ok(templates, input, exp_output); 651 } 652 653 654 ATF_TEST_CASE_WITHOUT_HEAD(instantiate__loop__no_iterations); 655 ATF_TEST_CASE_BODY(instantiate__loop__no_iterations) 656 { 657 const std::string input = 658 "first line\n" 659 "%loop table1 i\n" 660 "hello\n" 661 "value in vector: %%table1(i)%%\n" 662 "%if defined(var1)\n" "some other text\n" "%endif\n" 663 "%endloop\n" 664 "some more\n"; 665 666 const std::string exp_output = 667 "first line\n" 668 "some more\n"; 669 670 text::templates_def templates; 671 templates.add_variable("var1", "defined"); 672 templates.add_vector("table1"); 673 674 do_test_ok(templates, input, exp_output); 675 } 676 677 678 ATF_TEST_CASE_WITHOUT_HEAD(instantiate__loop__multiple_iterations); 679 ATF_TEST_CASE_BODY(instantiate__loop__multiple_iterations) 680 { 681 const std::string input = 682 "first line\n" 683 "%loop table1 i\n" 684 "hello %%table1(i)%% %%table2(i)%%\n" 685 "%endloop\n" 686 "some more\n"; 687 688 const std::string exp_output = 689 "first line\n" 690 "hello foo1 foo2\n" 691 "hello bar1 bar2\n" 692 "some more\n"; 693 694 text::templates_def templates; 695 templates.add_vector("table1"); 696 templates.add_to_vector("table1", "foo1"); 697 templates.add_to_vector("table1", "bar1"); 698 templates.add_vector("table2"); 699 templates.add_to_vector("table2", "foo2"); 700 templates.add_to_vector("table2", "bar2"); 701 702 do_test_ok(templates, input, exp_output); 703 } 704 705 706 ATF_TEST_CASE_WITHOUT_HEAD(instantiate__loop__nested__no_iterations); 707 ATF_TEST_CASE_BODY(instantiate__loop__nested__no_iterations) 708 { 709 const std::string input = 710 "first line\n" 711 "%loop table1 i\n" 712 "before: %%table1(i)%%\n" 713 "%loop table2 j\n" 714 "before: %%table2(j)%%\n" 715 "%loop table3 k\n" 716 "%%table3(k)%%\n" 717 "%endloop\n" 718 "after: %%table2(i)%%\n" 719 "%endloop\n" 720 "after: %%table1(i)%%\n" 721 "%endloop\n" 722 "some more\n"; 723 724 const std::string exp_output = 725 "first line\n" 726 "before: a\n" 727 "after: a\n" 728 "before: b\n" 729 "after: b\n" 730 "some more\n"; 731 732 text::templates_def templates; 733 templates.add_vector("table1"); 734 templates.add_to_vector("table1", "a"); 735 templates.add_to_vector("table1", "b"); 736 templates.add_vector("table2"); 737 templates.add_vector("table3"); 738 templates.add_to_vector("table3", "1"); 739 740 do_test_ok(templates, input, exp_output); 741 } 742 743 744 ATF_TEST_CASE_WITHOUT_HEAD(instantiate__loop__nested__multiple_iterations); 745 ATF_TEST_CASE_BODY(instantiate__loop__nested__multiple_iterations) 746 { 747 const std::string input = 748 "first line\n" 749 "%loop table1 i\n" 750 "%loop table2 j\n" 751 "%%table1(i)%% %%table2(j)%%\n" 752 "%endloop\n" 753 "%endloop\n" 754 "some more\n"; 755 756 const std::string exp_output = 757 "first line\n" 758 "a 1\n" 759 "a 2\n" 760 "a 3\n" 761 "b 1\n" 762 "b 2\n" 763 "b 3\n" 764 "some more\n"; 765 766 text::templates_def templates; 767 templates.add_vector("table1"); 768 templates.add_to_vector("table1", "a"); 769 templates.add_to_vector("table1", "b"); 770 templates.add_vector("table2"); 771 templates.add_to_vector("table2", "1"); 772 templates.add_to_vector("table2", "2"); 773 templates.add_to_vector("table2", "3"); 774 775 do_test_ok(templates, input, exp_output); 776 } 777 778 779 ATF_TEST_CASE_WITHOUT_HEAD(instantiate__loop__sequential); 780 ATF_TEST_CASE_BODY(instantiate__loop__sequential) 781 { 782 const std::string input = 783 "first line\n" 784 "%loop table1 iter\n" 785 "1: %%table1(iter)%%\n" 786 "%endloop\n" 787 "divider\n" 788 "%loop table2 iter\n" 789 "2: %%table2(iter)%%\n" 790 "%endloop\n" 791 "divider\n" 792 "%loop table3 iter\n" 793 "3: %%table3(iter)%%\n" 794 "%endloop\n" 795 "divider\n" 796 "%loop table4 iter\n" 797 "4: %%table4(iter)%%\n" 798 "%endloop\n" 799 "some more\n"; 800 801 const std::string exp_output = 802 "first line\n" 803 "1: a\n" 804 "1: b\n" 805 "divider\n" 806 "divider\n" 807 "divider\n" 808 "4: 1\n" 809 "4: 2\n" 810 "4: 3\n" 811 "some more\n"; 812 813 text::templates_def templates; 814 templates.add_vector("table1"); 815 templates.add_to_vector("table1", "a"); 816 templates.add_to_vector("table1", "b"); 817 templates.add_vector("table2"); 818 templates.add_vector("table3"); 819 templates.add_vector("table4"); 820 templates.add_to_vector("table4", "1"); 821 templates.add_to_vector("table4", "2"); 822 templates.add_to_vector("table4", "3"); 823 824 do_test_ok(templates, input, exp_output); 825 } 826 827 828 ATF_TEST_CASE_WITHOUT_HEAD(instantiate__loop__scoping); 829 ATF_TEST_CASE_BODY(instantiate__loop__scoping) 830 { 831 const std::string input = 832 "%loop table1 i\n" 833 "%if defined(i)\n" "i defined inside scope 1\n" "%endif\n" 834 "%loop table2 j\n" 835 "%if defined(i)\n" "i defined inside scope 2\n" "%endif\n" 836 "%if defined(j)\n" "j defined inside scope 2\n" "%endif\n" 837 "%endloop\n" 838 "%if defined(j)\n" "j defined inside scope 1\n" "%endif\n" 839 "%endloop\n" 840 "%if defined(i)\n" "i defined outside\n" "%endif\n" 841 "%if defined(j)\n" "j defined outside\n" "%endif\n"; 842 843 const std::string exp_output = 844 "i defined inside scope 1\n" 845 "i defined inside scope 2\n" 846 "j defined inside scope 2\n" 847 "i defined inside scope 1\n" 848 "i defined inside scope 2\n" 849 "j defined inside scope 2\n"; 850 851 text::templates_def templates; 852 templates.add_vector("table1"); 853 templates.add_to_vector("table1", "first"); 854 templates.add_to_vector("table1", "second"); 855 templates.add_vector("table2"); 856 templates.add_to_vector("table2", "first"); 857 858 do_test_ok(templates, input, exp_output); 859 } 860 861 862 ATF_TEST_CASE_WITHOUT_HEAD(instantiate__mismatched_delimiters); 863 ATF_TEST_CASE_BODY(instantiate__mismatched_delimiters) 864 { 865 const std::string input = 866 "this is some %% text\n" 867 "and this is %%var%% text%%\n"; 868 869 const std::string exp_output = 870 "this is some %% text\n" 871 "and this is some more text%%\n"; 872 873 text::templates_def templates; 874 templates.add_variable("var", "some more"); 875 876 do_test_ok(templates, input, exp_output); 877 } 878 879 880 ATF_TEST_CASE_WITHOUT_HEAD(instantiate__empty_statement); 881 ATF_TEST_CASE_BODY(instantiate__empty_statement) 882 { 883 do_test_fail(text::templates_def(), "%\n", "Empty statement"); 884 } 885 886 887 ATF_TEST_CASE_WITHOUT_HEAD(instantiate__unknown_statement); 888 ATF_TEST_CASE_BODY(instantiate__unknown_statement) 889 { 890 do_test_fail(text::templates_def(), "%if2\n", "Unknown statement 'if2'"); 891 } 892 893 894 ATF_TEST_CASE_WITHOUT_HEAD(instantiate__invalid_narguments); 895 ATF_TEST_CASE_BODY(instantiate__invalid_narguments) 896 { 897 do_test_fail(text::templates_def(), "%if a b\n", 898 "Invalid number of arguments for statement 'if'"); 899 } 900 901 902 ATF_TEST_CASE_WITHOUT_HEAD(instantiate__files__ok); 903 ATF_TEST_CASE_BODY(instantiate__files__ok) 904 { 905 text::templates_def templates; 906 templates.add_variable("string", "Hello, world!"); 907 908 atf::utils::create_file("input.txt", "The string is: %%string%%\n"); 909 910 text::instantiate(templates, fs::path("input.txt"), fs::path("output.txt")); 911 912 std::ifstream output("output.txt"); 913 std::string line; 914 ATF_REQUIRE(std::getline(output, line).good()); 915 ATF_REQUIRE_EQ(line, "The string is: Hello, world!"); 916 ATF_REQUIRE(std::getline(output, line).eof()); 917 } 918 919 920 ATF_TEST_CASE_WITHOUT_HEAD(instantiate__files__input_error); 921 ATF_TEST_CASE_BODY(instantiate__files__input_error) 922 { 923 text::templates_def templates; 924 ATF_REQUIRE_THROW_RE(text::error, "Failed to open input.txt for read", 925 text::instantiate(templates, fs::path("input.txt"), 926 fs::path("output.txt"))); 927 } 928 929 930 ATF_TEST_CASE(instantiate__files__output_error); 931 ATF_TEST_CASE_HEAD(instantiate__files__output_error) 932 { 933 set_md_var("require.user", "unprivileged"); 934 } 935 ATF_TEST_CASE_BODY(instantiate__files__output_error) 936 { 937 text::templates_def templates; 938 939 atf::utils::create_file("input.txt", ""); 940 941 fs::mkdir(fs::path("dir"), 0444); 942 943 ATF_REQUIRE_THROW_RE(text::error, "Failed to open dir/output.txt for write", 944 text::instantiate(templates, fs::path("input.txt"), 945 fs::path("dir/output.txt"))); 946 } 947 948 949 ATF_INIT_TEST_CASES(tcs) 950 { 951 ATF_ADD_TEST_CASE(tcs, templates_def__add_variable__first); 952 ATF_ADD_TEST_CASE(tcs, templates_def__add_variable__replace); 953 ATF_ADD_TEST_CASE(tcs, templates_def__remove_variable); 954 ATF_ADD_TEST_CASE(tcs, templates_def__add_vector__first); 955 ATF_ADD_TEST_CASE(tcs, templates_def__add_vector__replace); 956 ATF_ADD_TEST_CASE(tcs, templates_def__add_to_vector); 957 ATF_ADD_TEST_CASE(tcs, templates_def__exists__variable); 958 ATF_ADD_TEST_CASE(tcs, templates_def__exists__vector); 959 ATF_ADD_TEST_CASE(tcs, templates_def__get_variable__ok); 960 ATF_ADD_TEST_CASE(tcs, templates_def__get_variable__unknown); 961 ATF_ADD_TEST_CASE(tcs, templates_def__get_vector__ok); 962 ATF_ADD_TEST_CASE(tcs, templates_def__get_vector__unknown); 963 ATF_ADD_TEST_CASE(tcs, templates_def__evaluate__variable__ok); 964 ATF_ADD_TEST_CASE(tcs, templates_def__evaluate__variable__unknown); 965 ATF_ADD_TEST_CASE(tcs, templates_def__evaluate__vector__ok); 966 ATF_ADD_TEST_CASE(tcs, templates_def__evaluate__vector__unknown_vector); 967 ATF_ADD_TEST_CASE(tcs, templates_def__evaluate__vector__unknown_index); 968 ATF_ADD_TEST_CASE(tcs, templates_def__evaluate__vector__out_of_range); 969 ATF_ADD_TEST_CASE(tcs, templates_def__evaluate__defined); 970 ATF_ADD_TEST_CASE(tcs, templates_def__evaluate__length__ok); 971 ATF_ADD_TEST_CASE(tcs, templates_def__evaluate__length__unknown_vector); 972 ATF_ADD_TEST_CASE(tcs, templates_def__evaluate__parenthesis_error); 973 974 ATF_ADD_TEST_CASE(tcs, instantiate__empty_input); 975 ATF_ADD_TEST_CASE(tcs, instantiate__value__ok); 976 ATF_ADD_TEST_CASE(tcs, instantiate__value__unknown_variable); 977 ATF_ADD_TEST_CASE(tcs, instantiate__vector_length__ok); 978 ATF_ADD_TEST_CASE(tcs, instantiate__vector_length__unknown_vector); 979 ATF_ADD_TEST_CASE(tcs, instantiate__vector_value__ok); 980 ATF_ADD_TEST_CASE(tcs, instantiate__vector_value__unknown_vector); 981 ATF_ADD_TEST_CASE(tcs, instantiate__vector_value__out_of_range__empty); 982 ATF_ADD_TEST_CASE(tcs, instantiate__vector_value__out_of_range__not_empty); 983 ATF_ADD_TEST_CASE(tcs, instantiate__if__one_level__taken); 984 ATF_ADD_TEST_CASE(tcs, instantiate__if__one_level__not_taken); 985 ATF_ADD_TEST_CASE(tcs, instantiate__if__multiple_levels__taken); 986 ATF_ADD_TEST_CASE(tcs, instantiate__if__multiple_levels__not_taken); 987 ATF_ADD_TEST_CASE(tcs, instantiate__loop__no_iterations); 988 ATF_ADD_TEST_CASE(tcs, instantiate__loop__multiple_iterations); 989 ATF_ADD_TEST_CASE(tcs, instantiate__loop__nested__no_iterations); 990 ATF_ADD_TEST_CASE(tcs, instantiate__loop__nested__multiple_iterations); 991 ATF_ADD_TEST_CASE(tcs, instantiate__loop__sequential); 992 ATF_ADD_TEST_CASE(tcs, instantiate__loop__scoping); 993 ATF_ADD_TEST_CASE(tcs, instantiate__mismatched_delimiters); 994 ATF_ADD_TEST_CASE(tcs, instantiate__empty_statement); 995 ATF_ADD_TEST_CASE(tcs, instantiate__unknown_statement); 996 ATF_ADD_TEST_CASE(tcs, instantiate__invalid_narguments); 997 998 ATF_ADD_TEST_CASE(tcs, instantiate__files__ok); 999 ATF_ADD_TEST_CASE(tcs, instantiate__files__input_error); 1000 ATF_ADD_TEST_CASE(tcs, instantiate__files__output_error); 1001 } 1002
Indexes created Wed Mar 04 15:26:31 UTC 2026