rockit 0.7.1 → 0.7.2

data/tests/acceptance/rockit/dparser/atest_list_operator.rb

@@ -1,57 +0,0 @@
-require 'test/unit'
-require 'rockit/dparser'
-
-class ATestListOperator < Test::Unit::TestCase
-  ListTestGrammar = Rockit::DParser::Grammar.new do
-    start :S, [list(:Number, ",")], value(0)
-    term :Number, [/[0-9]+/]
-  end
-
-  Parser = ListTestGrammar.new_parser
-  
-  def test_01_two_value_list
-    ary = Parser.parse("1, 2")
-    assert_equal(["1", "2"], ary)
-  end
-
-  def test_02_multi_value_list
-    ary = Parser.parse("1, 2, 34, 567,890")
-    assert_equal(["1", "2", "34", "567", "890"], ary)
-  end
-
-  def test_03_single_value_list
-    ary = Parser.parse("9731")
-    assert_equal(["9731"], ary)
-  end
-
-  ListAndAstTestGrammar = Rockit::DParser::Grammar.new do
-    start :S, [list(:Digit)], ast(:S, 0)
-    term :Digit, [/[0-9]+/]
-  end
-
-  AstParser = ListAndAstTestGrammar.new_parser
-
-  def test_04_multiple_occurences_and_ast
-    ast = AstParser.parse("7,5,6,9")
-    assert_equal("S", ast.name)
-    assert_kind_of(AstParser.astclass_of_name(:S), ast)
-    assert_equal(1, ast.num_children)
-    assert_equal(["7", "5", "6", "9"], ast[0])
-  end
-
-  def test_05_single_occurence_and_ast
-    ast = AstParser.parse("745")
-    assert_equal("S", ast.name)
-    assert_kind_of(AstParser.astclass_of_name(:S), ast)
-    assert_equal(1, ast.num_children)
-    assert_equal(["745"], ast[0])
-  end
-
-  def atest_06_no_occurence_and_ast
-    ast = AstParser.parse("")
-    assert_equal("S", ast.name)
-    assert_kind_of(AstParser.astclass_of_name(:S), ast)
-    assert_equal(1, ast.num_children)
-    assert_equal([], ast[0])
-  end
-end

data/tests/acceptance/rockit/dparser/atest_mult_operator.rb

@@ -1,60 +0,0 @@
-require 'test/unit'
-require 'rockit/dparser'
-
-class ATestMultOperator < Test::Unit::TestCase
-  MultTestGrammar = Rockit::DParser::Grammar.new do
-    start :S, [mult(:Digit)], value(0)
-    term :Digit, [/[0-9]/]
-  end
-
-  Parser = MultTestGrammar.new_parser
-
-  def test_01_multiple_occurences
-    (2..20).each do |i|
-      digit = rand(10).to_s
-      ary = Parser.parse(digit * i)
-      assert_equal((1..i).map {digit}, ary)
-    end
-  end
-
-  def test_02_single_occurence
-    ary = Parser.parse("7")
-    assert_equal(["7"], ary)
-  end
-
-  def test_03_no_occurence
-    ary = Parser.parse("")
-    assert_equal([], ary)
-  end
-
-  MultAndAstTestGrammar = Rockit::DParser::Grammar.new do
-    start :S, [mult(:Digit)], ast(:S, 0)
-    term :Digit, [/[0-9]/]
-  end
-
-  AstParser = MultAndAstTestGrammar.new_parser
-
-  def test_04_multiple_occurences_and_ast
-    ast = AstParser.parse("7 5 6 9")
-    assert_equal("S", ast.name)
-    assert_kind_of(AstParser.astclass_of_name(:S), ast)
-    assert_equal(1, ast.num_children)
-    assert_equal(["7", "5", "6", "9"], ast[0])
-  end
-
-  def test_05_single_occurence_and_ast
-    ast = AstParser.parse("7")
-    assert_equal("S", ast.name)
-    assert_kind_of(AstParser.astclass_of_name(:S), ast)
-    assert_equal(1, ast.num_children)
-    assert_equal(["7"], ast[0])
-  end
-
-  def test_06_no_occurence_and_ast
-    ast = AstParser.parse("")
-    assert_equal("S", ast.name)
-    assert_kind_of(AstParser.astclass_of_name(:S), ast)
-    assert_equal(1, ast.num_children)
-    assert_equal([], ast[0])
-  end
-end

data/tests/acceptance/rockit/dparser/atest_operator_grammar.rb

