aurum 0.1.1 → 0.2.0

data/spec/examples/yacc_spec.rb

@@ -0,0 +1,30 @@
+helper_dir = File.join(File.dirname(__FILE__), '..')
+$:.unshift(helper_dir) unless $:.include?(helper_dir)
+
+require 'spec_helper'
+require 'yacc/grammar'
+
+describe 'Yacc Grammar' do
+  before :all do
+    YaccLexer = Aurum::Lexer.new(Aurum::Examples::YaccGrammar)
+    #YaccParser = Aurum::Parser.new(Aurum::Examples::YaccGrammar, :grammar)
+  end
+  
+  it 'should ' do
+    lines = File.open('ruby.y').readlines
+    content = lines.join("\n")
+    scanner = scanner(content)
+    while (a = scanner.next_symbol)
+      p a
+      break if a.terminal == '$unknown' || a.terminal == '$eof'
+    end
+  end
+  
+  def scanner source
+    YaccLexer.new(source)
+  end
+  
+  def parse source
+    YaccParser.new.parse(YaccLexer.new(source)).s_exp
+  end
+end

data/spec/grammar/builder/lexical_table/automata_spec.rb

@@ -0,0 +1,55 @@
+helper_dir = File.join(File.dirname(__FILE__), '..', '..', '..')
+$:.unshift(helper_dir) unless $:.include?(helper_dir)
+
+require 'spec_helper'
+
+require File.dirname(__FILE__) + '/regular_expression'
+
+describe Aurum::Grammar::LexicalRules::Automata, ' alphabet' do
+  before :each do
+    @automata =  Aurum::Grammar::LexicalRules::Automata.new(4)
+  end
+  
+  it 'should return ac and mq' do
+    @automata.connect(0, interval(?a, ?c), 1)
+    @automata.connect(2, interval(?m, ?q), 3)
+    result = []
+    @automata.alphabet([0, 2]) {|states, character_set| result << [states, character_set]}
+    result.should == [[[1], interval(?a, ?c)], [[3], interval(?m, ?q)]]
+  end
+  
+  it 'should return ac df and g' do
+    @automata.connect(0, interval(?a, ?f), 1)
+    @automata.connect(2, interval(?d, ?g), 3)
+    result = []
+    @automata.alphabet([0, 2]) {|states, character_set| result << [states, character_set]}
+    result.should == [[[1], interval(?a, ?c)], [[1, 3], interval(?d, ?f)], [[3], interval(?g, ?g)]]
+  end
+  
+  it 'should return ac dg and hz' do
+    @automata.connect(0, interval(?a, ?z), 1)
+    @automata.connect(2, interval(?d, ?g), 3)
+    result = []
+    @automata.alphabet([0, 2]) {|states, character_set| result << [states, character_set]}
+    result.should == [[[1], interval(?a, ?c)], [[1, 3], interval(?d, ?g)], [[1], interval(?h, ?z)]]    
+  end  
+  
+  def interval first, last
+    Aurum::Grammar::LexicalRules::CharacterSet::Interval.new(first, last).to_char_set
+  end
+end
+
+describe  Aurum::Grammar::LexicalRules::Automata, ' subset determinizer' do
+  include DeterminizedPatternMatcher
+  it_should_behave_like 'regular expression'
+end
+
+describe  Aurum::Grammar::LexicalRules::Automata, ' hopcroft minimizer' do
+  include MinimizedPatternMatcher
+  it_should_behave_like 'regular expression'
+end
+
+
+
+
+

data/spec/grammar/builder/lexical_table/builder_spec.rb

