rockit 0.7.1 → 0.7.2

data/tests/unit/rockit/utest_grammar_symbol.rb

@@ -1,11 +0,0 @@
-require 'test/unit'
-
-require 'rockit/grammar'
-include Rockit
-
-class UTestGrammarSymbol < Test::Unit::TestCase
-  def test_01_to_grammar_symbol
-    dummy = GrammarSymbol.new
-    assert_equal(dummy, dummy.to_grammar_symbol)
-  end
-end

data/tests/unit/rockit/utest_maybe_operator.rb

@@ -1,12 +0,0 @@
-require 'test/unit'
-
-require 'rockit/grammar'
-include Rockit
-
-class UTestRepetitionOperator < Test::Unit::TestCase
-  def test_01
-    m = Maybe.new(:A)
-    assert_kind_of(Maybe, m)
-    assert_kind_of(GrammarSymbol, m)
-  end
-end

data/tests/unit/rockit/utest_regexp_terminal.rb

@@ -1,45 +0,0 @@
-require 'test/unit'
-
-require 'rockit/grammar'
-include Rockit
-
-require 'strscan'
-
-class UTestRegexpTerminal < Test::Unit::TestCase
-  def setup
-    @ret = RegexpTerminal.new(/a/)
-    @retas = RegexpTerminal.new(/a+/)
-  end
-
-  def test_01_smoke
-    assert_kind_of(RegexpTerminal, @ret)
-    assert_kind_of(GrammarSymbol, @ret)
-  end
-
-  def test_02_inspect
-    assert_kind_of(String, @ret.inspect)
-    assert_equal("/a/", @ret.inspect)
-  end
-
-  def test_03_regexp
-    assert_kind_of(Regexp, @ret.regexp)
-    assert_equal(/\s*(a)/, @ret.regexp)
-    assert_equal(/\s*(a+)/, @retas.regexp)
-  end
-
-  def test_04_scan
-    s = StringScanner.new("a")
-    assert_equal("a", @ret.scan(s))
-    assert_equal(1, s.pos)
-
-    s = StringScanner.new("b")
-    assert_equal(nil, @ret.scan(s))
-    assert_equal(0, s.pos)
-  end
-
-  def test_05_dont_scan_over_whitespace
-    s = StringScanner.new("a   b")
-    assert_equal("a", @ret.scan(s))
-    assert_equal(1, s.pos)
-  end
-end

data/tests/unit/rockit/utest_repetition_operators.rb

@@ -1,35 +0,0 @@
-require 'test/unit'
-
-require 'rockit/grammar'
-include Rockit
-
-class UTestRepetitionOperator < Test::Unit::TestCase
-  def test_01_creation_of_repetition
-    r = Repetition.new(:A, 2, 10)
-    assert_kind_of(Repetition, r)
-    assert_kind_of(Operator, r)
-    assert_kind_of(GrammarSymbol, r)
-    assert_equal(2, r.min)
-    assert_equal(10, r.max)
-  end
-
-  def test_02_creation_of_mult
-    r = Mult.new(:C)
-    assert_kind_of(Mult, r)
-    assert_kind_of(Repetition, r)
-    assert_kind_of(Operator, r)
-    assert_kind_of(GrammarSymbol, r)
-    assert_equal(0, r.min)
-    assert_equal((1.0/0.0), r.max)
-  end
-
-  def test_03_creation_of_plus
-    r = Plus.new(:C)
-    assert_kind_of(Plus, r)
-    assert_kind_of(Repetition, r)
-    assert_kind_of(Operator, r)
-    assert_kind_of(GrammarSymbol, r)
-    assert_equal(1, r.min)
-    assert_equal((1.0/0.0), r.max)
-  end
-end

data/tests/unit/rockit/utest_rule.rb

@@ -1,23 +0,0 @@
-require 'test/unit'
-
-require 'rockit/grammar'
-include Rockit
-
-class UTestRule < Test::Unit::TestCase
-  def test_01_empty_rule
-    r = Rule.new(:r1, [])
-    assert_equal(:r1, r.name)
-    assert_equal([], r.right_hand_side)
-  end
-
-  def test_02
-    r = Rule.new(:r1, [[:a, "B"]])
-    assert_equal(:r1, r.name)
-    assert_equal(2, r.right_hand_side.length)
-    s1, s2 = r.right_hand_side
-    assert_kind_of(NonTerminal, s1)
-    assert_kind_of(StringTerminal, s2)
-    assert_equal(:a, s1.symbol)
-    assert_equal("B", s2.string)
-  end
-end