@@ -1,61 +0,0 @@
-require 'test/unit'
-require 'rockit/dparser'
-
-class ATestOperatorGrammar < Test::Unit::TestCase
-  MaybeTestGrammar = Rockit::DParser::Grammar.new do
-    start :M, [[:A, maybe(:Digit)]], ast(:M, 0, 1)
-    term :A, ["a"]
-    term :Digit, [/[0-9]+/]
-  end
-
-  def test_01_use_maybe_parser
-    parser = MaybeTestGrammar.new_parser
-
-    ast = parser.parse "a1"
-    assert_equal("M", ast.name)
-    assert_kind_of(parser.astclass_of_name(:M), ast)
-    assert_equal(2, ast.num_children)
-    assert_equal("a", ast[0])
-    assert_equal("1", ast[1])    
-
-    ast = parser.parse "a"
-    assert_equal("M", ast.name)
-    assert_kind_of(parser.astclass_of_name(:M), ast)
-    assert_equal(2, ast.num_children)
-    assert_equal("a", ast[0])
-    assert_equal(nil, ast[1])    
-  end
-
-  OperatorTestGrammar = Rockit::DParser::Grammar.new do
-    start :Str, [[:A, plus(:B), plus(:A), mult(:C), maybe(:D)]], 
-      ast(:Str, 0, 1, 3, 4)
-    term :A, ["a"]
-    term :B, ["b"]
-    term :C, ["c"]
-    term :D, ["d"]
-  end
-
-  def test_02_use_parser
-    parser = OperatorTestGrammar.new_parser
-    ast = parser.parse "abbbac"
-    assert_equal("Str", ast.name)
-    assert_kind_of(parser.astclass_of_name(:Str), ast)
-    assert_equal(4, ast.num_children)
-    assert_equal("a", ast[0])
-    assert_equal(["b", "b", "b"], ast[1])
-    assert_equal(["c"], ast[2])
-    assert_equal(nil, ast[3])
-  end
-
-  def test_03_use_parser
-    parser = OperatorTestGrammar.new_parser
-    ast = parser.parse "a b a c  c d"
-    assert_equal("Str", ast.name)
-    assert_kind_of(parser.astclass_of_name(:Str), ast)
-    assert_equal(4, ast.num_children)
-    assert_equal("a", ast[0])
-    assert_equal(["b"], ast[1])
-    assert_equal(["c", "c"], ast[2])
-    assert_equal("d", ast[3])
-  end
-end

data/tests/acceptance/rockit/dparser/atest_plus_operator.rb

@@ -1,55 +0,0 @@
-require 'test/unit'
-require 'rockit/dparser'
-
-class ATestPlusOperator < Test::Unit::TestCase
-  PlusTestGrammar = Rockit::DParser::Grammar.new do
-    start :S, [plus(:A)], value(0)
-    term :A, ["a"]
-  end
-
-  Parser = PlusTestGrammar.new_parser
-
-
-  def test_01_multiple_occurences
-    (2..20).each do |i|
-      ary = Parser.parse("a" * i)
-      assert_equal((1..i).map {"a"}, ary)
-    end
-  end
-
-  def test_02_single_occurence
-    ary = Parser.parse("a")
-    assert_equal(["a"], ary)
-  end
-
-  def test_03_no_occurence
-    assert_raises(RuntimeError) {Parser.parse("b")}
-  end
-
-  PlusAndAstTestGrammar = Rockit::DParser::Grammar.new do
-    start :S, [plus(:Digit)], ast(:S, 0)
-    term :Digit, [/[0-9]/]
-  end
-
-  AstParser = PlusAndAstTestGrammar.new_parser
-
-  def test_04_multiple_occurences_and_ast
-    ast = AstParser.parse("7 5 6 9")
-    assert_equal("S", ast.name)
-    assert_kind_of(AstParser.astclass_of_name(:S), ast)
-    assert_equal(1, ast.num_children)
-    assert_equal(["7", "5", "6", "9"], ast[0])
-  end
-
-  def test_05_single_occurence_and_ast
-    ast = AstParser.parse("7")
-    assert_equal("S", ast.name)
-    assert_kind_of(AstParser.astclass_of_name(:S), ast)
-    assert_equal(1, ast.num_children)
-    assert_equal(["7"], ast[0])
-  end
-
-  def test_06_no_occurence_and_ast
-    assert_raises(RuntimeError) {AstParser.parse("b")}
-  end
-end

data/tests/acceptance/rockit/dparser/atest_samples_calculator.rb