@@ -0,0 +1,78 @@
+helper_dir = File.join(File.dirname(__FILE__), '..', '..', '..')
+$:.unshift(helper_dir) unless $:.include?(helper_dir)
+
+require 'spec_helper'
+
+def scan(lexical_state, lexeme)
+  begin
+    state = - @table.lexical_states.index(lexical_state.to_s) - 1
+    state = (@table.states[0].find {|tran| tran.character_set.include?(state)}).destination
+    lexeme.each_byte {|char| state = (@table.states[state].find {|tran| tran.character_set.include?(char)}).destination}
+    @table.actions[state]
+  rescue
+    raise 'error'
+  end
+end
+
+describe Aurum::Builder::LexicalTableBuilder, ' no reserved literal' do
+  before :all do
+    @pattern_a, @pattern_b = $pattern.string('pattern_a'), $pattern.string('pattern_b')
+    @action_a, @action_b = Aurum::LexicalTable::Action.new('pattern_a'), Aurum::LexicalTable::Action.new('pattern_b')
+    @lexical_rules = Aurum::Grammar::LexicalRules.new
+    @lexical_rules.add_lexical_action(:initial, @pattern_a, @action_a)
+    @lexical_rules.add_lexical_action(:state_a, @pattern_b, @action_b)
+  end
+  
+  before :each do
+    @builder = Aurum::Builder::LexicalTableBuilder.new(@lexical_rules, [], [])    
+    @table = @builder.build
+  end
+  
+  it 'should recognize pattern_a in initial state' do
+    scan(:initial, 'pattern_a').should == @action_a
+  end
+  
+  it 'should not recognize pattern_b in initial state' do
+    lambda {scan(:initial, 'pattern_b')}.should raise_error
+  end
+  
+  it 'should recognize pattern_b in state_a' do
+    scan(:state_a, 'pattern_b').should == @action_b
+  end
+  
+  it 'should not recognize pattern_a in state_a' do
+    lambda {scan(:state_a, 'pattern_a')}.should raise_error
+  end  
+end
+
+describe Aurum::Builder::LexicalTableBuilder, ' reserved literal in all states' do
+  before :all do
+    @pattern_a, @pattern_b = $pattern.enum('abcdefghijklmnopqrstuvwxyz').one_or_more, $pattern.string('pattern_b')
+    @action_a, @action_b = Aurum::LexicalTable::Action.new('pattern_a'), Aurum::LexicalTable::Action.new('pattern_b')
+    @lexical_rules = Aurum::Grammar::LexicalRules.new
+    @lexical_rules.add_lexical_action(:initial, @pattern_a, @action_a)
+    @lexical_rules.add_lexical_action(:state_a, @pattern_b, @action_b)    
+    @action_keyword = Aurum::LexicalTable::Action.new('$literal_keyword')
+  end
+  
+  before :each do
+    @builder = Aurum::Builder::LexicalTableBuilder.new(@lexical_rules, ['all'], ['keyword'])
+    @table = @builder.build
+  end
+  
+  it 'should recognize keyword in initial state' do
+    scan(:initial, 'keyword').should == @action_keyword
+  end
+  
+  it 'should recognize pattern_a in initial state' do
+    scan(:initial, 'keywore').should == @action_a
+  end
+  
+  it 'should recognize keyword in state_a' do
+    scan(:state_a, 'keyword').should == @action_keyword
+  end
+  
+  it 'should recognize pattern_a in initial state' do
+    scan(:state_a, 'pattern_b').should == @action_b
+  end  
+end

data/spec/grammar/builder/lexical_table/character_set_spec.rb