data/tests/unit/rockit/utest_string_terminal.rb

@@ -1,40 +0,0 @@
-require 'test/unit'
-
-require 'rockit/grammar'
-include Rockit
-
-require 'strscan'
-
-class UTestStringTerminal < Test::Unit::TestCase
-  def setup
-    @sta = StringTerminal.new("a")
-    @stp = StringTerminal.new("+")
-  end
-
-  def test_01_smoke
-    assert_kind_of(StringTerminal, @sta)
-    assert_kind_of(GrammarSymbol, @sta)
-    assert_kind_of(StringTerminal, @stp)
-    assert_kind_of(GrammarSymbol, @stp)
-  end
-
-  def test_02_inspect
-    assert_kind_of(String, @sta.inspect)
-    assert_equal("a", @sta.inspect)
-  end
-
-  def test_03_string
-    assert_kind_of(String, @sta.string)
-    assert_equal("a", @sta.string)
-    assert_kind_of(String, @stp.string) 
-    assert_equal("+", @stp.string)
-  end
-
-  def test_04_regexp
-    assert_kind_of(Regexp, @sta.regexp)
-    assert_equal(/\s*(a)/, @sta.regexp)
-    assert_kind_of(Regexp, @stp.regexp)
-    assert_equal(/\s*(\+)/, @stp.regexp)
-    assert_equal("/\\s*(\\+)/", @stp.regexp.inspect)
-  end
-end

data/tests/unit/util/utest_array_alternatives.rb

@@ -1,23 +0,0 @@
-require 'test/unit'
-require 'util/array_alternatives'
-
-class UTestArrayAlternatives < Test::Unit::TestCase
-  def test_01_normal_use
-    first, second, third = [1], [2], [3, 4]
-    a = first / second / third
-    alts = a.assemble_alternatives
-    assert_kind_of(Array, alts)
-    assert_equal(3, alts.length)
-    assert_equal(first,  alts[0])
-    assert_equal(second, alts[1])
-    assert_equal(third,  alts[2])
-  end
-
-  def test_02_without_any_alternatives
-    a = [1]
-    alts = a.assemble_alternatives
-    assert_kind_of(Array, alts)
-    assert_equal(1, alts.length)
-    assert_equal(a,  alts[0])
-  end
-end

data/tests/unit/util/utest_enter_leave_visitor.rb