@@ -1,14 +0,0 @@
-require 'test/unit'
-require 'rockit/dparser'
-require 'calculator/calculator'
-
-require File.join(File.dirname(__FILE__), "calc_tests_common")
-
-class ATestSamplesCalculator < Test::Unit::TestCase
-  include CalcTestsCommon
-
-  def setup
-    @grammar = Samples::CalculatorGrammar
-    @calculator = Samples::Calculator.new
-  end
-end

data/tests/acceptance/rockit/dparser/atest_samples_minibasic.rb

@@ -1,20 +0,0 @@
-require 'test/unit'
-require 'rockit/dparser'
-
-require 'minibasic/minibasic_grammar'
-
-class ATestSamplesMinibasic < Test::Unit::TestCase
-  # Test the String regexp by itself since it is special
-  StringTermGrammar = Rockit::DParser::Grammar.new do
-    start :S, [["PRINT", :String, value(1)]]
-    term :String, /"[^"]*"/
-  end
-
-  def test_01_string_term
-    parser = StringTermGrammar.new_parser
-    value = parser.parse 'PRINT "a"'
-    assert_equal('"a"', value)
-  end
-
-  MiniBasicParser = Samples::MiniBasicGrammar.new_parser
-end

data/tests/acceptance/rockit/dparser/atest_samples_multifunccalculator.rb

@@ -1,36 +0,0 @@
-require 'test/unit'
-require 'rockit/dparser'
-require 'calculator/multifunc_calculator'
-
-require File.join(File.dirname(__FILE__), "calc_tests_common")
-
-class ATestSamplesMultiFuncCalc < Test::Unit::TestCase
-  include CalcTestsCommon
-
-  def setup
-    @grammar = Samples::MultiFuncCalcGrammar
-    @calculator = Samples::MultiFuncCalculator.new
-  end
-
-  def test_10_eval
-    assert_calc(8, "2^3")
-
-    # The calculator is the same between successive calls to assert_calc so
-    # the variables should retain their values
-    assert_calc(1, "a = 1")
-    assert_calc(-2, "b=-2")
-    assert_calc(-1, "a+b")
-    assert_calc(-97, "c = (3 - 100)")
-    assert_calc(-2*-97+(4*1), "(b*c)+(4*a)")
-
-    assert_calc(Math.log(2), "ln(2)")
-  end
-
-  def test_11_exponentiation_is_right_associative
-    assert_calc(2**(3**3), "2^3^3")
-  end
-
-  def test_12_precedence_and_associativity
-    assert_calc(15, "1+2*3^2-4")
-  end
-end

data/tests/acceptance/rockit/dparser/atest_simple_grammar.rb

@@ -1,34 +0,0 @@
-require 'test/unit'
-require 'rockit/dparser'
-
-class ATestSimpleGrammar < Test::Unit::TestCase
-  SimpleTestGrammar = Rockit::DParser::Grammar.new do
-    start :Str, [[:A, :B, :A, :C, ast(:Str, 0, 1, 3)]]
-    term :A, ["a"]
-    term :B, ["b"]
-    term :C, ["c"]
-  end
-
-  def test_01_creation_of_grammar
-    assert_kind_of(Rockit::DParser::Grammar, SimpleTestGrammar)
-    assert_equal(1, SimpleTestGrammar.rules.length)
-    assert_equal(3, SimpleTestGrammar.terms.values.length)
-    assert_equal(:Str, SimpleTestGrammar.start_symbol)
-  end
-
-  def test_02_creation_of_parser
-    parser = SimpleTestGrammar.new_parser
-    assert_kind_of(Rockit::DParser::Parser, parser)
-  end
-
-  def test_03_use_parser
-    parser = SimpleTestGrammar.new_parser
-    ast = parser.parse "ab a\tc"
-    assert_equal("Str", ast.name)
-    assert_kind_of(parser.astclass_of_name(:Str), ast)
-    assert_equal(3, ast.num_children)
-    assert_equal("a", ast[0])
-    assert_equal("b", ast[1])
-    assert_equal("c", ast[2])
-  end
-end

data/tests/acceptance/rockit/dparser/atest_speculative_code_action.rb