@@ -0,0 +1,100 @@
+helper_dir = File.join(File.dirname(__FILE__), '..', '..', '..')
+$:.unshift(helper_dir) unless $:.include?(helper_dir)
+
+require 'spec_helper'
+
+describe Aurum::Grammar::LexicalRules::CharacterSet::Interval do
+  before :each do
+    @interval = Aurum::Grammar::LexicalRules::CharacterSet::Interval.new ?a, ?c
+  end
+
+  it 'should contain character within interval' do
+    (?a..?c).each {|character| @interval.should be_include(character)}
+  end
+
+  it 'should not contain character out of interval' do
+    @interval.should_not be_include(?d)
+  end
+
+  it 'should not merge intervals if they do not have any character in common' do
+    interval = Aurum::Grammar::LexicalRules::CharacterSet::Interval.new ?e, ?f
+    @interval.merge!(interval).should be_nil
+  end
+
+  it 'should merge two intervals if they have characters in common' do
+    interval = Aurum::Grammar::LexicalRules::CharacterSet::Interval.new ?b, ?e
+    @interval.merge!(interval).should_not be_nil
+    @interval.should == Aurum::Grammar::LexicalRules::CharacterSet::Interval.new(?a, ?e)
+  end
+
+  it 'should merge [b-e] and [a-c]' do
+    interval = Aurum::Grammar::LexicalRules::CharacterSet::Interval.new ?b, ?e
+    interval.merge!(@interval).should_not be_nil
+    interval.should == Aurum::Grammar::LexicalRules::CharacterSet::Interval.new(?a, ?e)
+  end
+
+  it 'should merge two intervals if they are adjacent' do
+    interval = Aurum::Grammar::LexicalRules::CharacterSet::Interval.new ?d, ?e
+    @interval.merge!(interval).should_not be_nil
+    @interval.should == Aurum::Grammar::LexicalRules::CharacterSet::Interval.new(?a, ?e)
+  end
+
+  it 'should merge [d-e] and [a-c]' do
+    interval = Aurum::Grammar::LexicalRules::CharacterSet::Interval.new ?d, ?e
+    interval.merge!(@interval).should_not be_nil
+    interval.should == Aurum::Grammar::LexicalRules::CharacterSet::Interval.new(?a, ?e)
+  end
+end
+
+describe Aurum::Grammar::LexicalRules::CharacterSet do
+  it 'should construct character set for string literal' do
+    character_set = Aurum::Grammar::LexicalRules::CharacterSet.enum('age')
+    [?a, ?g, ?e].each {|char | character_set.should be_include(char)}
+  end
+
+  it 'should merge intervals as many as possible' do
+    character_set = Aurum::Grammar::LexicalRules::CharacterSet.enum('abc')
+    character_set.intervals.size.should == 1
+    character_set.intervals.should be_include(Aurum::Grammar::LexicalRules::CharacterSet::Interval.new(?a, ?c))
+  end
+
+  it '[aec] + [dbf] should be [a-f]' do
+    char_set_aec, char_set_dbf = Aurum::Grammar::LexicalRules::CharacterSet.enum('aec'), Aurum::Grammar::LexicalRules::CharacterSet.enum('dbf')
+    result = char_set_aec + char_set_dbf
+    result.intervals.size.should == 1
+    result.intervals.should be_include(Aurum::Grammar::LexicalRules::CharacterSet::Interval.new(?a, ?f))
+  end
+
+  it '[a-d] - [bc] should be [a] and [d]' do
+    char_set_ad, char_set_bc = Aurum::Grammar::LexicalRules::CharacterSet.enum('abcd'), Aurum::Grammar::LexicalRules::CharacterSet.enum('bc')
+    result = char_set_ad - char_set_bc
+    result.intervals.size.should == 2
+    result.intervals.should be_include(Aurum::Grammar::LexicalRules::CharacterSet::Interval.new(?a))
+    result.intervals.should be_include(Aurum::Grammar::LexicalRules::CharacterSet::Interval.new(?d))
+  end
+
+  it '[a-d] - [e-f] should be [a-d]' do
+    char_set_ad, char_set_ef = Aurum::Grammar::LexicalRules::CharacterSet.enum('abcd'), Aurum::Grammar::LexicalRules::CharacterSet.enum('ef')
+    result = char_set_ad - char_set_ef
+    result.intervals.size.should == 1
+    result.intervals.should be_include(Aurum::Grammar::LexicalRules::CharacterSet::Interval.new(?a, ?d))
+  end
+
+  it '[a-d] - [a-d] should be []' do
+    char_set_ad = Aurum::Grammar::LexicalRules::CharacterSet.enum('abcd')
+    result = char_set_ad - char_set_ad
+    result.intervals.size.should == 0
+  end
+end
+
+describe Aurum::Grammar::LexicalRules::Point do
+  before :each do
+    @point = Aurum::Grammar::LexicalRules::Point.new(?a, true, 1)
+  end
+  
+  it {@point.should == @point}  
+  it {@point.should < Aurum::Grammar::LexicalRules::Point.new(?b, true, 1)}
+  it {@point.should > Aurum::Grammar::LexicalRules::Point.new(?A, true, 1)}
+  it {@point.should < Aurum::Grammar::LexicalRules::Point.new(?a, false, 1)}
+  it {Aurum::Grammar::LexicalRules::Point.new(?a, false, 1).should > @point}
+end

data/spec/grammar/builder/lexical_table/pattern_spec.rb

@@ -0,0 +1,11 @@
+helper_dir = File.join(File.dirname(__FILE__), '..', '..', '..')
+$:.unshift(helper_dir) unless $:.include?(helper_dir)
+
+require 'spec_helper'
+
+require File.dirname(__FILE__) + '/regular_expression'
+
+describe Aurum::Grammar::LexicalRules::Pattern do
+  include PatternMatcher
+  it_should_behave_like 'regular expression'
+end

data/spec/grammar/builder/lexical_table/regular_expression.rb