@@ -1,89 +0,0 @@
-require 'test/unit'
-require 'util/enter_leave_visitor'
-
-class TestEnterLeaveVisitor < Test::Unit::TestCase
-  class Mock
-  end
-
-  class SuperMock
-    include EnterLeaveVisitable
-  end
-
-  class ELMock < SuperMock
-  end
-
-  class SuperTELVisitor
-    include EnterLeaveVisitor
-    attr_reader :calls
-    def initialize; @calls = []; end
-
-    def enter_SuperMock(obj); @calls << :enterSuperM; end
-    def visit_SuperMock(obj); @calls << :visitSuperM; end
-    def leave_SuperMock(obj); @calls << :leaveSuperM; end
-  end
-
-  class TELVisitor < SuperTELVisitor
-    def enter_Mock(obj); @calls << :enterM; end
-    def visit_Mock(obj); @calls << :visitM; end
-    def leave_Mock(obj); @calls << :leaveM; end
-
-    def enter_ELMock(obj); @calls << :enterELM; end
-    def visit_ELMock(obj); @calls << :visitELM; end
-    def leave_ELMock(obj); @calls << :leaveELM; end
-
-    def enter_SMock(obj); @calls << :enterSM; end
-    def visit_SMock(obj); @calls << :visitSM; end
-    def leave_SMock(obj); @calls << :leaveSM; end
-  end
-
-  class SMock
-    def initialize(c1, c2)
-      @c1, @c2 = c1, c2
-    end
-    def accept_visitor(v)
-      v.visit_me_then_children self, [@c1, @c2]
-    end
-  end
-
-  class EmptyVisitor
-    include EnterLeaveVisitor
-  end
-
-  def test_01_empty_visitor
-    visitor, m = EmptyVisitor.new, ELMock.new
-    assert_nothing_raised {m.accept_visitor(visitor)}
-  end
-
-  def test_02_visit_std_visitable
-    visitor, m = TELVisitor.new, Mock.new
-    visitor.visit m
-    assert_equal([:enterM, :visitM, :leaveM], visitor.calls)
-  end
-
-  def test_03_visit_enterleavevisitable
-    visitor, m = TELVisitor.new, ELMock.new
-    visitor.visit m
-    assert_equal([:enterELM, :visitELM, :leaveELM], visitor.calls)    
-  end
-
-  def test_04_visit_nested_objects
-    visitor, sm = TELVisitor.new, SMock.new(c1 = ELMock.new, c2 = ELMock.new)
-    sm.accept_visitor(visitor)
-    assert_equal([:enterSM, :visitSM,
-		   :enterELM, :visitELM, :leaveELM,
-		   :enterELM, :visitELM, :leaveELM,
-		   :leaveSM], visitor.calls)
-  end
-
-  def test_05_visit_superclass_visit_method
-    visitor, m1 = SuperTELVisitor.new, ELMock.new
-    m1.accept_visitor(visitor)
-    assert_equal([:enterSuperM, :visitSuperM, :leaveSuperM], visitor.calls)
-  end
-
-  def test_06_visit_our_visitmethod_if_available_both_for_us_and_for_superclass
-    visitor, m1 = TELVisitor.new, ELMock.new
-    m1.accept_visitor(visitor)
-    assert_equal([:enterELM, :visitELM, :leaveELM], visitor.calls)
-  end  
-end

data/tests/unit/util/utest_string_location.rb

@@ -1,42 +0,0 @@
-require 'test/unit'
-
-require 'util/string_location'
-
-class UTestStringLocation < Test::Unit::TestCase
-  def setup
-    @sl = StringLocations.new "a\nb\nc\r\nd"
-  end
-
-  def test_01_creation
-    assert_kind_of(StringLocations, @sl)
-  end
-
-  def test_02_line
-    assert_equal(1, @sl.line(0))
-    assert_equal(1, @sl.line(1))
-    assert_equal(2, @sl.line(2))
-    assert_equal(2, @sl.line(3))
-    assert_equal(3, @sl.line(4))
-    assert_equal(3, @sl.line(5))
-    assert_equal(3, @sl.line(6))
-    assert_equal(4, @sl.line(7))
-  end
-
-  def test_03_column
-    assert_equal(0, @sl.column(0))
-    assert_equal(1, @sl.column(1))
-    assert_equal(0, @sl.column(2))
-    assert_equal(1, @sl.column(3))
-    assert_equal(0, @sl.column(4))
-    assert_equal(1, @sl.column(5))
-    assert_equal(2, @sl.column(6))
-    assert_equal(0, @sl.column(7))
-  end
-
-  def test_04_location
-    assert_equal([1, 0], @sl.location(0))
-    assert_equal([1, 1], @sl.location(1))
-    assert_equal([2, 0], @sl.location(2))
-    assert_equal([2, 1], @sl.location(3))
-  end
-end

data/tests/unit/util/utest_visitor.rb