@@ -1,128 +0,0 @@
-require 'test/unit'
-require 'rockit/dparser'
-require 'rockit/symbol_table'
-
-class ATestSpeculativeCodeAction < Test::Unit::TestCase
-  TestGrammar = Rockit::DParser::Grammar.new do
-    start :S, [[:Id, ast(:S, 0)]]
-    rule :Id, [[:AIdent]]
-
-    rule :AIdent, [
-      [:Ident, 
-	# Speculative code that rejects match unless the ident starts with "A"
-	speculative do |parser|
-	  parser.reject if parser.get_value_of_child(0)[0,1] != "A"
-	end,
-	# Final code
-	ast(:A, 0),
-      ]      
-    ]
-
-    term :Ident, /[A-Za-z]+/
-  end
-
-  def test_01_no_reject
-    parser = TestGrammar.new_parser
-    ast = parser.parse "ABBA"
-    assert_equal("S", ast.name)
-    assert_kind_of(parser.astclass_of_name(:S), ast)
-    assert_equal(1, ast.num_children)
-    assert_kind_of(parser.astclass_of_name(:A), ast[0])
-    assert_equal(1, ast[0].num_children)
-    assert_equal("ABBA", ast[0][0])
-  end
-
-  def test_02_reject
-    parser = TestGrammar.new_parser
-    # Make sure "CDE" is not a valid parse even though it matches Ident
-    # since it should be rejected by the speculative action code
-    assert_raises(RuntimeError) {ast = parser.parse "CDE"}
-    assert_raises(RuntimeError) {ast = parser.parse "B"}
-    assert_raises(RuntimeError) {ast = parser.parse "D"}
-    assert_raises(RuntimeError) {ast = parser.parse "G"}
-  end
-
-  # This example is a more realistic one with a SymbolTable that saves
-  # symbols and indicates that they are type names.
-  SymbolTableTestGrammar = Rockit::DParser::Grammar.new do
-    parser_include Rockit::ParserSymbolTable
-
-    start :TranslationUnit, [
-      [mult(:Declaration), plus(:Assignment)],
-    ], ast(:TU, 0, 1)
-
-    rule :Assignment, [
-      [:Identifier, "=", :Identifier, ast(:Assign, 0, 2)],
-    ]
-
-    rule :Declaration, [
-      [plus(:StorageClassSpecifier), :Identifier, ";", 
-
-        # Speculative code that inserts identifier into symbol table
-        # if it is a typedef.
-	speculative do |parser|
-          e0, e1 = parser.get_value_of_child(0), parser.get_value_of_child(1)
-	  if e0.include?("typedef") && e1.name == "Identifier"
-	    parser.symbol_table.add_typename(e1[0])
-	  end
-	end,
-
-	ast(:Declaration, 0, 1),
-      ],
-    ]
-
-    rule :StorageClassSpecifier, [
-      ['auto'], ['register'], ['static'], ['extern'], ['typedef'],
-    ]
-
-    rule :Identifier, [
-      [:Ident, 
-
-	# Speculative code here that rejects the ident if it is in the 
-	# symbol table and is a type name
-	speculative do |parser|
-	  e0 = parser.get_value_of_child(0)
-	  parser.reject if parser.symbol_table.typename?(e0)
-	end,
-
-	ast(:Identifier, 0)
-      ]
-    ]
-
-    term :Ident, /[A-Za-z]+/
-  end  
-
-  def test_03_valid_with_symbol_table_but_without_typedef
-    parser = SymbolTableTestGrammar.new_parser
-    ast = parser.parse "A = B"
-    assert_equal("TU", ast.name)
-    assert_kind_of(parser.astclass_of_name(:TU), ast)
-    assert_equal(2, ast.num_children)
-    assert_equal(0, ast[0].length)
-    assert_equal(1, ast[1].length)
-    assert_equal("Assign", ast[1][0].name)    
-    assert_equal("A", ast[1][0][0][0])
-    assert_equal("B", ast[1][0][1][0])
-  end
-
-  def test_03_valid_with_symbol_table_and_typedef
-    parser = SymbolTableTestGrammar.new_parser
-    ast = parser.parse "typedef C; A = B"
-    assert_equal("TU", ast.name)
-    assert_kind_of(parser.astclass_of_name(:TU), ast)
-    assert_equal(2, ast.num_children)
-    assert_equal(1, ast[0].length)
-    assert_equal("Declaration", ast[0][0].name)    
-    assert_equal("C", ast[0][0][1][0])
-    assert_equal(1, ast[1].length)
-    assert_equal("Assign", ast[1][0].name)    
-  end
-
-  def test_04_invalid_with_typedef_and_symbol_table
-    parser = SymbolTableTestGrammar.new_parser
-    # Should not parse ok since the typedef means the A cannot later be an
-    # identifier.
-    assert_raises(RuntimeError) {ast = parser.parse "typedef A; A = B"}
-    assert_raises(RuntimeError) {ast = parser.parse "typedef B; A = B"}
-  end
-end