rockit 0.7.1 → 0.7.2

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

@@ -1,103 +0,0 @@
-# Tests common to several calculators
-module CalcTestsCommon
-  def parser
-    @parser ||= @grammar.new_parser
-  end
-
-  def test_01_grammar
-    assert_kind_of(Rockit::DParser::Grammar, @grammar)
-  end
-
-  def test_02_creation_of_parser
-    assert_kind_of(Rockit::DParser::Parser, parser)
-  end
-
-  def test_03_constant
-    ast = parser.parse "1234567890"
-    assert_equal("Constant", ast.name)
-    assert_kind_of(parser.astclass_of_name(:Constant), ast)
-    assert_equal(1, ast.num_children)
-    assert_equal("1234567890", ast[0])
-    assert_equal("1234567890", ast.num)
-  end
-
-  Ops = [["+", :Plus], ["-", :Minus], ["*", :Mul], ["/", :Div]] 
-
-  def test_04_operators
-    Ops.each do |op, n|
-      num1, num2 = rand(10).to_s, rand(10).to_s
-      str = num1 + op + num2
-      ast = parser.parse str
-      assert_equal(n.to_s, ast.name)
-      assert_kind_of(parser.astclass_of_name(n), ast)
-      assert_equal(2, ast.num_children)
-
-      assert_kind_of(parser.astclass_of_name(:Constant), ast[0])
-      assert_equal(num1, ast[0].num)
-      assert_kind_of(parser.astclass_of_name(:Constant), ast.left)
-      assert_equal(num1, ast.left.num)
-
-      assert_kind_of(parser.astclass_of_name(:Constant), ast[1])
-      assert_equal(num2, ast[1].num)
-      assert_kind_of(parser.astclass_of_name(:Constant), ast.right)
-      assert_equal(num2, ast.right.num)
-    end
-  end
-
-  def test_05_paren
-    ast = parser.parse "2 * (4 + 67)"
-    assert_kind_of(parser.astclass_of_name(:Mul), ast)
-    assert_equal(2, ast.num_children)
-
-    assert_kind_of(parser.astclass_of_name(:Constant), ast.left)
-    assert_equal("2", ast.left.num)
-
-    assert_kind_of(parser.astclass_of_name(:Plus), ast.right)
-
-    assert_kind_of(parser.astclass_of_name(:Constant), ast.right.left)
-    assert_equal("4", ast.right.left.num)
-
-    assert_kind_of(parser.astclass_of_name(:Constant), ast.right.right)
-    assert_equal("67", ast.right.right.num)
-
-    assert_equal('Mul[Constant["2"], Plus[Constant["4"], Constant["67"]]]',
-		 ast.inspect)
-  end
-
-  def assert_calc(expected, str)
-    assert_equal(expected, @calculator.eval(parser.parse(str)))
-  end
-
-  def test_06_left_associative_operators
-    Ops.each do |op, name|
-      ast = parser.parse "1 #{op} 2 #{op} 3"
-      assert_kind_of(parser.astclass_of_name(name), ast)
-
-      assert_kind_of(parser.astclass_of_name(name), ast.left)
-      assert_equal("1", ast.left.left.num)
-      assert_equal("2", ast.left.right.num)
-
-      assert_kind_of(parser.astclass_of_name(:Constant), ast.right)
-      assert_equal("3", ast.right.num)
-    end
-  end
-
-  def test_07_mul_higher_precedence_than_plus
-    ast = parser.parse "1 + 2 * 3"
-    assert_kind_of(parser.astclass_of_name(:Plus), ast)
-
-    assert_kind_of(parser.astclass_of_name(:Constant), ast.left)
-    assert_equal("1", ast.left.num)
-
-    assert_kind_of(parser.astclass_of_name(:Mul), ast.right)
-    assert_equal("2", ast.right.left.num)
-    assert_equal("3", ast.right.right.num)
-  end
-
-  def test_08_eval
-    assert_calc(2, "2")
-    assert_calc(2 * (4+67), "2 * (4 + 67)")
-    assert_calc(987 * (456+671), "987*(456+671)")
-    assert_calc((9-5) * (100/10), "(9-5) * (100/10)")
-  end
-end