@@ -0,0 +1,40 @@
+describe 'regular expression', :shared => true do
+  it {'string'.should be_matched_by('string', $pattern.string('string'))}
+  it {'string'.should_not be_matched_by('other_string', $pattern.string('other_string'))}
+  it {'a'.should be_matched_by('a|b|c', $pattern.enum('abc'))}
+  it {'b'.should be_matched_by('a|b|c', $pattern.enum('abc'))}
+  it {'c'.should be_matched_by('a|b|c', $pattern.enum('abc'))}
+  it {'d'.should_not be_matched_by('a|b|c', $pattern.enum('abc'))}
+  it {''.should be_matched_by('(abc)*', $pattern.string('abc').zero_or_more)}
+  it {'abc'.should be_matched_by('(abc)*', $pattern.string('abc').zero_or_more)}
+  it {'abcabcabcabc'.should be_matched_by('(abc)*', $pattern.string('abc').zero_or_more)}
+  it {''.should_not be_matched_by('(abc)+', $pattern.string('abc').one_or_more)}
+  it {'abc'.should be_matched_by('(abc)+', $pattern.string('abc').one_or_more)}
+  it {'abcabcabcabc'.should be_matched_by('(abc)+', $pattern.string('abc').one_or_more)}
+  it {''.should be_matched_by('(abc)+', $pattern.string('abc').zero_or_one)}
+  it {'abc'.should be_matched_by('(abc)+', $pattern.string('abc').zero_or_one)}
+  it {'abcabc'.should_not be_matched_by('(abc)+', $pattern.string('abc').zero_or_one)}
+  it {'abcdef'.should be_matched_by('(abc)(def)', $pattern.concat([$pattern.string('abc'), $pattern.string('def')]))}
+  it {'abcdeg'.should_not be_matched_by('(abc)(def)', $pattern.concat([$pattern.string('abc'), $pattern.string('def')]))}
+  it {'abcabc'.should be_matched_by('(abc){2}', $pattern.string('abc')[2])}
+  it {'abc'.should_not be_matched_by('(abc){2}', $pattern.string('abc')[2])}
+  it {'abcabcabc'.should_not be_matched_by('(abc){2}', $pattern.string('abc')[2])}
+  it {'abcabc'.should be_matched_by('(abc){2,4}', $pattern.string('abc')[2, 4])}
+  it {'abcabcabc'.should be_matched_by('(abc){2,4}', $pattern.string('abc')[2, 4])}
+  it {'abcabcabcabc'.should be_matched_by('(abc){2,4}', $pattern.string('abc')[2, 4])}
+  it {'abc'.should_not be_matched_by('(abc){2,4}', $pattern.string('abc')[2, 4])}
+  it {'abcabcabcabcabc'.should_not be_matched_by('(abc){2,4}', $pattern.string('abc')[2, 4])}
+  it {'abc'.should be_matched_by('(abc)|(def)', $pattern.string('abc') | $pattern.string('def'))}
+  it {'def'.should be_matched_by('(abc)|(def)', $pattern.string('abc') | $pattern.string('def'))}
+  it {'deg'.should_not be_matched_by('(abc)|(def)', $pattern.string('abc') | $pattern.string('def'))}
+  it {'abc'.should_not be_matched_by('!abc', $pattern.string('abc').not)}
+  it {'ade'.should be_matched_by('!abc', $pattern.string('abc').not)}
+  it {'a'.should be_matched_by('!abc', $pattern.string('abc').not)}
+  it {'abcdefhijk'.should be_matched_by('!abc', $pattern.string('abc').not)}
+  it {''.should be_matched_by('!abc', $pattern.string('abc').not)}
+  it {'abcdef */'.should be_matched_by('~*/', ~ $pattern.string('*/'))}
+  it {'/* abcdef */'.should be_matched_by('/*~*/', $pattern.concat([$pattern.string('/*'), ~ $pattern.string('*/')]))}
+  it {'abcdef */ /'.should_not be_matched_by('~*/', ~ $pattern.string('*/'))}
+  it {'abcdef'.should_not be_matched_by('~*/', ~ $pattern.string('*/'))}
+  it {'abcdef *'.should_not be_matched_by('~*/', ~ $pattern.string('*/'))}
+end

data/spec/grammar/builder/parsing_table/augmented_grammar_spec.rb

