dhaka 2.0.0 → 2.0.1

data/test/{chittagong_tokenizer.rb → chittagong/chittagong_tokenizer.rb}

@@ -1,21 +1,20 @@
-require File.dirname(__FILE__)+'/../lib/dhaka'
-require 'chittagong_grammar'
-
+require File.dirname(__FILE__) + '/chittagong_grammar'
 
 class ChittagongTokenizer < Dhaka::Tokenizer
 
-  KEYWORDS = ['print', 'if', 'else', 'end', 'while', 'def', 'return']
+  KEYWORDS      = %w| print if else end while def return |
   
-  digits = ('0'..'9').to_a
-  letters = ('a'..'z').to_a
-  parenths = ['(', ')']
-  operators = ['-', '+', '/', '*', '^', '!', '>', '<']
-  equal_sign = ['=']
-  whitespace = [' ']
-  arg_separator = [',']
-  newline = ["\n"]
+  digits        = ('0'..'9').to_a
+  decimal_point = %w| . |
+  letters       = ('a'..'z').to_a
+  parenths      = %w| ( ) |
+  operators     = %w| - + / * ^ ! > < |
+  equal_sign    = %w| = |
+  whitespace    = [' ']
+  arg_separator = %w| , |
+  newline       = ["\n"]
   
-  all_characters = digits + letters + parenths + operators + whitespace + newline + arg_separator + equal_sign
+  all_characters = digits + decimal_point + letters + parenths + operators + whitespace + newline + arg_separator + equal_sign
 
   for_state Dhaka::TOKENIZER_IDLE_STATE do
     for_characters(all_characters - (digits + letters + newline + whitespace + equal_sign)) do
@@ -49,7 +48,7 @@ class ChittagongTokenizer < Dhaka::Tokenizer
       switch_to Dhaka::TOKENIZER_IDLE_STATE
     end
     for_character equal_sign do
-      curr_token.symbol_name += '='
+      curr_token.symbol_name << '='
       advance
       switch_to Dhaka::TOKENIZER_IDLE_STATE
     end
@@ -60,18 +59,18 @@ class ChittagongTokenizer < Dhaka::Tokenizer
       switch_to Dhaka::TOKENIZER_IDLE_STATE
     end
     for_characters digits do
-      curr_token.value += curr_char
+      curr_token.value << curr_char
       advance
     end
   end
-
+  # lipi:keywords
   for_state :get_word_literal do
     for_characters all_characters - letters do
       curr_token.symbol_name = word_literal_symbol(curr_token.value)
       switch_to Dhaka::TOKENIZER_IDLE_STATE
     end
     for_characters letters do
-      curr_token.value += curr_char
+      curr_token.value << curr_char
       advance
       curr_token.symbol_name = word_literal_symbol(curr_token.value) unless curr_char
     end
@@ -84,5 +83,6 @@ class ChittagongTokenizer < Dhaka::Tokenizer
       'word_literal'
     end
   end
+  # lipi:keywords
   
 end

data/test/{chittagong_tokenizer_test.rb → chittagong/chittagong_tokenizer_test.rb}

@@ -1,6 +1,5 @@
-require "test/unit"
-
-require "chittagong_tokenizer"
+require File.dirname(__FILE__) + '/../dhaka_test_helper'
+require File.dirname(__FILE__) + "/chittagong_tokenizer"
 
 class TestChittagongTokenizer < Test::Unit::TestCase
   def test_tokenizes_a_program

data/test/compiled_parser_test.rb

@@ -1,16 +1,10 @@
-require "test/unit"
-require "simple_grammar"
-require 'arithmetic_test_methods'
-require 'arithmetic_grammar'
-
-eval(Dhaka::Parser.new(SimpleGrammar).compile_to_ruby_source_as('Foo'))
-eval(Dhaka::Parser.new(ArithmeticGrammar).compile_to_ruby_source_as('CompiledArithmeticParser'))
+require File.dirname(__FILE__) + '/dhaka_test_helper'
+require File.dirname(__FILE__) + "/simple_grammar"
+eval(Dhaka::Parser.new(SimpleGrammar).compile_to_ruby_source_as(:SimpleParser))
 
 class TestCompiledParser < Test::Unit::TestCase