data/tests/unit/parse/utest_ebnf_grammar.rb

@@ -1,50 +0,0 @@
-require 'test/unit'
-
-require 'parse/ebnf_grammar'
-include Parse::Grammar
-
-class UT_Parse_ebnf_grammar < Test::Unit::TestCase
-  def test_01_Maybe_expansion
-    g = Grammar.new do
-      r :Start, [
-        [maybe(:A), "1"]
-      ]
-      r :A, ["a"]
-    end
-    g.expand!
-    assert_equal(3, g.nonterminals.length)
-  end
-
-  def test_02_Plus_expansion
-    g = Grammar.new do
-      r :Start, [
-        [plus(:A), "1"]
-      ]
-      r :A, ["a"]
-    end
-    g.expand!
-    assert_equal(4, g.nonterminals.length)
-  end
-
-  def test_03_Mult_expansion
-    g = Grammar.new do
-      r :Start, [
-        [mult(:A), "1"]
-      ]
-      r :A, ["a"]
-    end
-    g.expand!
-    assert_equal(3, g.nonterminals.length)
-  end
-
-  def test_04_Group_expansion
-    g = Grammar.new do
-      r :Start, [
-        [group("1", "2"), "3"]
-      ]
-    end
-    g.expand!
-    puts g.inspect
-    assert_equal(2, g.nonterminals.length)
-  end
-end

data/tests/unit/parse/utest_expand_grammar.rb

@@ -1,23 +0,0 @@
-require 'test/unit'
-
-require 'parse/expand_grammar'
-include Parse::Grammar
-
-class UT_Parse_expand_grammar < Test::Unit::TestCase
-  def test_01_internal_nonterm_num
-    g = Grammar.new
-    assert_equal(1, g.next_free_internal_nonterminal_num)
-    assert_equal(2, g.next_free_internal_nonterminal_num)
-    assert_equal(3, g.next_free_internal_nonterminal_num)
-  end
-
-  def test_02_create_fresh_nonterminal
-    g = Grammar.new
-    nt = g.create_fresh_nonterminal
-    assert_kind_of(NonTerminal, nt)
-
-    # The name should start with the prefix
-    re = Regexp.new("^" + Grammar::InternalNontermNamePrefix)
-    assert_match(re, nt.name.to_s)
-  end
-end

data/tests/unit/parse/utest_grammar.rb