@@ -1,92 +0,0 @@
-require 'test/unit'
-require 'util/visitor'
-
-class TestVisitor < Test::Unit::TestCase
-  class SuperMock
-    include Visitable
-  end
-
-  class Mock < SuperMock
-    attr_reader :children, :visited
-    def initialize
-      @children = []
-    end
-    def accept_visitor(visitor)
-      @visited = true
-      visitor.visit_me_then_children self, @children
-    end
-  end
-
-  class TVisitor
-    include Visitor
-    attr_reader :count
-    def initialize; @count = 0; end
-    def visit_Mock(obj); @count += 1; end
-  end
-
-  class EmptyVisitor
-    include Visitor
-  end
-
-  # To test whether super class visit method is used if there is no one
-  # for the actual class
-  class SuperMockVisitor
-    include Visitor
-    attr_reader :count
-    def initialize; @count = 0; end
-    def visit_SuperMock(obj); @count += 1; end
-  end
-
-  class MockAndSuperMockVisitor
-    include Visitor
-    attr_reader :countSM, :countM
-    def initialize; @countM = @countSM = 0; end
-    def visit_SuperMock(obj); @countSM += 1; end
-    def visit_Mock(obj); @countM += 1; end
-  end
-
-  def test_01_empty_visitor
-    visitor, m = EmptyVisitor.new, Mock.new
-    assert_nothing_raised {m.accept_visitor(visitor)}
-    assert(m.visited)
-  end
-
-  def test_02_visit
-    visitor, m = TVisitor.new, Mock.new
-    assert_equal(0, visitor.count)
-    visitor.visit(m)
-    assert_equal(1, visitor.count)
-    m.accept_visitor(visitor)
-    assert_equal(2, visitor.count)    
-  end
-
-  def test_03_visit_nested
-    visitor, m1 = TVisitor.new, Mock.new
-    m1.children << (m2 = Mock.new)
-    m2.children << (m3 = Mock.new)
-    m1.accept_visitor(visitor)
-    assert_equal(3, visitor.count)
-    assert(m1.visited)
-    assert(m2.visited)
-    assert(m3.visited)
-  end
-
-  def test_04_visit_superclass_visit_method
-    visitor, m1 = SuperMockVisitor.new, Mock.new
-    m1.accept_visitor(visitor)
-    assert_equal(1, visitor.count)
-  end
-
-  def test_05_visit_our_visitmethod_if_available_both_for_us_and_for_superclass
-    visitor, m1 = MockAndSuperMockVisitor.new, Mock.new
-    m1.accept_visitor(visitor)
-    assert_equal(1, visitor.countM)
-    assert_equal(0, visitor.countSM)
-  end
-
-  def test_06_visit_each
-    visitor, a = TVisitor.new, [Mock.new, Mock.new]
-    visitor.visit_each(a)
-    assert_equal(2, visitor.count)
-  end
-end

data/tests/unit/util/utest_visitor_combinators.rb

@@ -1,64 +0,0 @@
-require 'test/unit'
-
-require 'util/visitor_combinators'
-
-require 'util/visitor'
-
-class UTestVisitorCombinators < Test::Unit::TestCase
-  class Tree
-    attr_reader :children, :visitors
-    def initialize(*children)
-      @children, @visitors = children, []
-    end
-    def accept_visitor(visitor)
-      @visitors << visitor.object_id
-      visitor.visit_me_and_my_children(self, @children)
-    end
-  end
-
-  # Doesn't touch the visited nodes, just saves the fact that they have been
-  # visited
-  class TIdentityVisitor
-    include Visitor
-    attr_reader :visited
-    def initialize
-      @visited = []
-    end
-    def visit_Tree(tree)
-      @visited << tree
-    end
-  end
-
-  def setup
-    @l1, @l2, @l3 = Tree.new, Tree.new, Tree.new
-    @i = Tree.new(@l2, @l3)
-    @r = Tree.new(@l1, @i)
-    @nodes = [@r, @l1, @i, @l2, @l3] 
-  end
-
-  def assert_topdown_leftright_visited(visitor)
-    assert_equal(@r, visitor.visited[0])
-    assert_equal(@l1, visitor.visited[1])
-    assert_equal(@i, visitor.visited[2])
-    assert_equal(@l2, visitor.visited[3])
-    assert_equal(@l3, visitor.visited[4])
-  end
-
-  def test_01_identity_visitor
-    @r.accept_visitor(iv = TIdentityVisitor.new)
-    assert_equal(5, iv.visited.length)
-    assert_topdown_leftright_visited(iv)
-  end
-
-  def test_02_sequence_visitor
-    sv = SequenceVisitor.new(iv1 = TIdentityVisitor.new, iv2 = TIdentityVisitor.new)
-    @r.accept_visitor(sv)
-    assert_topdown_leftright_visited(iv1)
-    assert_topdown_leftright_visited(iv2)
-    # Seems leaf nodes are visited many times by iv1 and iv2 so the assert 
-    # does not hold.
-    # @nodes.each do |n| 
-    #  assert_equal([sv.id, iv1.id, iv2.id], n.visitors)
-    # end
-  end
-end