@@ -0,0 +1,36 @@
+helper_dir = File.join(File.dirname(__FILE__), '..', '..', '..')
+$:.unshift(helper_dir) unless $:.include?(helper_dir)
+
+require 'spec_helper'
+
+describe Aurum::Builder::AugmentedGrammar do
+  before :all do
+    @syntax_rules = Aurum::Grammar::SyntaxRules.new
+    @E, @T = Aurum::Grammar.nonterminal('E'), Aurum::Grammar.nonterminal('T')
+    @F, @id = Aurum::Grammar.nonterminal('F'), Aurum::Grammar.terminal('id')
+    @syntax_rules.add_syntax_rule Aurum::Grammar.production(@E, [@T])
+    @syntax_rules.add_syntax_rule Aurum::Grammar.production(@E, [@F])
+    @syntax_rules.add_syntax_rule Aurum::Grammar.production(@T, [])
+    @syntax_rules.add_syntax_rule Aurum::Grammar.production(@F, [@id])
+    @augmented_grammar = Aurum::Builder::AugmentedGrammar.new(@syntax_rules, @E)
+  end
+  
+  it 'should compute all nullable symbols' do
+    @augmented_grammar.compute_nullables
+    @augmented_grammar.should be_nullable(@E)
+    @augmented_grammar.should be_nullable(@T)
+    @augmented_grammar.should_not be_nullable(@F)
+  end
+  
+  it 'first set of terminal should be itself' do
+    @augmented_grammar.compute_first_sets
+    @augmented_grammar.first_set(@id).should == [@id].to_set
+  end
+  
+  it 'first set of symbols should be included to nonterminal' do
+    @augmented_grammar.compute_first_sets
+    @augmented_grammar.first_set(@E).should == [@id].to_set
+    @augmented_grammar.first_set(@F).should == [@id].to_set
+    @augmented_grammar.first_set(@T).should == [].to_set        
+  end
+end

data/spec/grammar/builder/parsing_table/builder_spec.rb