@@ -1,160 +0,0 @@
-require 'test/unit'
-
-require 'parse/grammar'
-include Parse::Grammar
-
-class UT_Parse_Grammar < Test::Unit::TestCase
-  def test_01_Symbol
-    s = Parse::Grammar::GrammarSymbol.new "name"
-    assert_equal("name", s.name)
-    assert_equal("name", s.inspect)
-    assert_equal(s, s.to_grammar_symbol)
-  end
-
-  def test_02_Symbol_name_not_needed
-    s = Parse::Grammar::GrammarSymbol.new
-    assert_equal(nil, s.name)
-    assert_equal(s, s.to_grammar_symbol)
-  end
-
-  def test_03_NonTerminal
-    s = NonTerminal.new :name
-    assert_equal(:name, s.name)
-    assert_equal("name", s.inspect)
-    assert_kind_of(Parse::Grammar::GrammarSymbol, s)
-    assert_equal(s, s.to_grammar_symbol)
-  end
-
-  def test_04_Terminal
-    s = Terminal.new
-    assert_kind_of(Parse::Grammar::GrammarSymbol, s)
-  end
-
-  def test_05_Production
-    p = Production.new(n = NonTerminal.new(:N), [t = Terminal.new(:T)])
-    assert_equal(n, p.symbol)
-    assert_equal(t, p.rhs.first)
-    assert_equal(t, p.right_hand_side.first)
-  end
-
-  def test_06_Production_short_hand
-    p = Prod[n = NonTerminal.new(:N), [t = Terminal.new(:T)]]
-    assert_equal(n, p.symbol)
-    assert_equal(t, p.rhs.first)
-    assert_equal(t, p.right_hand_side.first)
-
-    p2 = Prod[:N, [t]]
-    assert_equal("N", p2.symbol.inspect)
-  end
-
-  def test_07_nonterminal_equality
-    n1 = NonTerminal.new(:N)
-    n2 = NonTerminal.new(:N)
-    assert(n1 == n2)
-    assert(n2 == n1)
-  end
-
-  def test_08_Rule
-    p1 = Prod[n = NonTerminal.new(:N), [Terminal.new(:T1)]]
-    p2 = Prod[:N, [Terminal.new(:T2)]]
-    r = Rule[p1]
-
-    assert(n == r.symbol)
-    assert_equal(1, r.productions.length)
-
-    r.add_production p2
-    assert_equal(n, r.symbol)
-    assert_equal(2, r.productions.length)
-
-    assert_raises(ArgumentError) {r.add_production(Prod[:N2, [Terminal[:T3]]])}
-  end
-
-  def test_09_Grammar
-    g = Grammar.new(:name => "Test Grammar 1", :author => "Robert")
-    assert_kind_of(Grammar, g)
-    assert_equal("Test Grammar 1", g.meta[:name])
-    assert_equal("Robert", g.meta[:author])
-    assert_equal(0, g.rules.length)
-    assert_equal(0, g.nonterminals.length)
-    assert_equal(0, g.terminals.length)
-    assert_equal(0, g.symbols.length)
-
-    g.add_rule(Rule[Prod[:N, [Terminal[:T1]]]])
-    assert_equal(1, g.rules.length)
-    assert_equal(1, g.nonterminals.length)
-    assert_equal(1, g.terminals.length)
-    assert_equal(2, g.symbols.length)
-  end
-
-  def test_10_symbol_predicates
-    nt = NonTerminal[:N]
-    assert_equal(true, nt.nonterminal?)
-    assert_equal(false, nt.terminal?)
-    assert_equal(false, nt.action?)
-
-    t = Terminal[:T]
-    assert_equal(false, t.nonterminal?)
-    assert_equal(true, t.terminal?)
-    assert_equal(false, t.action?)
-
-    a = Action[:A]
-    assert_equal(false, a.nonterminal?)
-    assert_equal(false, a.terminal?)
-    assert_equal(true, a.action?)
-  end
-
-  class TestGrammar < Grammar
-    r :S, [[:B]]
-    r :B, [
-      [Terminal.new(:T1)],
-      [Terminal.new(:T2), Terminal.new(:T3)],
-    ]
-    t :CT1, ["A"]
-  end
-
-  def test_11_embedded_grammar_def
-    t = TestGrammar.new
-
-    assert_equal(2, t.rules.length)
-
-    assert_equal(:S, t.rules.first.symbol.name)
-    assert_equal(1, t.rules.first.productions.length)
-
-    assert_equal(:B, t.rules.last.symbol.name)
-    assert_equal(2, t.rules.last.productions.length)
-    assert_equal(:T1, t.rules.last.productions.first.rhs.first.name)
-    assert_equal(:T2, t.rules.last.productions.last.rhs.first.name)
-    assert_equal(:T3, t.rules.last.productions.last.rhs.last.name)
-
-    assert_equal(1, t.complex_terminals.length)
-
-    assert_equal(:CT1, t.complex_terminals.first.name)
-  end
-
-  TestDeepClone = Struct.new(:a)
-
-  def test_12_deep_clone
-    a = [1,2,3]
-    t1 = TestDeepClone.new(a)
-    t1a = t1.clone
-    t1b = t1.deep_clone
-    assert_equal(t1.a.object_id, t1a.a.object_id)
-    assert_not_equal(t1.a.object_id, t1b.a.object_id)
-  end
-
-  def test_13_define_grammar_in_a_block
-    g = Grammar.new do
-      r :S, [["a", :B]]
-      r :B, [["b"]]
-    end
-    assert_equal(2, g.nonterminals.length)
-  end
-
-  def test_14_extending_a_grammar_with_a_block
-    g = TestGrammar.new do
-      r :A, [["a"]]
-    end
-    # Two nonterminals in the original grammar and one new here => 3
-    assert_equal(3, g.nonterminals.length)
-  end
-end

