tests/test_ll.lua

   1 --[[--------------------------------------------------------------------
   2
   3   Gazelle: a system for building fast, reusable parsers
   4
   5   tests/test_ll.lua
   6
   7   Tests for the LL(*) lookahead generation.  This is the among the
   8   most complicated things the complier does, and it has a lot of edge
   9   cases and failure modes, so this file is complicated and subtle.
  10
  11   Copyright (c) 2008 Joshua Haberman.  See LICENSE for details.
  12
  13 --------------------------------------------------------------------]]--
  14
  15 require "luaunit"
  16 require "ll"
  17 require "fa_algorithms"
  18 require "bootstrap/rtn"
  19 require "pp"
  20
  21 function find_state(rule, slotnum)
  22   if slotnum == 0 then
  23     return rule.start
  24   end
  25
  26   for s in each(rule:states()) do
  27     for edge_val, dest_state, properties in s:transitions() do
  28       if properties.slotnum == slotnum then
  29         return s
  30       end
  31     end
  32   end
  33
  34   error(string.format("No such slotnum (%d) for rule %s", slotnum, rule_str))
  35 end
  36
  37 function get_target_for_slotnum(state, slotnum)
  38   if slotnum == 0 then
  39     return {0, 0}
  40   else
  41     for edge_val, dest_state, properties in state:transitions() do
  42       if properties.slotnum == slotnum then
  43         return {edge_val, dest_state}
  44       end
  45     end
  46   end
  47   error(string.format("Slotnum %d not found for state %s", slotnum, serialize(state, 6, "  ")))
  48 end
  49
  50 function parse_gla(str, rtn_state)
  51   local stream = CharStream:new(str)
  52   stream:ignore("whitespace")
  53   local gla = fa.GLA:new()
  54   gla.rtn_state = rtn_state
  55   local states = {[1]=gla.start}
  56   while not stream:eof() do
  57     local statenum = tonumber(stream:consume_pattern("%d+"))
  58     local state = states[statenum]
  59     if not state then
  60       error(string.format("GLA refers to state %d before it is used as a target",
  61             statenum))
  62     end
  63     while stream:lookahead(1) ~= ";" do
  64       stream:consume("-")
  65       local term = stream:consume_pattern("%w+")
  66       stream:consume("->")
  67       local dest_state_num = tonumber(stream:consume_pattern("%d+"))
  68       states[dest_state_num] = states[dest_state_num] or fa.GLAState:new()
  69       local dest_state = states[dest_state_num]
  70       if term == "EOF" then
  71         state:add_transition(fa.eof, dest_state)
  72       else
  73         state:add_transition(term, dest_state)
  74       end
  75       if stream:lookahead(1) == "(" then
  76         stream:consume("(")
  77         local final_state_slotnum = tonumber(stream:consume_pattern("%d+"))
  78         stream:consume(")")
  79         dest_state.final = get_target_for_slotnum(rtn_state, final_state_slotnum)
  80       end
  81       state = dest_state
  82     end
  83     stream:consume(";")
  84   end
  85
  86   return gla
  87 end
  88
  89 function assert_lookahead(grammar_str, rule_str, slotnum, expected_gla_str, k)
  90   local grammar = parse_grammar(CharStream:new(grammar_str))
  91   grammar:assign_priorities()
  92   grammar:determinize_rtns()
  93   grammar:minimize_rtns()
  94
  95   local rule = grammar.rtns:get(rule_str)
  96   local state = find_state(rule, slotnum)
  97   local expected_gla = parse_gla(expected_gla_str, state)
  98
  99   compute_lookahead(grammar, k)
 100
 101   if not fa_isequal(expected_gla, state.gla) then
 102     local bad = io.open("bad.dot", "w")
 103     bad:write("digraph untitled {\n")
 104     bad:write(state.gla:to_dot())
 105     bad:write("}")
 106     bad:close()
 107
 108     local good = io.open("good.dot", "w")
 109     good:write("digraph untitled {\n")
 110     good:write(expected_gla:to_dot())
 111     good:write("}")
 112     good:close()
 113
 114     os.execute("dot -Tpng -o good.png good.dot")
 115     os.execute("dot -Tpng -o bad.png bad.dot")
 116
 117     error("GLAs were not equal: expected and actual are " ..
 118           "in good.png and bad.png, respectively")
 119   end
 120 end
 121
 122 TestSimple = {}
 123 function TestSimple:test1()
 124   assert_lookahead(
 125   [[
 126     s -> a | "X";
 127     a -> "Y";
 128   ]],
 129   "s", 0,
 130   [[
 131     1 -Y-> 2(1);
 132     1 -X-> 3(2);
 133   ]]
 134   )
 135 end
 136
 137 function TestSimple:test_multiple_recursions()
 138   assert_lookahead(
 139   [[
 140     s -> a | "X";
 141     a -> b;
 142     b -> "Y";
 143   ]],
 144   "s", 0,
 145   [[
 146     1 -Y-> 2(1);
 147     1 -X-> 3(2);
 148   ]]
 149   )
 150 end
 151
 152 TestEpsilon = {}
 153 function TestEpsilon:test1()
 154   assert_lookahead(
 155   [[
 156     s -> a "Z" | "X";
 157     a -> "Y"?;
 158   ]],
 159   "s", 0,
 160   [[
 161     1 -Y-> 2(1);
 162     1 -Z-> 2;
 163     1 -X-> 3(3);
 164   ]]
 165   )
 166 end
 167
 168 function TestEpsilon:test2()
 169   assert_lookahead(
 170   [[
 171     s -> a | "X";
 172     a -> "Y"? "Z" ;
 173   ]],
 174   "s", 0,
 175   [[
 176     1 -Y-> 2(1);
 177     1 -Z-> 2;
 178     1 -X-> 3(2);
 179   ]]
 180   )
 181 end
 182
 183 function TestEpsilon:test3()
 184   assert_lookahead(
 185   [[
 186     s -> a "Q" | "X";
 187     a -> "Y"? "Z"? ;
 188   ]],
 189   "s", 0,
 190   [[
 191     1 -Y-> 2(1);
 192     1 -Z-> 2;
 193     1 -Q-> 2;
 194     1 -X-> 3(3);
 195   ]]
 196   )
 197 end
 198
 199 function TestEpsilon:test4()
 200   assert_lookahead(
 201   [[
 202     s -> a "Q" | "X";
 203     a -> b "Y"?;
 204     b -> "Z"?;
 205   ]],
 206   "s", 0,
 207   [[
 208     1 -Y-> 2(1);
 209     1 -Z-> 2;
 210     1 -Q-> 2;
 211     1 -X-> 3(3);
 212   ]]
 213   )
 214 end
 215
 216 TestMultipleNonterms = {}
 217 function TestMultipleNonterms:test1()
 218   assert_lookahead(
 219   [[
 220     s -> a | b | c;
 221     a -> "X";
 222     b -> "Y";
 223     c -> "Z";
 224   ]],
 225   "s", 0,
 226   [[
 227     1 -X-> 2(1);
 228     1 -Y-> 3(2);
 229     1 -Z-> 4(3);
 230   ]]
 231   )
 232 end
 233
 234 function TestMultipleNonterms:test22()
 235   assert_lookahead(
 236   [[
 237     s -> (a | b | c)? d;
 238     a -> "X";
 239     b -> "Y";
 240     c -> "Z";
 241     d -> "Q";
 242   ]],
 243   "s", 0,
 244   [[
 245     1 -X-> 2(1);
 246     1 -Y-> 3(2);
 247     1 -Z-> 4(3);
 248     1 -Q-> 5(4);
 249   ]]
 250   )
 251 end
 252
 253 TestLL1 = {}
 254 function TestLL1:test1()
 255   assert_lookahead(
 256   [[
 257     s -> "X" s?;
 258   ]],
 259   "s", 2,
 260   [[
 261     1 -X-> 2(2);
 262     1 -EOF-> 3(0);
 263   ]]
 264   )
 265 end
 266
 267 TestLL2 = {}
 268 function TestLL2:test1()
 269   assert_lookahead(
 270   [[
 271     s -> "X" "Y" | "X" "Z";
 272   ]],
 273   "s", 0,
 274   [[
 275     1 -X-> 2;
 276     2 -Y-> 3(1);
 277     2 -Z-> 4(3);
 278   ]]
 279   )
 280 end
 281
 282 function TestLL2:test2()
 283   assert_lookahead(
 284   [[
 285     s -> a "Y" | a "Z";
 286     a -> "X";
 287   ]],
 288   "s", 0,
 289   [[
 290     1 -X-> 2;
 291     2 -Y-> 3(1);
 292     2 -Z-> 4(3);
 293   ]]
 294   )
 295 end
 296
 297 function TestLL2:test3()
 298   assert_lookahead(
 299   [[
 300     s -> a "Y" | a "Z";
 301     a -> "X" | "Q";
 302   ]],
 303   "s", 0,
 304   [[
 305     1 -X-> 2;
 306     1 -Q-> 2;
 307     2 -Y-> 3(1);
 308     2 -Z-> 4(3);
 309   ]]
 310   )
 311 end
 312
 313 function TestLL2:test3()
 314   assert_lookahead(
 315   [[
 316     s -> "X"? "Y" | "X" "Z";
 317   ]],
 318   "s", 0,
 319   [[
 320     1 -Y-> 2(2);
 321     1 -X-> 3;
 322     3 -Y-> 4(1);
 323     3 -Z-> 5(3);
 324   ]]
 325   )
 326 end
 327
 328 function TestLL2:test3()
 329   assert_lookahead(
 330   [[
 331     s -> "X" s | "X" "Y";
 332   ]],
 333   "s", 0,
 334   [[
 335     1 -X-> 2 -X-> 3(1);
 336     2 -Y-> 4(3);
 337   ]]
 338   )
 339 end
 340
 341 function TestLL2:test4()
 342   assert_lookahead(
 343   [[
 344     a -> b "X";
 345     b -> c*;
 346     c -> "X";
 347   ]],
 348   "b", 0,
 349   [[
 350     1 -X-> 2 -X-> 3(1);
 351     2 -EOF-> 4(0);
 352   ]]
 353   )
 354 end
 355
 356 function TestLL2:test5()
 357   assert_lookahead(
 358   [[
 359     s -> "X"+ | "X" "Y";
 360   ]],
 361   "s", 0,
 362   [[
 363     1 -X-> 2 -X-> 3(1);
 364     2 -EOF-> 3;
 365     2 -Y-> 4(2);
 366   ]]
 367   )
 368 end
 369
 370 function TestLL2:test6()
 371   assert_lookahead(
 372   [[
 373     s -> a? "X" "X";
 374     a -> "X" "Y" | "X" "Z";
 375   ]],
 376   "s", 0,
 377   [[
 378     1 -X-> 2 -X-> 3(2);
 379     2 -Y-> 4(1);
 380     2 -Z-> 4;
 381   ]]
 382   )
 383 end
 384
 385 TestLL3 = {}
 386 function TestLL3:test1()
 387   assert_lookahead(
 388   [[
 389     s -> a "X" | a "Y";
 390     a -> ("P" | "Q") ("P" | "Q");
 391   ]],
 392   "s", 0,
 393   [[
 394     1 -P-> 2 -P-> 3;
 395     1 -Q-> 2 -Q-> 3;
 396     2 -Q-> 3;
 397     2 -P-> 3;
 398     3 -X-> 4(1);
 399     3 -Y-> 5(3);
 400   ]]
 401   )
 402 end
 403
 404 -- This is equivalent to the grammar on page 271 of The Definitive ANTLR Reference.
 405 function TestLL3:test3()
 406   assert_lookahead(
 407   [[
 408     s -> "X" s "Y" | "X" "X" "Z";
 409   ]],
 410   "s", 0,
 411   [[
 412     1 -X-> 2 -X-> 3;
 413     3 -X-> 4(1);
 414     3 -Z-> 5(4);
 415   ]]
 416   )
 417 end
 418
 419 function TestLL3:test3()
 420   assert_lookahead(
 421   [[
 422     s -> a a "Y" | a a "Z";
 423     a -> "X";
 424   ]],
 425   "s", 0,
 426   [[
 427     1 -X-> 2 -X-> 3 -Y-> 4(1);
 428     3 -Z-> 5(4);
 429   ]]
 430   )
 431 end
 432
 433 TestEOF = {}
 434 function TestEOF:test1()
 435   assert_lookahead(
 436   [[
 437     s -> "A" | "A" "B";
 438   ]],
 439   "s", 0,
 440   [[
 441     1 -A-> 2;
 442     2 -B-> 3(2);
 443     2 -EOF-> 4(1);
 444   ]]
 445   )
 446 end
 447
 448 function TestEOF:test2()
 449   -- this is the example used by Terence Parr in his discussion of ANTLR 3.0's
 450   -- lookahead analysis: http://www.antlr.org/blog/antlr3/lookahead.tml
 451   assert_lookahead(
 452   [[
 453     s -> a "A" | a "B";
 454     a -> "A"?;
 455   ]],
 456   "s", 0,
 457   [[
 458     1 -A-> 2;
 459     1 -B-> 3(3);
 460     2 -B-> 3(3);
 461     2 -A-> 4(1);
 462     2 -EOF-> 4(1);
 463   ]]
 464   )
 465 end
 466
 467 function TestEOF:test3()
 468   assert_lookahead(
 469   [[
 470     s -> "A" a;
 471     a -> "A"?;
 472   ]],
 473   "a", 0,
 474   [[
 475     1 -A-> 2(1);
 476     1 -EOF-> 3(0);
 477   ]]
 478   )
 479 end
 480
 481 -- This is really a "follow" test
 482 function TestEOF:test4()
 483   assert_lookahead(
 484   [[
 485     s -> "X" a "Y";
 486     a -> b;
 487     b -> "X"?;
 488   ]],
 489   "b", 0,
 490   [[
 491     1 -X-> 2(1);
 492     1 -Y-> 3(0);
 493   ]]
 494   )
 495 end
 496
 497
 498 TestLLStar = {}
 499 function TestLLStar:test1()
 500   assert_lookahead(
 501   [[
 502     s -> a "X" | a "Y";
 503     a -> "Z"*;
 504   ]],
 505   "s", 0,
 506   [[
 507     1 -Z-> 1;
 508     1 -X-> 2(1);
 509     1 -Y-> 3(3);
 510   ]]
 511   )
 512 end
 513
 514 -- Test lookahead that we can only compute correctly if we apply the
 515 -- tail-recursion optimization.
 516 function TestLLStar:test2()
 517   assert_lookahead(
 518   [[
 519     s -> a "X" | a "Y";
 520     a -> ("Z" a)?;
 521   ]],
 522   "s", 0,
 523   [[
 524     1 -Z-> 1;
 525     1 -X-> 2(1);
 526     1 -Y-> 3(3);
 527   ]]
 528   )
 529 end
 530
 531 TestFollow = {}
 532 function TestFollow:test1()
 533   assert_lookahead(
 534   [[
 535     s -> a "X";
 536     a -> "Y" "Y" | "Y";
 537   ]],
 538   "a", 0,
 539   [[
 540     1 -Y-> 2;
 541     2 -Y-> 3(1);
 542     2 -X-> 4(3);
 543   ]]
 544   )
 545 end
 546
 547 function TestFollow:test2()
 548   assert_lookahead(
 549   [[
 550     s -> a "X";
 551     a -> "Y"?;
 552   ]],
 553   "a", 0,
 554   [[
 555     1 -Y-> 2(1);
 556     1 -X-> 3(0);
 557   ]]
 558   )
 559 end
 560
 561 function assert_fails_with_error(grammar_str, error_string)
 562   local grammar = parse_grammar(CharStream:new(grammar_str))
 563   grammar:assign_priorities()
 564   grammar:determinize_rtns()
 565   grammar:minimize_rtns()
 566
 567   local success, message = pcall(compute_lookahead, grammar)
 568   if success then
 569     error("Failed to fail!")
 570   elseif not message:find(error_string) then
 571     error("Failed with wrong message!  Message was supposed to contain  "
 572           .. error_string .. ", but it was: " .. message)
 573   end
 574 end
 575
 576 function assert_left_recursive(grammar_str)
 577   assert_fails_with_error(grammar_str, "it is left%-recursive")
 578 end
 579
 580 function assert_nonregular(grammar_str)
 581   assert_fails_with_error(grammar_str, "one lookahead language was nonregular, others were not all fixed")
 582 end
 583
 584 function assert_ambiguous(grammar_str)
 585   assert_fails_with_error(grammar_str, "Ambiguous grammar")
 586 end
 587
 588 function assert_no_nonrecursive_alt(grammar_str)
 589   assert_fails_with_error(grammar_str, "no non%-recursive alternative")
 590 end
 591
 592 function assert_not_ll(grammar_str)
 593   assert_fails_with_error(grammar_str, "It is not Strong%-LL or full%-LL")
 594 end
 595
 596 function assert_never_taken(grammar_str)
 597   assert_fails_with_error(grammar_str, "will never be taken")
 598 end
 599
 600 function assert_resolution_not_supported(grammar_str)
 601   assert_fails_with_error(grammar_str, "cannot support this resolution of the ambiguity")
 602 end
 603
 604 TestDetectNonLLStar = {}
 605 function TestDetectNonLLStar:test_left_recursive()
 606   assert_left_recursive(
 607   [[
 608     s -> s? "X";
 609   ]]
 610   )
 611 end
 612
 613 function TestDetectNonLLStar:test_left_recursive2()
 614   assert_left_recursive(
 615   [[
 616     s -> a | "X";
 617     a -> s | "Y";
 618   ]]
 619   )
 620 end
 621
 622 function TestDetectNonLLStar:test_left_recursive3()
 623   assert_left_recursive(
 624   [[
 625     s -> (s "X")?;
 626   ]]
 627   )
 628 end
 629
 630 -- Hmm, technically this test is broken because this is left-recursion
 631 -- that is getting incorrectly reported as ambiguity instead.  But
 632 -- fixing this one isn't a high priority right now.
 633 -- function TestDetectNonLLStar:test_left_recursive4()
 634 --   assert_left_recursive(
 635 --   [[
 636 --     s -> a b?;
 637 --     a -> "X"?;
 638 --     b -> s;
 639 --   ]]
 640 --   )
 641 -- end
 642
 643 function TestDetectNonLLStar:test_nonregular()
 644   assert_nonregular(
 645   [[
 646     s -> e "%" | e "!";
 647     e -> "(" e ")" | "ID";
 648   ]]
 649   )
 650 end
 651
 652 function TestDetectNonLLStar:test_fails_heuristic_but_is_ll()
 653   assert_nonregular(
 654   [[
 655     s -> "X"* "Y" "Y" "Z"| "X" c;
 656     c -> "Y" c "Y" | "Q";
 657   ]]
 658   )
 659   assert_lookahead(
 660   [[
 661     s -> "X"* "Y" "Y" "Z"| "X" c;
 662     c -> "Y" c "Y" | "Q";
 663   ]],
 664   "s", 0,
 665   [[
 666     1 -Y-> 2(2);
 667     1 -X-> 3 -Y-> 4 -Y-> 5 -Y-> 6(5);
 668     3 -Q-> 6;
 669     4 -Q-> 6;
 670     5 -Q-> 6;
 671     5 -Z-> 7(1);
 672     3 -X-> 7;
 673   ]],
 674   4
 675   )
 676 end
 677
 678 function TestDetectNonLLStar:test_not_full_ll_1()
 679   assert_not_ll(
 680   [[
 681     s -> a a;
 682     a -> b;
 683     b -> "X"*;
 684   ]]
 685   )
 686 end
 687
 688 function TestDetectNonLLStar:test_not_full_ll_1()
 689   assert_not_ll(
 690   [[
 691     s -> ("X" s "X")?;
 692   ]]
 693   )
 694 end
 695
 696 function TestDetectNonLLStar:test_not_full_ll_2()
 697   assert_not_ll(
 698   [[
 699     s -> "if" e "then" s ("else" s)? | e;
 700     e -> "5";
 701   ]]
 702   )
 703 end
 704
 705
 706 TestAmbiguity = {}
 707 function TestAmbiguity:test1()
 708   assert_ambiguous(
 709   [[
 710     a -> b | c;
 711     b -> c;
 712     c -> "X";
 713   ]]
 714   )
 715 end
 716
 717 function TestAmbiguity:test2()
 718   assert_ambiguous(
 719   [[
 720     a -> b c "Y";
 721     b -> "X" ?;
 722     c -> "X" ?;
 723   ]]
 724   )
 725 end
 726
 727 function TestAmbiguity:test3()
 728   assert_ambiguous(
 729   [[
 730     a -> (b | c) "Y";
 731     b -> "X";
 732     c -> "X";
 733   ]]
 734   )
 735 end
 736
 737 function TestAmbiguity:test4()
 738   assert_ambiguous(
 739   [[
 740     s -> a "X"?;
 741     a -> "X"?;
 742   ]]
 743   )
 744 end
 745
 746 function TestAmbiguity:test5()
 747   assert_ambiguous(
 748   [[
 749     s -> a "X"*;
 750     a -> "X"*;
 751   ]]
 752   )
 753 end
 754
 755 function TestAmbiguity:test6()
 756   assert_ambiguous(
 757   [[
 758     s -> a? a?;
 759     a -> "X";
 760   ]]
 761   )
 762 end
 763
 764 function TestAmbiguity:test7()
 765   assert_ambiguous(
 766   [[
 767     s -> "X" | "X";
 768   ]]
 769   )
 770 end
 771
 772 function TestAmbiguity:test8()
 773   assert_ambiguous(
 774   [[
 775     s -> "X"? | "X";
 776   ]]
 777   )
 778 end
 779
 780 function TestAmbiguity:test9()
 781   assert_ambiguous(
 782   [[
 783     s -> "X"? | "X"?;
 784   ]]
 785   )
 786 end
 787
 788 function TestAmbiguity:test10()
 789   assert_ambiguous(
 790   [[
 791     s -> a b;
 792     a -> "X"*;
 793     b -> "X"*;
 794   ]]
 795   )
 796 end
 797
 798 function TestAmbiguity:test11()
 799   assert_ambiguous(
 800   [[
 801     s -> a*;
 802     a -> "X"?;
 803   ]]
 804   )
 805 end
 806
 807 function TestAmbiguity:test12()
 808   assert_ambiguous(
 809   [[
 810     s -> a*;
 811     a -> "X"*;
 812   ]]
 813   )
 814 end
 815
 816 -- These tests are currently failing because I have not implemented this
 817 -- check yet!
 818 TestNoNonRecursiveAlt = {}
 819 function TestNoNonRecursiveAlt:test1()
 820   assert_no_nonrecursive_alt(
 821   [[
 822     a -> a;
 823   ]]
 824   )
 825 end
 826
 827 function TestNoNonRecursiveAlt:test2()
 828   assert_no_nonrecursive_alt(
 829   [[
 830     a -> "X" a;
 831   ]]
 832   )
 833 end
 834
 835 function TestNoNonRecursiveAlt:test3()
 836   assert_no_nonrecursive_alt(
 837   [[
 838     a -> "X" b;
 839     b -> a;
 840   ]]
 841   )
 842 end
 843
 844 function TestNoNonRecursiveAlt:test4()
 845   assert_no_nonrecursive_alt(
 846   [[
 847     s -> a b;
 848     a -> "X"?;
 849     b -> s;
 850   ]]
 851   )
 852 end
 853
 854 function TestNoNonRecursiveAlt:test4()
 855   assert_no_nonrecursive_alt(
 856   [[
 857     a -> "X" b;
 858     b -> "X" a;
 859   ]]
 860   )
 861 end
 862
 863 TestAmbiguityResolution = {}
 864 function TestAmbiguityResolution:test1()
 865   assert_lookahead(
 866   [[
 867     s -> "X" "Y" / "X"+ "Y";
 868   ]],
 869   "s", 0,
 870   [[
 871     1 -X-> 2 -Y-> 3(1);
 872     2 -X-> 4(3);
 873   ]]
 874   )
 875 end
 876
 877 function TestAmbiguityResolution:test2()
 878   assert_lookahead(
 879   [[
 880     s -> "if" e "then" s ("else" s)?+ | e;
 881     e -> "5";
 882   ]],
 883   "s", 5,
 884   [[
 885     1 -else-> 2(5);
 886     1 -EOF-> 3(0);
 887   ]]
 888   )
 889 end
 890
 891 function TestAmbiguityResolution:test_never_taken1()
 892   assert_never_taken(
 893   [[
 894     s -> "X" "Y" / "X" "Y";
 895   ]]
 896   )
 897 end
 898
 899 -- This test is currently failing -- it's throwing the wrong error message.
 900 -- Instead of warning you that one transition is never taken, it just says
 901 -- that Gazelle can't support this resolution of the ambiguity.
 902 function TestAmbiguityResolution:test_never_taken2()
 903   assert_never_taken(
 904   [[
 905     s -> a b / "X" "Y";
 906     a -> "X";
 907     b -> "Y";
 908   ]]
 909   )
 910 end
 911
 912 function TestAmbiguityResolution:test_never_taken3()
 913   assert_never_taken(
 914   [[
 915     s -> "X"* "Y" / "X" "Y";
 916   ]]
 917   )
 918 end
 919
 920 function TestAmbiguityResolution:test_resolution_not_supported1()
 921   assert_resolution_not_supported(
 922   [[
 923     s -> "S" / "S" s "S";
 924   ]]
 925   )
 926 end
 927
 928 function TestDetectNonLLStar:test_resolution_not_supported2()
 929   assert_resolution_not_supported(
 930   [[
 931     s -> "if" e "then" s ("else" s)?- | e;
 932     e -> "5";
 933   ]]
 934   )
 935 end
 936
 937
 938 LuaUnit:run(unpack(arg))
 939