@@ -0,0 +1,152 @@
+helper_dir = File.join(File.dirname(__FILE__), '..', '..', '..')
+$:.unshift(helper_dir) unless $:.include?(helper_dir)
+
+require 'spec_helper'
+
+describe 'LR(0)', :shared => true do
+  it 'should not have any inconsistent state' do
+    @builder.instance_eval {@inconsistent_states}.should be_empty
+  end
+
+  it 'lookahead level should be 0' do
+    @parsing_table.lookahead.should == 0
+  end
+end
+
+describe 'LALR(1)', :shared => true do
+  it 'should have inconsistent states' do
+    @builder.instance_eval {@inconsistent_states}.should_not be_empty
+  end
+
+  it 'should not have any conflict state' do
+    @builder.instance_eval {@conflict_states}.should be_empty
+  end
+
+  it 'lookahead level should be 1' do
+    @parsing_table.lookahead.should == 1
+  end
+end
+
+describe 'LALR(n)', :shared => true do
+  it 'should have inconsistent states' do
+    @builder.instance_eval {@inconsistent_states}.should_not be_empty
+  end
+
+  it 'should have conflict states in LALR(1) automata' do
+    @builder.instance_eval {@conflict_states}.should_not be_empty
+  end
+
+  it 'should not have any conflict state in LALR(n) automata' do
+    @builder.instance_eval {@states}.all? {|state| !state.conflict?}.should be_true
+  end
+
+  it 'should have lookahead states' do
+    @builder.instance_eval {@states}.any? {|state| state.empty?}.should be_true
+  end
+
+  it "lookahead level should be n" do
+    @parsing_table.lookahead.should == @lookahead_level
+  end
+end
+
+describe Aurum::Builder::ParsingTableBuilder, ' LR(0) : Simple LR(0) Grammar' do
+  before :each do
+    syntax_rules = SimpleLR0Grammar.instance_eval {@syntax_rules}
+    augmented_grammar = Aurum::Builder::AugmentedGrammar.new(syntax_rules, Aurum::Grammar.nonterminal('expression'))
+    @builder = Aurum::Builder::ParsingTableBuilder.new(augmented_grammar, nil)
+    @parsing_table = @builder.build
+  end
+
+  it 'should use set of items as parsing state' do
+    states = @builder.instance_eval {@states}
+    states.size.should == 3
+    states[0].inspect.should == '[$start -> .expression ]'    
+    states[1].inspect.should == '[expression -> term .+ term ]'
+    states[2].inspect.should == '[expression -> term + .term ]'    
+  end
+
+  it_should_behave_like 'LR(0)'
+end
+
+describe Aurum::Builder::ParsingTableBuilder, ' LALR(1) : Grammar 4.19 in Dragon book' do
+  before :each do
+    syntax_rules = Grammar419InDragonBook.instance_eval {@syntax_rules}
+    augmented_grammar = Aurum::Builder::AugmentedGrammar.new(syntax_rules, Aurum::Grammar.nonterminal('expression'))    
+    @builder = Aurum::Builder::ParsingTableBuilder.new(augmented_grammar, nil)
+    @parsing_table = @builder.build
+  end
+
+  it 'should compute lookahead symbol for inconsistent states' do
+    @parsing_table.actions[1]['$eof'].should_not be_read_reduce
+    @parsing_table.actions[2]['$eof'].should_not be_read_reduce
+    @parsing_table.actions[2]['$literal_)'].should_not be_read_reduce
+    @parsing_table.actions[2]['$literal_+'].should_not be_read_reduce
+    @parsing_table.actions[6]['$eof'].should_not be_read_reduce
+    @parsing_table.actions[6]['$literal_)'].should_not be_read_reduce
+    @parsing_table.actions[6]['$literal_+'].should_not be_read_reduce
+  end
+
+  it_should_behave_like 'LALR(1)'
+end
+
+describe Aurum::Builder::ParsingTableBuilder, ' LALR(1) : Expression Grammar with operator precedences' do
+  before :each do
+    syntax_rules = ExpressionGrammarWithOperatorPrecedence.instance_eval {@syntax_rules}
+    syntax_rules.assign_operator_precedence_to_symbols
+    augmented_grammar = Aurum::Builder::AugmentedGrammar.new(syntax_rules, Aurum::Grammar.nonterminal('expression'))    
+    @builder = Aurum::Builder::ParsingTableBuilder.new(augmented_grammar, nil)
+    @parsing_table = @builder.build
+  end
+
+  it 'should be reduce action if equal precedence operator given' do
+    @parsing_table.actions[7]['$literal_+'].should be_reduce
+  end
+
+  it 'should be reduce action if ) given' do
+    @parsing_table.actions[7]['$literal_)'].should be_reduce
+  end
+
+  it 'should be reduce action if EOF given' do
+    @parsing_table.actions[7]['$eof'].should be_reduce
+  end
+  
+  it 'should be shift action if higer precedence operator given' do
+    @parsing_table.actions[7]['$literal_*'].should be_shift
+  end
+
+  it_should_behave_like 'LALR(1)'
+end
+
+describe Aurum::Builder::ParsingTableBuilder, ' LALR(2) : BNF grammar in Philippe Charles\' thesis' do
+  before :each do
+    syntax_rules = BnfGrammarInCharlesThesis.instance_eval {@syntax_rules}
+    augmented_grammar = Aurum::Builder::AugmentedGrammar.new(syntax_rules, Aurum::Grammar.nonterminal('bnf'))    
+    @builder = Aurum::Builder::ParsingTableBuilder.new(augmented_grammar, nil)    
+    @parsing_table = @builder.build
+    @lookahead_level = 2
+  end
+
+  it_should_behave_like 'LALR(n)'
+end
+
+
+describe Aurum::Builder::ParsingTableBuilder, ' LALR(4) : simple LALR(4) grammar' do
+  before :each do
+    syntax_rules = LALR4Grammar.instance_eval {@syntax_rules}
+    augmented_grammar = Aurum::Builder::AugmentedGrammar.new(syntax_rules, Aurum::Grammar.nonterminal('s'))    
+    @builder = Aurum::Builder::ParsingTableBuilder.new(augmented_grammar, nil)    
+    @parsing_table = @builder.build
+    @lookahead_level = 4
+  end
+
+  it_should_behave_like 'LALR(n)'
+end
+
+describe Aurum::Builder::ParsingTableBuilder, ' not LR(n) : Expression Grammar without operator precedences' do
+  it 'should raise not LR(n) error' do
+    syntax_rules = ExpressionGrammar.instance_eval {@syntax_rules}
+    augmented_grammar = Aurum::Builder::AugmentedGrammar.new(syntax_rules, Aurum::Grammar.nonterminal('expression'))    
+    builder = Aurum::Builder::ParsingTableBuilder.new(augmented_grammar, nil)    
+    lambda {builder.build}.should raise_error(RuntimeError, 'not LALR(n)')
+  end
+end