data/tests/unit/rockit/assembler/llvm/utest_instructions.rb

@@ -1,41 +0,0 @@
-require 'test/unit'
-
-require 'rockit/assembler/llvm/instructions'
-include Rockit::Assembler::LLVM
-
-class UTestLLVMInstructions < Test::Unit::TestCase
-  def test_01_NamedValue_valid
-    nv1 = NamedValue.new("foo")
-    assert_equal("%foo", nv1.to_llvm)
-
-    nv2 = NamedValue.new("DivByZero")
-    assert_equal("%DivByZero", nv2.to_llvm)
-
-    nv3 = NamedValue.new("a.really.long.identifier")
-    assert_equal("%a.really.long.identifier", nv3.to_llvm)
-  end
-
-  def test_02_NamedValue_invalid
-    assert_raises(ArgumentError) {NamedValue.new("12")}
-    assert_raises(ArgumentError) {NamedValue.new("%")}
-  end
-
-  def test_03_UnnamedValue_valid
-    u1 = UnnamedValue.new(0)
-    assert_equal("%0", u1.to_llvm)
-
-    u2 = UnnamedValue.new(12)
-    assert_equal("%12", u2.to_llvm)
-
-    u3 = UnnamedValue.new(2)
-    assert_equal("%2", u3.to_llvm)
-
-    u4 = UnnamedValue.new(44)
-    assert_equal("%44", u4.to_llvm)
-  end
-
-  def test_04_UnnamedValue_invalid
-    assert_raises(ArgumentError) {UnnamedValue.new(-1)}
-    assert_raises(ArgumentError) {UnnamedValue.new(-18743)}
-  end
-end

data/tests/unit/rockit/assembler/llvm/utest_module.rb

@@ -1,19 +0,0 @@
-require 'test/unit'
-
-require 'rockit/assembler/llvm/module'
-include Rockit::Assembler::LLVM
-
-class UTestLLVMInstructions < Test::Unit::TestCase
-  # Hello world example module
-  class TestModule1 < LLVM::Module
-    LC0 = internal constant '[13 x sbyte]' c("hello world\0A")
-
-    declare int "puts", [sbytep]
-
-    defmethod("main", int, []) do
-      
-    end
-  end
-
-  def te
-end

data/tests/unit/rockit/prettyprint/utest_box.rb

@@ -1,44 +0,0 @@
-require 'test/unit'
-
-require 'rockit/prettyprint/box'
-include Rockit::PrettyPrint
-
-class UTestBox < Test::Unit::TestCase
-  def setup
-    @h = Box::H.new(1, "a") 
-    @h1 = Box::H.new(1, "a", "b") 
-    @h2 = Box::H.new(2, "a", "b") 
-    @h3 = Box::H.new(3, "a", "b", "c") 
-    @v = Box::V.new("a", "2 2", "c") 
-    @e = Box::Epsilon.new("x", "   ", ":=") 
-  end
-  
-  def test_01_creation
-    assert_kind_of(Box::H, @h)
-    assert_equal(1, @h.num_spaces)
-    assert_equal(["a"], @h.elements)
-
-    assert_kind_of(Box::H, @h3)
-    assert_equal(3, @h3.num_spaces)
-    assert_equal(["a", "b", "c"], @h3.elements)
-
-    assert_kind_of(Box::V, @v)
-    assert_equal(["a", "2 2", "c"], @v.elements)
-
-    assert_kind_of(Box::Epsilon, @e)
-  end
-
-  def test_02_render
-    assert_equal("a", @h.render)
-    assert_equal("a b", @h1.render)
-    assert_equal("a  b", @h2.render)
-    assert_equal("a   b   c", @h3.render)
-    assert_equal("a\n2 2\nc", @v.render)
-    assert_equal("x   :=", @e.render)
-  end
-
-  def test_03_prepend
-    p = Box::Prepend["#", "A comment"]
-    assert_equal("# A comment", p.render)
-  end
-end