-  include ArithmeticTestMethods
-  
   def test_compiled_parser_generates_parse_tree_for_simple_grammar
-    parse_tree = Foo.parse(build_tokens(['(','n','-','(','n','-','n',')',')','-','n','#',Dhaka::END_SYMBOL_NAME])).parse_tree
+    parse_tree = SimpleParser.parse(build_tokens(['(','n','-','(','n','-','n',')',')','-','n','#',Dhaka::END_SYMBOL_NAME]))
     assert_equal \
       ["literal",
        "term",
@@ -28,39 +22,13 @@ class TestCompiledParser < Test::Unit::TestCase
        "start"], parse_tree.linearize.collect {|node| node.production.name}
   end
 
-  def test_compiled_parser_generates_parse_tree_for_arithmetic_grammar
-    parser_input = ['(','n','-','(','n','/','n','-','n',')','/','n',')',Dhaka::END_SYMBOL_NAME]
-    assert_equal \
-      ["getting_literals",
-       "factor",
-       "term",
-       "getting_literals",
-       "factor",
-       "getting_literals",
-       "division",
-       "term",
-       "getting_literals",
-       "factor",
-       "subtraction",
-       "unpacking_parenthetized_expression",
-       "factor",
-       "getting_literals",
-       "division",
-       "subtraction",
-       "unpacking_parenthetized_expression",
-       "factor",
-       "term",
-       "expression"], parse(build_tokens(parser_input)).linearize.collect {|node| node.production.name}
-  end
-  
-  def test_parse_result_has_nil_parse_tree_if_empty_token_array
-    parse_result = CompiledArithmeticParser.parse([])
-    assert !CompiledArithmeticParser.parse([]).has_error?
-    assert_nil parse_result.parse_tree
+  def test_parse_result_has_error_result_if_only_end_token_passed
+    parse_result = SimpleParser.parse(build_tokens([Dhaka::END_SYMBOL_NAME]))
+    assert parse_result.has_error?
   end
 
   def test_parser_returns_error_result_with_index_of_bad_token_if_parse_error
-    parse_result = CompiledArithmeticParser.parse(build_tokens(['(', '-', ')',Dhaka::END_SYMBOL_NAME]))
+    parse_result = SimpleParser.parse(build_tokens(['(', '-', ')',Dhaka::END_SYMBOL_NAME]))
     assert parse_result.has_error?
     assert_equal '-', parse_result.unexpected_token.symbol_name
   end
@@ -68,5 +36,4 @@ class TestCompiledParser < Test::Unit::TestCase
   def build_tokens(token_symbol_names)
     token_symbol_names.collect {|symbol_name| Dhaka::Token.new(symbol_name, nil, nil)}
   end
-
-end
+end

data/test/dhaka_test_helper.rb

@@ -0,0 +1,17 @@
+unless defined? Dhaka
+  require File.dirname(__FILE__) + '/../lib/dhaka'
+end
+
+require File.dirname(__FILE__) + '/fake_logger'
+
+require 'test/unit'
+
+begin
+  require 'mocha'
+rescue LoadError
+  puts "
+  The tests depend on Mocha. Please install it if you wish to run them:
+    sudo gem install mocha
+  This gem is not required for using the library."
+  exit
+end

data/test/evaluator_test.rb

@@ -1,8 +1,23 @@
-require "test/unit"
-require File.dirname(__FILE__)+'/../lib/dhaka'
+require File.dirname(__FILE__) + '/dhaka_test_helper'
+require File.dirname(__FILE__) + '/simple_grammar'
 
 class TestEvaluator < Test::Unit::TestCase
   def test_throws_exception_if_evaluation_rules_not_completely_defined
