babel_bridge 0.4.1 → 0.5.0

data/test/test_bb.rb

@@ -1,458 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__),"..","lib","babel_bridge"))
-require File.expand_path(File.join(File.dirname(__FILE__),"test_helper"))
-
-class BBTests < TestHelper
-
-  def new_module
-   @module_counter||=0
-   @module_counter+=1
-   "TestModule#{@module_counter}"
-  end
-
-  def new_parser(&block)
-    @parser_counter||=0
-    @parser_counter+=1
-    Object.const_set(klass_name="TestParser#{@parser_counter}",Class.new(BabelBridge::Parser,&block))
-    Object.const_get(klass_name).new
-  end
-
-  def test_foobar
-    parser=new_parser do #Class.new BabelBridge::Parser do
-      rule :foo, "foo", :bar
-      rule :bar, "bar"
-    end
-
-    assert_nil parser.parse("foo")
-    assert parser.parse("foobar")
-  end
-
-  def test_as
-    parser=new_parser do
-      rule :foo, match("foo").as(:boo)
-    end
-
-    assert parser.parse("foo")
-    assert_equal "foo", parser.parse("foo").boo.text
-  end
-
-  def test_many_as
-    parser=new_parser do
-      rule :foo, many("foo").as(:boo)
-    end
-
-    assert parser.parse("foo")
-    assert parser.parse("foofoo")
-    assert_equal "foofoo", parser.parse("foofoo").boo.text
-  end
-
-  def test_negative
-    parser=new_parser do
-      rule :foo, match!("boo"), /[a-zA-Z]+/
-    end
-
-    assert_nil parser.parse("boo")
-    assert parser.parse("foo")
-    assert parser.parse("boO")
-    assert parser.parse("abc")
-  end
-
-  def test_foo
-    parser=new_parser do
-      rule :foo, "foo"
-    end
-
-    assert p=parser.parse("foo")
-    assert_equal 0,p.offset
-    assert_equal 3,p.match_length
-  end
-
-  def test_regex
-    parser=new_parser do
-      rule :foo, /[0-9]+/
-    end
-
-    %w{ 0 1 10 123 1001 }.each do |numstr|
-      assert_equal numstr,parser.parse(numstr).text
-    end
-  end
-
-  def test_regex_offset
-    parser=new_parser do
-      rule :foo, /[0-9]+/
-      rule :foo, "hi", /[0-9]+/
-    end
-
-    assert_equal 1,parser.parse("123").matches.length
-    assert_equal 2,parser.parse("hi123").matches.length
-  end
-
-  def test_optional
-    parser=new_parser do
-      rule :foo, "foo", :bar?
-      rule :bar, "bar"
-    end
-
-    assert parser.parse("foo")
-    assert parser.parse("foobar")
-  end
-
-  def test_could
-    parser=new_parser do
-      rule :foo, could.match(/[a-z]/), /[a-zA-Z]+/
-    end
-    assert_nil parser.parse("FOO")
-    assert parser.parse("fOO")
-    assert parser.parse("foo")
-  end
-
-  def test_optional_middle
-    parser=new_parser do
-      rule :foo, "foo", :bar?, "foo"
-      rule :bar, "bar"
-    end
-
-    assert parser.parse("foofoo")
-    assert parser.parse("foobarfoo")
-  end
-
-  def test_greedy_optional_middle
-    parser=new_parser do
-      rule :foo, "foo", :bar?, "foo"
-      rule :bar, "foo"
-    end
-
-    assert_nil parser.parse("foofoo")
-    assert parser.parse("foofoofoo")
-  end
-
-  def test_not
-    parser=new_parser do
-      rule :foo, "foo", :bar!
-      rule :bar, "bar"
-    end
-
-    assert_nil parser.parse("foofud") # this should fail because it doesn't match the entire input
-    assert parser.parse("foofud",0,:foo)
-    assert parser.parse("foo")
-    assert_nil parser.parse("foobar")
-  end
-
-  def test_recursive
-    parser=new_parser do
-      rule :foo, "foo", :foo?
-    end
-
-    assert parser.parse("foo")
-    assert parser.parse("foofoo")
-    assert f=parser.parse("foofoofoo")
-
-#    assert_nil parser[:foo].parse("foobar")
-  end
-
-  def test_alternate
-    v1=nil
-    v2=nil
-    parser=new_parser do
-      v1=rule :foo, "foo"
-      v2=rule :foo, "bar"
-    end
-
-    assert r1=parser.parse("foo")
-    assert r2=parser.parse("bar")
-    assert_equal v1,r1.class
-    assert_equal v2,r2.class
-  end
-
-  def test_add
-    parser=new_parser do
-      rule :add, :number, "+", :number
-      rule :number, /[0-9]+/
-    end
-
-    assert parser.parse("1+1")
-    assert parser.parse("987+123")
-  end
-
-  def test_method
-    parser=new_parser do
-      rule :number, /[0-9]+/ do
-        def number
-          text.to_i
-        end
-      end
-    end
-
-    assert p=parser.parse("123")
-    assert_equal 123,p.number
-  end
-
-  def test_adder
-    parser=new_parser do
-      rule :adder, :number, "+", :number do
-        def answer;
-          number[0].number + number[1].number
-        end
-      end
-      rule :number, /[0-9]+/ do
-        def number; text.to_i end
-      end
-    end
-
-
-    assert p=parser.parse("123+654")
-    assert_equal 777,p.answer
-  end
-
-  def test_adder_multiplier
-    parser=new_parser do
-
-      rule :adder, :multiplier, "+", :adder do
-        def value
-          multiplier.value + adder.value
-        end
-      end
-
-      rule :adder, :multiplier do
-        def value
-          multiplier.value
-        end
-      end
-
-      rule :multiplier, :number, "*", :multiplier do
-        def value
-          number.value * multiplier.value
-        end
-      end
-
-      rule :multiplier, :number do
-        def value
-          number.value
-        end
-      end
-
-      rule :number, /[0-9]+/ do
-        def value; text.to_i end
-      end
-
-    end
-
-    assert_equal 123,parser.parse("123").value
-    assert_equal 369,parser.parse("123*3").value
-    assert_equal 370,parser.parse("123*3+1").value
-    assert_equal 129,parser.parse("123+3*2").value
-    assert_equal 777,parser.parse("123+654").value
-    assert_equal 281,parser.parse("20*4+1+100*2").value
-  end
-
-  def test_rule_class
-    parser=new_parser do
-      rule :foo, "foo"
-      rule :foo, "bar"
-      node_class :foo do
-        def value; text end
-      end
-    end
-
-    assert_equal "foo",parser.parse("foo").value
-    assert_equal "bar",parser.parse("bar").value
-  end
-
-  def test_indexed_match_reference_with_optional
-    parser=new_parser do
-      rule :foo, :bar, :boo?, :bar do
-        def outter
-          bar[0].text + bar[1].text
-        end
-      end
-      rule :bar, /[0-9]+,?/
-      rule :boo, /[A-Z]+,?/
-    end
-
-    assert_equal "1,2", parser.parse("1,2").outter
-    assert_equal "1,3", parser.parse("1,A,3").outter
-
-  end
-
-  def test_verbose
-    parser=new_parser do
-      rule :foo, {:match=>"foo"}, {:match=>"bar",:optional=>true}
-    end
-
-    assert parser.parse("foo")
-    assert parser.parse("foobar")
-  end
-
-  def test_custom_parser
-    parser=new_parser do
-      rule :foo, {:parser=>lambda do |parent_node|
-        offset=parent_node.next
-        src=parent_node.src
-
-        # Note, the \A anchors the search at the beginning of the string
-        if src[offset..-1].index(/\A[A-Z]+/)==0
-          endpattern=$~.to_s
-          if i=src.index(endpattern,offset+endpattern.length)
-            range = offset..(i+endpattern.length)
-            BabelBridge::TerminalNode.new(parent_node,range,"endpattern")
-          end
-        end
-      end}
-    end
-
-    assert parser.parse("END this is in the middle END")
-    assert_equal "END this is in END",parser.parse("END this is in END the middle END",0,:foo).text
-    assert_nil parser.parse("END this is in the middle EN")
-    assert_nil parser.parse("    END this is in the middle END")
-  end
-
-  def test_poly
-    parser=new_parser do
-      rule :foo, many("foo").as(:foo)
-    end
-    assert_equal ["foo"], parser.parse("foo").foo.collect {|f| f.text}
-    assert_equal ["foo","foo"], parser.parse("foofoo").foo.collect {|f| f.text}
-    assert_equal ["foo","foo","foo"], parser.parse("foofoofoo").foo.collect {|f| f.text}
-  end
-
-  def test_poly_delimiter
-    parser=new_parser do
-      rule :foo, many("foo",/ +/).as(:foo)
-    end
-    assert_equal ["foo"], parser.parse("foo").foo.collect {|f| f.text}
-    assert parser.parse("foo     foo")
-    assert_equal ["foo","foo"], parser.parse("foo     foo").foo.collect {|f| f.text}
-  end
-
-  def test_poly_optional_delimiter
-    parser=new_parser do
-      rule :foo, many(";",match?(/ +/))
-    end
-    assert parser.parse(";")
-    assert parser.parse_and_puts_errors(";;")
-    assert parser.parse(";    ;   ;")
-  end
-
-  def test_many
-    assert_equal({:many=>";",:match=>true}, BabelBridge::Parser.many(";"))
-  end
-
-  def test_many?
-    assert_equal({:many=>";", :optionally=>true, :match=>true}, BabelBridge::Parser.many?(";"))
-  end
-
-  def test_many!
-    assert_equal({:many=>";", :dont=>true, :match=>true}, BabelBridge::Parser.many!(";"))
-  end
-
-  def test_match
-    assert_equal({:match=>";"}, BabelBridge::Parser.match(";"))
-  end
-
-  def test_match?
-    assert_equal({:match=>";",:optionally=>true}, BabelBridge::Parser.match?(";"))
-  end
-
-  def test_match!
-    assert_equal({:match=>";",:dont=>true}, BabelBridge::Parser.match!(";"))
-  end
-
-  def test_dont
-    assert_equal({:match=>";",:dont=>true}, BabelBridge::Parser.dont.match(";"))
-  end
-
-  def test_optionally
-    assert_equal({:match=>";",:optionally=>true}, BabelBridge::Parser.optionally.match(";"))
-  end
-
-  def test_could
-    assert_equal({:match=>";",:could=>true}, BabelBridge::Parser.could.match(";"))
-  end
-
-  def test_ignore_whitespace
-    parser=new_parser do
-      ignore_whitespace
-      rule :pair, "foo", "bar"
-    end
-    assert parser.parse("foobar")
-    assert parser.parse("foo   bar")
-    assert parser.parse("foobar   ")
-    assert parser.parse("foo bar     ")
-  end
-
-  def test_binary_operator_rule
-    parser=new_parser do
-      binary_operators_rule :bin_op, :int, ["**", [:/, :*], [:+, "-"]], :right_operators => ["**"] do
-        def evaluate
-          "(#{left.evaluate}#{operator}#{right.evaluate})"
-        end
-      end
-
-      rule :int, /[-]?[0-9]+/ do
-        def evaluate; to_s; end
-      end
-    end
-    assert_equal "(1+2)",     parser.parse("1+2").evaluate
-    assert_equal "((1+2)+3)", parser.parse("1+2+3").evaluate
-    assert_equal "(1+(2*3))", parser.parse("1+2*3").evaluate
-    assert_equal "((1*2)+3)", parser.parse("1*2+3").evaluate
-    assert_equal "(5**6)",    parser.parse("5**6").evaluate
-    assert_equal "((1-2)+((3*4)/(5**6)))", parser.parse("1-2+3*4/5**6").evaluate
-    assert_equal "(5**(6**7))", parser.parse("5**6**7").evaluate
-  end
-
-  def test_dont_parser
-    parser = new_parser do
-      rule :option, dont.match(/msg.*/), /.*/
-    end
-    assert_nil parser.parse "msg test"
-    assert parser.parse "non test"
-  end
-
-  def test_line_col
-    assert_equal [1,1], "".line_col(0)
-    assert_equal [1,1], " ".line_col(0)
-    assert_equal [1,1], "a\nbb\nccc".line_col(0)
-    assert_equal [1,2], "a\nbb\nccc".line_col(1)
-    assert_equal [2,1], "a\nbb\nccc".line_col(2)
-    assert_equal [2,2], "a\nbb\nccc".line_col(3)
-    assert_equal [2,3], "a\nbb\nccc".line_col(4)
-    assert_equal [3,1], "a\nbb\nccc".line_col(5)
-    assert_equal [3,2], "a\nbb\nccc".line_col(6)
-    assert_equal [3,3], "a\nbb\nccc".line_col(7)
-    assert_equal [3,4], "a\nbb\nccc".line_col(8)
-    assert_equal [3,4], "a\nbb\nccc".line_col(9)
-  end
-
-  def disabled_test_recursive_block
-    # PEG does have this problem, so this isn't really an error
-    # But maybe in the future we'll handle it better.
-    # SBD: Disabled 2010-10-24
-    parser=new_parser do
-      rule :foo, :foo, ";"
-      rule :foo, "-"
-
-    end
-    parser.parse "-"
-  end
-
-
-
-  def regex_performance
-    parser=new_parser do
-      rule :foo, many(:element)
-      rule :element, /[0-9]+/
-      rule :element, "a"
-    end
-
-    str=("a"*10000)+"1"
-    start_time=Time.now
-    res=parser.parse(str)
-    end_time=Time.now
-    puts "time for matching string of length #{str.length}: #{((end_time-start_time)*1000).to_i}ms"
-    puts "parse tree size: #{res.element.length}"
-    assert res
-  end
-end
-
-tests=BBTests.new
-tests.run_tests(ARGV.length>0 && ARGV)