-    assert_raise(Dhaka::EvaluatorDefinitionError) {require 'incomplete_arithmetic_evaluator'}
+    assert_raise(Dhaka::EvaluatorDefinitionError) do 
+      eval(
+      "class IncompleteSimpleEvaluator < Dhaka::Evaluator
+        self.grammar = SimpleGrammar
+        define_evaluation_rules do
+          for_start do
+            something
+          end
+        
+          for_literal do
+            something
+          end
+        end
+      end")
+    end
+    
   end
 end

data/test/grammar_test.rb

@@ -1,35 +1,32 @@
-#!/usr/bin/env ruby
-require 'test/unit'
-require 'simple_grammar'
+require File.dirname(__FILE__) + '/dhaka_test_helper'
+require File.dirname(__FILE__) + '/simple_grammar'
 
 class SimpleGrammarTest < Test::Unit::TestCase
-  
   def setup
     @grammar = SimpleGrammar
   end
   
   def test_loads_symbol_and_classifies_them
     expected_non_terminals = Set.new(['E', 'S', 'T', Dhaka::START_SYMBOL_NAME])
-    expected_terminals = Set.new(['-', 'n', '(', ')', '#', Dhaka::END_SYMBOL_NAME])
+    expected_terminals     = Set.new(['-', 'n', '(', ')', '#', Dhaka::END_SYMBOL_NAME])
     assert_equal(expected_non_terminals, Set.new(@grammar.non_terminal_symbols.collect {|symbol| symbol.name}))
     assert_equal(expected_terminals, Set.new(@grammar.terminal_symbols.collect {|symbol| symbol.name}))
   end
   
   def test_creates_productions
     productions_for_E = @grammar.productions_for_symbol(@grammar.symbol_for_name('E'))
-    assert(productions_for_E.size==2)
+    assert(productions_for_E.size == 2)
     expected_productions_for_E = Set.new(['subtraction E ::= E - T', 'term E ::= T'])
     assert_equal(expected_productions_for_E, Set.new(productions_for_E.collect {|production| production.to_s}))
     productions_for_start = @grammar.productions_for_symbol(@grammar.start_symbol)
-    assert(productions_for_start.size==1)
+    assert(productions_for_start.size == 1)
     expected_productions_for_start = Set.new(['start _Start_ ::= S #'])
     assert_equal(expected_productions_for_start, Set.new(productions_for_start.collect {|production| production.to_s}))
-
   end
   
   def test_symbols_in_productions_use_the_flyweight_pattern
     assert_same(@grammar.production_named('subtraction').symbol, @grammar.production_named('term').symbol)
-    assert_same(@grammar.production_named('expression').expansion[0], @grammar.production_named('subtraction').expansion[0])
+    assert_same(@grammar.production_named('expression').expansion.first, @grammar.production_named('subtraction').expansion.first)
   end
   
   def test_first_with_non_terminal
@@ -43,11 +40,11 @@ class SimpleGrammarTest < Test::Unit::TestCase
   end
 
   def test_computes_closures_and_channels_given_a_kernel
-    start_production = @grammar.production_named('start')
-    start_item = Dhaka::Item.new(start_production, 0)
-    kernel = Set.new([start_item])
+    start_production  = @grammar.production_named('start')
+    start_item        = Dhaka::Item.new(start_production, 0)
+    kernel            = Set.new([start_item])
     channels, closure = @grammar.closure(kernel)
-    expected_items = Set.new(['_Start_ ::= -> S # []',
+    expected_items    = Set.new(['_Start_ ::= -> S # []',
                               'S ::= -> E []',
                               'E ::= -> E - T []',
                               'E ::= -> T []',
@@ -65,6 +62,4 @@ class SimpleGrammarTest < Test::Unit::TestCase
     assert_equal(expected_items, Set.new(closure.values.collect{|item| item.to_s}))
     assert_equal(expected_channels, Set.new(channels.collect{|item| item.to_s}))
   end
-
-
 end

data/test/lalr_but_not_slr_grammar.rb

@@ -1,17 +1,19 @@
-require File.dirname(__FILE__)+'/../lib/dhaka'
-
 class LALRButNotSLRGrammar < Dhaka::Grammar
+
   for_symbol(Dhaka::START_SYMBOL_NAME) do
-    start ['E']
+    start %w| E |
   end
+
   for_symbol('E') do
-    E_Aa ['A', 'a']
-    E_bAc ['b', 'A', 'c']
-    E_dc ['d', 'c']
-    E_bda ['b', 'd', 'a']
+    E_Aa  %w| A a |
+    E_bAc %w| b A c |
+    E_dc  %w| d c |
+    E_bda %w| b d a |
   end
+
   for_symbol('A') do
-    A_d ['d']
+    A_d   %w| d |
   end
+
 end
 

data/test/malformed_grammar.rb

@@ -1,9 +1,7 @@
-require File.dirname(__FILE__)+'/../lib/dhaka'
-
 class MalformedGrammar < Dhaka::Grammar
 
-  for_symbol('goo') do
-    foo ['boo']
+  for_symbol('foo') do
+    bar %w| baz |
   end
   
 end

data/test/malformed_grammar_test.rb

@@ -1,6 +1,5 @@
-require "test/unit"
-
-require "malformed_grammar"
+require File.dirname(__FILE__) + '/dhaka_test_helper'
+require File.dirname(__FILE__) + "/malformed_grammar"
 
 class TestMalformedGrammar < Test::Unit::TestCase
   def test_must_have_a_start_symbol_in_order_to_generate_a_parser

data/test/nullable_grammar.rb

@@ -1,18 +1,21 @@
-require File.dirname(__FILE__)+'/../lib/dhaka'
-
 class NullableGrammar < Dhaka::Grammar
+
   for_symbol(Dhaka::START_SYMBOL_NAME) do
-    tuple ['Tuple']
+    tuple                     %w| Tuple |
   end
+
   for_symbol('Tuple') do
-    element_list ['(', 'Elements', ')']
+    element_list              %w| ( Elements ) |
   end
+
   for_symbol('Elements') do
-    empty_element_list []
-    concatenate_element_lists ['Character', 'Elements']
+    empty_element_list        %w| |
+    concatenate_element_lists %w| Character Elements |
   end
+
   for_symbol('Character') do
-    literal_a ['a']
-    literal_b ['b']
+    literal_a                 %w| a |
+    literal_b                 %w| b |
   end
+
 end

data/test/parse_result_test.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/dhaka_test_helper'
+require File.dirname(__FILE__) + '/simple_grammar'
+
+class TestParseSuccessResult < Test::Unit::TestCase
+  include Dhaka
+
+  def composite_node(production, child_nodes, dot_name)
+    node = ParseTreeCompositeNode.new(SimpleGrammar.production_named(production))
+    node.child_nodes.concat child_nodes
+    node.stubs(:dot_name).returns(dot_name)
+    node
+  end
+
+  def leaf_node(token, value, dot_name)
+    node = ParseTreeLeafNode.new(Token.new(token, value, nil))
+    node.stubs(:dot_name).returns(dot_name)
+    node
+  end
+
+  def test_parse_tree_can_be_exported_to_dot_format
+    first_term    = composite_node('literal', [leaf_node('n', 1, "literal_1")], "first_term")
+    second_term   = composite_node('literal', [leaf_node('n', 2, "literal_2")], "second_term")
+    addition_term = leaf_node('-', nil, "subtraction_operator")
+    tree          = composite_node('subtraction', [first_term, addition_term, second_term], "expression")
+    result        = ParseSuccessResult.new(tree)
+    assert_equal(
+%(digraph x {
+node [fontsize="10" shape=box size="5"]
+expression [label="subtraction E ::= E - T"]
+expression -> first_term
+first_term [label="literal T ::= n"]
+first_term -> literal_1
+literal_1 [label="n : 1"]
+expression -> subtraction_operator
+subtraction_operator [label="-"]
+expression -> second_term
+second_term [label="literal T ::= n"]
+second_term -> literal_2
+literal_2 [label="n : 2"]
+}), 
+    result.to_dot)
+  end
+
+end

data/test/parser_state_test.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/dhaka_test_helper'
+
+class TestParserState < Test::Unit::TestCase
+  include Dhaka
+  def test_unique_identifier
+    states = (0...5).collect {|i| ParserState.new(nil, {})}
+    ids = Set.new
+    states.each do |state|
+      assert(/^State(\d+)$/ =~ state.unique_name)
+      ids << $1.to_i
+    end
+    assert_equal(5, ids.size)
+  end
+  
+  def test_to_s_method
+    options = {:some_option => true}
+    item1 = mock()
+    item1.stubs(:to_s).with(options).returns("i'm item 1")
+    item2 = mock()
+    item2.stubs(:to_s).with(options).returns("i'm item 2")
+    state = ParserState.new(nil, {item1 => item1, item2 => item2})
+    assert_equal(["i'm item 1", "i'm item 2"], state.to_s(options).split("\n").sort)
+  end
+  
+  def test_to_dot_method
+    options = {:some_option => true}
+    item1 = mock()
+    item1.stubs(:to_s).with(options).returns("i'm item 1")
+    item2 = mock()
+    item2.stubs(:to_s).with(options).returns("i'm item 2")
+    state = ParserState.new(nil, {item1 => item1, item2 => item2})
+    state.stubs(:unique_name).returns("State1")
+    assert(state.to_dot(options) =~ /^State1 \[label="(.+)\\n(.+)"\]/)
+    assert_equal(["i'm item 1", "i'm item 2"], [$1, $2].sort)
+  end
+end

data/test/parser_test.rb

@@ -1,16 +1,12 @@
-#!/usr/bin/env ruby
-require 'test/unit'
-require 'simple_grammar'
-require 'arithmetic_grammar'
-require 'nullable_grammar'
-require 'lalr_but_not_slr_grammar'
-require 'another_lalr_but_not_slr_grammar'
-require 'rr_conflict_grammar'
-require 'sr_conflict_grammar'
-require 'fake_logger'
+require File.dirname(__FILE__) + '/dhaka_test_helper'
+require File.dirname(__FILE__) + '/simple_grammar'
+require File.dirname(__FILE__) + '/nullable_grammar'
+require File.dirname(__FILE__) + '/lalr_but_not_slr_grammar'
+require File.dirname(__FILE__) + '/another_lalr_but_not_slr_grammar'
+require File.dirname(__FILE__) + '/rr_conflict_grammar'
+require File.dirname(__FILE__) + '/sr_conflict_grammar'
 
 class ParserTest < Test::Unit::TestCase
-
   def build_tokens(token_symbol_names)
     token_symbol_names.collect {|symbol_name| Dhaka::Token.new(symbol_name, nil, nil)}
   end
@@ -20,37 +16,45 @@ class ParserTest < Test::Unit::TestCase
     @parser = Dhaka::Parser.new(@grammar)
   end
 
+  def contains(given_member, set)
+    set.inject(false) {|result, member| result ||= (Set.new(member) == Set.new(given_member))}
+  end
+
+  def assert_collection_equal(expected, actual)
+    assert_equal(expected.size, actual.size)
+    actual.each do |actual_member|
+      assert(contains(actual_member, expected))
+    end
+  end
+  
   def test_parser_generates_states_with_correct_items
-    expected_states = {}
-    expected_states[1] = Set.new(['_Start_ ::= -> S # [_End_]',
+    expected_states = [
+                       ['_Start_ ::= -> S # [_End_]',
                           'S ::= -> E [#]',
                           'E ::= -> E - T [#-]',
                           'E ::= -> T [#-]',
                           'T ::= -> n [#-]',
-                          'T ::= -> ( E ) [#-]'])
-    expected_states[2] = Set.new(['E ::= T -> [#)-]'])
-    expected_states[3] = Set.new(['T ::= n -> [#)-]'])
-    expected_states[4] = Set.new(['S ::= E -> [#]', 
-                          'E ::= E -> - T [#-]'])
-    expected_states[5] = Set.new(['_Start_ ::= S -> # [_End_]'])
-    expected_states[6] = Set.new(['T ::= ( -> E ) [#)-]',
+                          'T ::= -> ( E ) [#-]'],
+                       ['E ::= T -> [#)-]'],
+                       ['T ::= n -> [#)-]'],
+                       ['S ::= E -> [#]', 
+                          'E ::= E -> - T [#-]'],
+                       ['_Start_ ::= S -> # [_End_]'],
+                       ['T ::= ( -> E ) [#)-]',
                           'E ::= -> E - T [)-]',
                           'E ::= -> T [)-]',
                           'T ::= -> n [)-]',
-                          'T ::= -> ( E ) [)-]'])
-    expected_states[7] = Set.new(['E ::= E - -> T [#)-]',
+                          'T ::= -> ( E ) [)-]'],
+                       ['E ::= E - -> T [#)-]',
                           'T ::= -> n [#)-]',
-                          'T ::= -> ( E ) [#)-]'])
-    expected_states[8] = Set.new(['E ::= E - T -> [#)-]'])
-    expected_states[9] = Set.new(['T ::= ( E -> ) [#)-]',
-                          'E ::= E -> - T [)-]'])
-    expected_states[10] = Set.new(['T ::= ( E ) -> [#)-]'])
-    expected_states[11] = Set.new(['_Start_ ::= S # -> [_End_]'])
-    actual_states = Set.new(@parser.send('states').collect {|state| Set.new(state.items.values.collect {|item| item.to_s})})
-    #write_parser(@parser)
-    expected_states.values.each do |state|
-      assert set_finder(state, actual_states), "expected #{state.to_a}"
-    end
+                          'T ::= -> ( E ) [#)-]'],
+                       ['E ::= E - T -> [#)-]'],
+                       ['T ::= ( E -> ) [#)-]',
+                          'E ::= E -> - T [)-]'],
+                       ['T ::= ( E ) -> [#)-]'],
+                       ['_Start_ ::= S # -> [_End_]']]
+    actual_states = @parser.send('states').collect {|state| state.items.values.collect {|item| item.to_s}}
+    assert_collection_equal(expected_states, actual_states)
   end
   
   def test_parser_can_be_exported_to_dot_format
@@ -58,7 +62,7 @@ class ParserTest < Test::Unit::TestCase
   end
   
   def test_parser_generates_parse_tree_given_a_stream_of_symbols
-    parse_tree = @parser.parse(build_tokens(['(','n','-','(','n','-','n',')',')','-','n','#', Dhaka::END_SYMBOL_NAME])).parse_tree
+    parse_tree = @parser.parse(build_tokens(['(','n','-','(','n','-','n',')',')','-','n','#', Dhaka::END_SYMBOL_NAME]))
     assert_equal \
       ["literal",
        "term",
@@ -76,68 +80,13 @@ class ParserTest < Test::Unit::TestCase
        "start"], parse_tree.linearize.collect {|node| node.production.name}
   end
   
-  def test_parse_trees_can_be_exported_to_dot_format
-    parse_tree = @parser.parse(build_tokens(['(','n','-','(','n','-','n',')',')','-','n','#', Dhaka::END_SYMBOL_NAME])).parse_tree
-    parse_tree.to_dot
-  end
-  
   def get_linearized_parse_result(input, parser)
     parser.parse(build_tokens(input)).parse_tree.linearize.collect {|node| node.production.name}
   end
   
-  def test_with_a_different_grammar_with_division
-    grammar = ArithmeticGrammar
-    parser = Dhaka::Parser.new(grammar)
-    parser_input = ['(','n','-','(','n','/','n','-','n',')','/','n',')', Dhaka::END_SYMBOL_NAME]
-    assert_equal \
-      ["getting_literals",
-       "factor",
-       "term",
-       "getting_literals",
-       "factor",
-       "getting_literals",
-       "division",
-       "term",
-       "getting_literals",
-       "factor",
-       "subtraction",
-       "unpacking_parenthetized_expression",
-       "factor",
-       "getting_literals",
-       "division",
-       "subtraction",
-       "unpacking_parenthetized_expression",
-       "factor",
-       "term",
-       "expression"], get_linearized_parse_result(parser_input, parser)
-
-    parser_input = ['h','(','(','n',')','-','n',',','n',')', Dhaka::END_SYMBOL_NAME]
-    assert_equal \
-      ["max_function",
-       "getting_literals",
-       "factor",
-       "term",
-       "unpacking_parenthetized_expression",
-       "factor",
-       "term",
-       "getting_literals",
-       "factor",
-       "subtraction",
-       "getting_literals",
-       "factor",
-       "term",
-       "single_args",
-       "concatenating_args",
-       "evaluating_function",
-       "function",
-       "factor",
-       "term",
-       "expression"], get_linearized_parse_result(parser_input, parser)
-  end
-  
   def test_with_a_grammar_with_nullables_after_terminals
-    grammar = NullableGrammar
-    parser = Dhaka::Parser.new(grammar)
+    grammar      = NullableGrammar
+    parser       = Dhaka::Parser.new(grammar)
     parser_input = ['(','a',')', Dhaka::END_SYMBOL_NAME]
     assert_equal \
       ["literal_a",
@@ -148,30 +97,31 @@ class ParserTest < Test::Unit::TestCase
   end
 
   def test_with_a_grammar_that_is_not_SLR
-    grammar = LALRButNotSLRGrammar
-    parser = Dhaka::Parser.new(grammar)
+    grammar      = LALRButNotSLRGrammar
+    parser       = Dhaka::Parser.new(grammar)
     parser_input = ['b','d','c', Dhaka::END_SYMBOL_NAME]
     assert_equal(["A_d", "E_bAc", "start"], get_linearized_parse_result(parser_input, parser))
   end
 
   def test_with_another_grammar_that_is_not_SLR
-    grammar = AnotherLALRButNotSLRGrammar
-    parser = Dhaka::Parser.new(grammar)
+    grammar      = AnotherLALRButNotSLRGrammar
+    parser       = Dhaka::Parser.new(grammar)
     parser_input = ['*', 'id', '=', 'id', Dhaka::END_SYMBOL_NAME]
     assert_equal(["identifier", "l_value", "contents", "identifier", "l_value", "assignment"], get_linearized_parse_result(parser_input, parser))
   end
 
-  def test_with_a_grammar_that_should_generate_an_RR_conflict
-    grammar = RRConflictGrammar
+  def test_debug_output_with_a_grammar_that_should_generate_an_RR_conflict
     fake_logger = FakeLogger.new
-    Dhaka::Parser.new(grammar, fake_logger)
-    assert_equal(1,  fake_logger.errors.size)
+    Dhaka::ParserState.any_instance.stubs(:unique_name).returns("StateXXX")
+    parser = Dhaka::Parser.new(RRConflictGrammar, fake_logger)
+    num_states = parser.send(:states).size
+    assert_equal(['Created StateXXX.'] * num_states, fake_logger.debugs[0...num_states])
+    assert_equal(1, fake_logger.errors.size)
+    assert(fake_logger.errors.first.match(/^Parser Conflict at State:\n(.+)\n(.+)\nExisting: (.+)\nNew: (.+)\nLookahead: (.+)$/))
+    assert_equal(["A ::= x y ->", "B ::= x y ->", "Reduce with xy A ::= x y", "Reduce with xy_again B ::= x y", "c"], 
+        $~[1..5].sort)
   end
 
-  def set_finder(set1, set2)
-    set2.inject(false) {|result, member| result ||= member == set1}
-  end
-  
   def write_parser(parser)
     File.open('parser.dot', 'w') do |file|
       file << parser.to_dot