rley 0.8.14 → 0.8.15

data/spec/rley/parser/gfg_parsing_spec.rb

@@ -35,6 +35,9 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         return helper.build_dotted_items(aGrammar)
       end
 
+      # Default instantiation rule
+      subject(:parsing) { described_class.new(sample_gfg) }
+
       # Factory method. Build a production with the given sequence
       # of symbols as its rhs.
       let(:grm1) do
@@ -52,34 +55,31 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       let(:output) { StringIO.new('', 'w') }
 
-      # Default instantiation rule
-      subject { GFGParsing.new(sample_gfg) }
-
       context 'Initialization:' do
-        it 'should be created with a GFG' do
-          expect { GFGParsing.new(sample_gfg) }.not_to raise_error
+        it 'is created with a GFG' do
+          expect { described_class.new(sample_gfg) }.not_to raise_error
         end
 
-        it 'should have an empty tokens array' do
-          expect(subject.tokens).to be_empty
+        it 'has an empty tokens array' do
+          expect(parsing.tokens).to be_empty
         end
 
-        it 'should know its chart object' do
-          expect(subject.chart).to be_kind_of(GFGChart)
+        it 'knows its chart object' do
+          expect(parsing.chart).to be_a(GFGChart)
         end
 
-        it 'should know the initial parse entry' do
-          expect(subject.initial_entry).to eq(subject.chart.initial_entry)
+        it 'knows the initial parse entry' do
+          expect(parsing.initial_entry).to eq(parsing.chart.initial_entry)
         end
 
-        it 'should have no antecedence for the initial parse entry' do
-          antecedence = subject.antecedence
+        it 'has no antecedence for the initial parse entry' do
+          antecedence = parsing.antecedence
           expect(antecedence.size).to eq(1)
-          expect(antecedence.fetch(subject.initial_entry)).to be_empty
+          expect(antecedence.fetch(parsing.initial_entry)).to be_empty
         end
 
 =begin
-        it 'should emit trace level 1 info' do
+        it 'emits trace level 1 info' do
           tracer = ParseTracer.new(1, output, grm1_tokens)
           Parsing.new([ start_dotted_rule ], grm1_tokens, tracer)
           expectations = <<-SNIPPET
@@ -95,16 +95,16 @@ SNIPPET
       context 'Parsing:' do
         # Utility method to fill the first entry set...
         def fill_first_set
-          subject.start_rule(subject.initial_entry, 0)
-          subject.call_rule(subject.chart[0].last, 0)
-          subject.start_rule(subject.chart[0].last, 0)
+          parsing.start_rule(parsing.initial_entry, 0)
+          parsing.call_rule(parsing.chart[0].last, 0)
+          parsing.start_rule(parsing.chart[0].last, 0)
         end
 
         # Utility method to initialize the second entry set...
         def seed_second_set
           # Cheating: we change the tokens to scan...
           # Seeding second entry set...
-          subject.scan_rule(0, grm1_token_b[0])
+          parsing.scan_rule(0, grm1_token_b[0])
         end
 
         # Utility method used to invoke the private method 'push_entry'
@@ -112,93 +112,93 @@ SNIPPET
           aParsing.send(:push_entry, *args)
         end
 
-        it 'should push a parse entry to a given chart entry set' do
-          expect(subject.chart.sets[1]).to be_nil
+        it 'pushes a parse entry to a given chart entry set' do
+          expect(parsing.chart.sets[1]).to be_nil
           a_vertex = sample_gfg.find_vertex('A => a . A c')
 
-          push_entry(subject, a_vertex, 1, 1, :scan_rule)
-          expect(subject.chart[1].size).to eq(1)
-          expect(subject.chart[1].first.vertex).to eq(a_vertex)
+          push_entry(parsing, a_vertex, 1, 1, :scan_rule)
+          expect(parsing.chart[1].size).to eq(1)
+          expect(parsing.chart[1].first.vertex).to eq(a_vertex)
 
           # Pushing twice the same state must be no-op
-          push_entry(subject, a_vertex, 1, 1, :scan_rule)
-          expect(subject.chart[1].size).to eq(1)
+          push_entry(parsing, a_vertex, 1, 1, :scan_rule)
+          expect(parsing.chart[1].size).to eq(1)
 
           # Pushing to another entry set
-          push_entry(subject, a_vertex, 1, 2, :scan_rule)
-          expect(subject.chart[2].size).to eq(1)
+          push_entry(parsing, a_vertex, 1, 2, :scan_rule)
+          expect(parsing.chart[2].size).to eq(1)
         end
 
-        it 'should complain when trying to push nil instead of vertex' do
+        it 'complains when trying to push nil instead of vertex' do
           err = StandardError
           msg = 'Vertex may not be nil'
-          expect { push_entry(subject, nil, 1, 1, :start_rule) }
+          expect { push_entry(parsing, nil, 1, 1, :start_rule) }
             .to raise_error(err, msg)
         end
 
-        it 'should use the start rule with initial entry' do
-          expect(subject.chart[0].size).to eq(1)
-          initial_entry = subject.initial_entry
-          subject.start_rule(initial_entry, 0)
+        it 'uses the start rule with initial entry' do
+          expect(parsing.chart[0].size).to eq(1)
+          initial_entry = parsing.initial_entry
+          parsing.start_rule(initial_entry, 0)
 
-          expect(subject.chart[0].size).to eq(2)
-          new_entry = subject.chart[0].last
+          expect(parsing.chart[0].size).to eq(2)
+          new_entry = parsing.chart[0].last
           expect(new_entry.vertex.label).to eq('S => . A')
-          expect(subject.antecedence.fetch(new_entry)).to eq([initial_entry])
+          expect(parsing.antecedence.fetch(new_entry)).to eq([initial_entry])
         end
 
-        it 'should apply the call rule correctly' do
-          subject.start_rule(subject.initial_entry, 0)
+        it 'applies the call rule correctly' do
+          parsing.start_rule(parsing.initial_entry, 0)
           # A parse entry with vertex 'S => . A' was added...
-          second_entry = subject.chart[0].last
-          subject.call_rule(second_entry, 0)
+          second_entry = parsing.chart[0].last
+          parsing.call_rule(second_entry, 0)
 
-          expect(subject.chart[0].size).to eq(3)
-          new_entry = subject.chart[0].last
+          expect(parsing.chart[0].size).to eq(3)
+          new_entry = parsing.chart[0].last
           expect(new_entry.vertex.label).to eq('.A')
-          expect(subject.antecedence.fetch(new_entry)).to eq([second_entry])
+          expect(parsing.antecedence.fetch(new_entry)).to eq([second_entry])
         end
 
-        it 'should apply the start rule correctly' do
-          subject.start_rule(subject.chart[0].first, 0)
-          subject.call_rule(subject.chart[0].last, 0)
-          expect(subject.chart[0].size).to eq(3)
+        it 'applies the start rule correctly' do
+          parsing.start_rule(parsing.chart[0].first, 0)
+          parsing.call_rule(parsing.chart[0].last, 0)
+          expect(parsing.chart[0].size).to eq(3)
           # Last entry is: (.A, 0)
-          dot_A_entry = subject.chart[0].last
+          dot_A_entry = parsing.chart[0].last
 
-          subject.start_rule(dot_A_entry, 0)
+          parsing.start_rule(dot_A_entry, 0)
 
           # Expectations: two entries:
           expected = ['A => . a A c', 'A => . b']
-          expect(subject.chart[0].size).to eq(5)
-          expect(subject.chart[0].pop.vertex.label).to eq(expected.last)
-          fourth_entry = subject.chart[0].last
+          expect(parsing.chart[0].size).to eq(5)
+          expect(parsing.chart[0].pop.vertex.label).to eq(expected.last)
+          fourth_entry = parsing.chart[0].last
           expect(fourth_entry.vertex.label).to eq(expected.first)
-          expect(subject.antecedence.fetch(fourth_entry)).to eq([dot_A_entry])
+          expect(parsing.antecedence.fetch(fourth_entry)).to eq([dot_A_entry])
         end
 
-        it 'should apply the scan rule correctly' do
+        it 'applies the scan rule correctly' do
           # Filling manually first entry set...
           fill_first_set
           # There are two entries expecting a terminal:
           # ['A => . a A c', 'A => . b']
-          fourth_entry = subject.chart[0].entries[3] # 'A => . a A c'
+          fourth_entry = parsing.chart[0].entries[3] # 'A => . a A c'
 
-          expect(subject.chart.sets[1]).to be_nil
-          subject.scan_rule(0, grm1_tokens[0])
+          expect(parsing.chart.sets[1]).to be_nil
+          parsing.scan_rule(0, grm1_tokens[0])
           # Given that the scanned token is 'a'...
           # Then a new entry is added in next entry set
-          expect(subject.chart[1].size).to eq(1)
-          last_entry = subject.chart[1].last
+          expect(parsing.chart[1].size).to eq(1)
+          last_entry = parsing.chart[1].last
 
           # Entry must be past the terminal symbol
           expect(last_entry.vertex.label).to eq('A => a . A c')
           expect(last_entry.origin).to eq(0)
-          antecedence = subject.antecedence
+          antecedence = parsing.antecedence
           expect(antecedence.fetch(last_entry)).to eq([fourth_entry])
         end
 
-        it 'should apply the exit rule correctly' do
+        it 'applies the exit rule correctly' do
           # Filling manually first entry set...
           fill_first_set
 
@@ -207,56 +207,56 @@ SNIPPET
 
           # Given that the scanned token is 'b'...
           # Then a new entry is added in next entry set
-          expect(subject.chart[1].size).to eq(1)
-          last_entry = subject.chart[1].last
+          expect(parsing.chart[1].size).to eq(1)
+          last_entry = parsing.chart[1].last
 
           # Entry must be past the terminal symbol
           expect(last_entry.vertex.label).to eq('A => b .')
           expect(last_entry.origin).to eq(0)
 
           # Apply exit rule...
-          subject.exit_rule(last_entry, 1)
-          expect(subject.chart[1].size).to eq(2)
-          exit_entry = subject.chart[1].last
+          parsing.exit_rule(last_entry, 1)
+          expect(parsing.chart[1].size).to eq(2)
+          exit_entry = parsing.chart[1].last
           expect(exit_entry.vertex.label).to eq('A.')
           expect(exit_entry.origin).to eq(0)
-          expect(subject.antecedence.fetch(exit_entry)).to eq([last_entry])
+          expect(parsing.antecedence.fetch(exit_entry)).to eq([last_entry])
         end
 
-        it 'should apply the end rule correctly' do
+        it 'applies the end rule correctly' do
           # Filling manually first entry set...
           fill_first_set
 
           # Initial manually first entry set...
           seed_second_set
-          last_entry = subject.chart[1].last
+          last_entry = parsing.chart[1].last
 
           # Given that the scanned token is 'b'...
           # New entry must be past the terminal symbol
           expect(last_entry.vertex.label).to eq('A => b .')
 
           # Apply exit rule...
-          subject.exit_rule(last_entry, 1)
-          expect(subject.chart[1].size).to eq(2)
-          exit_entry = subject.chart[1].last
+          parsing.exit_rule(last_entry, 1)
+          expect(parsing.chart[1].size).to eq(2)
+          exit_entry = parsing.chart[1].last
           expect(exit_entry.vertex.label).to eq('A.')
 
           # ... Now the end rule
-          subject.end_rule(subject.chart[1].last, 1)
-          expect(subject.chart[1].size).to eq(3)
-          end_entry = subject.chart[1].last
+          parsing.end_rule(parsing.chart[1].last, 1)
+          expect(parsing.chart[1].size).to eq(3)
+          end_entry = parsing.chart[1].last
           expect(end_entry.vertex.label).to eq('S => A .')
           expect(end_entry.origin).to eq(0)
-          expect(subject.antecedence.fetch(end_entry)).to eq([exit_entry])
+          expect(parsing.antecedence.fetch(end_entry)).to eq([exit_entry])
         end
 
 =begin
-        it 'should retrieve the parse states that expect a given terminal' do
+        it 'retrieves the parse states that expect a given terminal' do
           item1 = DottedItem.new(prod_A1, 2)
           item2 = DottedItem.new(prod_A1, 1)
-          subject.push_state(item1, 2, 2, :scanning)
-          subject.push_state(item2, 2, 2, :scanning)
-          states = subject.states_expecting(c_, 2, false)
+          parsing.push_state(item1, 2, 2, :scanning)
+          parsing.push_state(item2, 2, 2, :scanning)
+          states = parsing.states_expecting(c_, 2, false)
           expect(states.size).to eq(1)
           expect(states[0].dotted_rule).to eq(item1)
         end
@@ -264,17 +264,17 @@ SNIPPET
         it 'should update the states upon token match' do
           # When a input token matches an expected terminal symbol
           # then new parse states must be pushed to the following chart slot
-          expect(subject.chart[1]).to be_empty
+          expect(parsing.chart[1]).to be_empty
 
           item1 = DottedItem.new(prod_A1, 0)
           item2 = DottedItem.new(prod_A2, 0)
-          subject.push_state(item1, 0, 0, :completion)
-          subject.push_state(item2, 0, 0, :completion)
-          subject.scanning(a_, 0) { |i| i } # Code block is mock
+          parsing.push_state(item1, 0, 0, :completion)
+          parsing.push_state(item2, 0, 0, :completion)
+          parsing.scanning(a_, 0) { |i| i } # Code block is mock
 
           # Expected side effect: a new state at chart[1]
-          expect(subject.chart[1].size).to eq(1)
-          new_state = subject.chart[1].states[0]
+          expect(parsing.chart[1].size).to eq(1)
+          new_state = parsing.chart[1].states[0]
           expect(new_state.dotted_rule).to eq(item1)
           expect(new_state.origin).to eq(0)
         end
@@ -282,6 +282,12 @@ SNIPPET
       end # context
 
       context 'Provided services:' do
+        subject(:parsing) do
+          parser = GFGEarleyParser.new(b_expr_grammar)
+          tokens = expr_tokenizer('2 + 3 * 4')
+          parser.parse(tokens)
+        end
+
         let(:b_expr_grammar) do
           builder = grammar_expr_builder
           builder.grammar
@@ -291,14 +297,10 @@ SNIPPET
           b_expr_grammar.name2symbol[aSymbolName]
         end
 
-        subject do
-          parser = GFGEarleyParser.new(b_expr_grammar)
-          tokens = expr_tokenizer('2 + 3 * 4')
-          parser.parse(tokens)
-        end
+        # rubocop: disable Lint/BinaryOperatorWithIdenticalOperands
 
-        it 'should give a text representation of itself' do
-          repr = subject.to_s
+        it 'gives a text representation of itself' do
+          repr = parsing.to_s
           expect(repr).to match(/^success\? true/)
 
           # Let's test the last chart state only
@@ -315,11 +317,18 @@ State[5]
   S => S . + M | 0
   P. | 0
 REPR
-          expect(expectation).to eq(expectation)
+          expect(expectation == expectation).to be(true)
         end
+        # rubocop: enable Lint/BinaryOperatorWithIdenticalOperands
       end # context
 
       context 'Parse forest building:' do
+        subject(:parsing) do
+          parser = GFGEarleyParser.new(b_expr_grammar)
+          tokens = expr_tokenizer('3 * 4')
+          parser.parse(tokens)
+        end
+
         let(:b_expr_grammar) do
           builder = grammar_expr_builder
           builder.grammar
@@ -329,14 +338,8 @@ REPR
           b_expr_grammar.name2symbol[aSymbolName]
         end
 
-        subject do
-          parser = GFGEarleyParser.new(b_expr_grammar)
-          tokens = expr_tokenizer('3 * 4')
-          parser.parse(tokens)
-        end
-
-        it 'should indicate whether a parse succeeded' do
-          expect(subject.success?).to be_truthy
+        it 'indicates whether a parse succeeded' do
+          expect(parsing).to be_success
         end
       end # context
     end # describe

data/spec/rley/parser/parse_entry_set_spec.rb

@@ -19,6 +19,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         return Syntax::Production.new(theLHS, theRHSSymbols)
       end
 
+      subject(:a_set) { described_class.new }
+
       let(:t_a) { Rley::Syntax::Terminal.new('a') }
       let(:t_b) { Rley::Syntax::Terminal.new('b') }
       let(:t_c) { Rley::Syntax::Terminal.new('c') }
@@ -39,153 +41,153 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       let(:entry3) { ParseEntry.new(vertex3, 4) }
 
       context 'Initialization:' do
-        it 'should be created without argument' do
-          expect { ParseEntrySet.new }.not_to raise_error
+        it 'is created without argument' do
+          expect { described_class.new }.not_to raise_error
         end
 
-        it 'should be empty after creation' do
-          expect(subject.entries).to be_empty
+        it 'is empty after creation' do
+          expect(a_set.entries).to be_empty
         end
       end # context
 
       context 'Provided services:' do
-        it 'should accept the addition of an entry' do
+        it 'accepts the addition of an entry' do
           # Case: first time entry addition
-          expect(subject.push_entry(entry1)).to eq(entry1)
-          expect(subject).not_to be_empty
+          expect(a_set.push_entry(entry1)).to eq(entry1)
+          expect(a_set).not_to be_empty
 
           # Case: duplicate entry
-          expect(subject.push_entry(entry1)).to eq(entry1)
+          expect(a_set.push_entry(entry1)).to eq(entry1)
 
           # Yet another entry
-          expect(subject.push_entry(entry2)).to eq(entry2)
-          expect(subject.entries).to eq([entry1, entry2])
+          expect(a_set.push_entry(entry2)).to eq(entry2)
+          expect(a_set.entries).to eq([entry1, entry2])
         end
 
-        it 'should retrieve the entry at given position' do
-          subject.push_entry(entry1)
-          subject.push_entry(entry2)
-          expect(subject[0]).to eq(entry1)
-          expect(subject[1]).to eq(entry2)
+        it 'retrieves the entry at given position' do
+          a_set.push_entry(entry1)
+          a_set.push_entry(entry2)
+          expect(a_set[0]).to eq(entry1)
+          expect(a_set[1]).to eq(entry2)
         end
 
-        it 'should list the entries expecting a given terminal' do
+        it 'lists the entries expecting a given terminal' do
           # Case: an entry expecting a terminal
-          subject.push_entry(entry1)
-          expect(subject.entries4term(t_b)).to eq([entry1])
+          a_set.push_entry(entry1)
+          expect(a_set.entries4term(t_b)).to eq([entry1])
 
           # Case: a second entry expecting same terminal
-          subject.push_entry(entry2)
-          expect(subject.entries4term(t_b)).to eq([entry1, entry2])
+          a_set.push_entry(entry2)
+          expect(a_set.entries4term(t_b)).to eq([entry1, entry2])
         end
 
-        it 'should list the expected terminals' do
-          subject.push_entry(entry1)
-          subject.push_entry(entry2)
-          subject.push_entry(entry3)
+        it 'lists the expected terminals' do
+          a_set.push_entry(entry1)
+          a_set.push_entry(entry2)
+          a_set.push_entry(entry3)
 
-          expect(subject.expected_terminals).to eq([t_b])
+          expect(a_set.expected_terminals).to eq([t_b])
         end
 
-        it 'should list the entries expecting a given non-terminal' do
+        it 'lists the entries expecting a given non-terminal' do
           # Case: an entry expecting a non-terminal
-          subject.push_entry(entry3)
-          expect(subject.entries4n_term(nt_rep_c)).to eq([entry3])
+          a_set.push_entry(entry3)
+          expect(a_set.entries4n_term(nt_rep_c)).to eq([entry3])
         end
 
-        it 'should provide human-readable representation of itself' do
+        it 'provides human-readable representation of itself' do
           # Case 1: empty set
           pattern_empty = /^#<Rley::Parser::ParseEntrySet:\d+ @entries=\[\]>$/
-          expect(subject.inspect).to match(pattern_empty)
+          expect(a_set.inspect).to match(pattern_empty)
 
           # Case 2: non-empty set
-          subject.push_entry(entry1)
+          a_set.push_entry(entry1)
           prefix = /^#<Rley::Parser::ParseEntrySet:\d+ @entries=\[#<Rley/
-          expect(subject.inspect).to match(prefix)
+          expect(a_set.inspect).to match(prefix)
           pattern_entry = /ParseEntry:\d+ @vertex=<Rley::GFG::ItemVertex:\d+/
-          expect(subject.inspect).to match(pattern_entry)
+          expect(a_set.inspect).to match(pattern_entry)
           suffix = /=> a \. b b Repetition> @origin=2 @antecedents=\[\]>\]>$/
-          expect(subject.inspect).to match(suffix)
+          expect(a_set.inspect).to match(suffix)
         end
 
 =begin
-        it 'should list of ambiguous states' do
+        it 'lists of ambiguous states' do
           prod1 = double('fake-production1')
           prod2 = double('fake-production2')
-          expect(subject.ambiguities.size).to eq(0)
+          expect(a_set.ambiguities.size).to eq(0)
 
           # Adding states
-          subject.push_entry(entry1)
+          a_set.push_entry(entry1)
           expect(vertex1).to receive(:production).and_return(prod1)
           expect(vertex1).to receive(:"reduce_item?").and_return(true)
           expect(vertex1).to receive(:lhs).and_return(:something)
-          expect(subject.ambiguities.size).to eq(0)
+          expect(a_set.ambiguities.size).to eq(0)
           expect(vertex2).to receive(:production).and_return(prod2)
           expect(vertex2).to receive(:"reduce_item?").and_return(true)
           expect(vertex2).to receive(:lhs).and_return(:something_else)
-          subject.push_entry(entry2)
-          expect(subject.ambiguities.size).to eq(0)
+          a_set.push_entry(entry2)
+          expect(a_set.ambiguities.size).to eq(0)
           # dotted_rule3 = double('fake_dotted_rule3')
           # expect(dotted_rule3).to receive(:production).and_return(prod2)
           # expect(dotted_rule3).to receive(:"reduce_item?").and_return(true)
           # expect(dotted_rule3).to receive(:lhs).and_return(:something_else)
           # entry3 = ParseEntry.new(dotted_rule3, 5)
-          subject.push_entry(entry3)
-          expect(subject.ambiguities[0]).to eq([entry2, entry3])
+          a_set.push_entry(entry3)
+          expect(a_set.ambiguities[0]).to eq([entry2, entry3])
         end
 =end
 =begin
-        it 'should list the states expecting a given terminal' do
+        it 'lists the states expecting a given terminal' do
           # Case of no state
-          expect(subject.states_expecting(:a)).to be_empty
+          expect(a_set.states_expecting(:a)).to be_empty
 
           # Adding states
-          subject.push_entry(entry1)
-          subject.push_entry(entry2)
+          a_set.push_entry(entry1)
+          a_set.push_entry(entry2)
           expect(vertex1).to receive(:next_symbol).and_return(:b)
           expect(vertex2).to receive(:next_symbol).and_return(:a)
-          expect(subject.states_expecting(:a)).to eq([entry2])
-          expect(subject.states_expecting(:b)).to eq([entry1])
+          expect(a_set.states_expecting(:a)).to eq([entry2])
+          expect(a_set.states_expecting(:b)).to eq([entry1])
         end
 
-        it 'should list the states related to a production' do
+        it 'lists the states related to a production' do
           a_prod = double('fake-production')
 
           # Case of no state
-          expect(subject.states_for(a_prod)).to be_empty
+          expect(a_set.states_for(a_prod)).to be_empty
 
           # Adding states
-          subject.push_entry(entry1)
-          subject.push_entry(entry2)
+          a_set.push_entry(entry1)
+          a_set.push_entry(entry2)
           expect(vertex1).to receive(:production).and_return(:dummy)
           expect(vertex2).to receive(:production).and_return(a_prod)
-          expect(subject.states_for(a_prod)).to eq([entry2])
+          expect(a_set.states_for(a_prod)).to eq([entry2])
         end
 
-        it 'should list the states that rewrite a given non-terminal' do
+        it 'lists the states that rewrite a given non-terminal' do
           non_term = double('fake-non-terminal')
           prod1 = double('fake-production1')
           prod2 = double('fake-production2')
 
           # Adding states
-          subject.push_entry(entry1)
-          subject.push_entry(entry2)
+          a_set.push_entry(entry1)
+          a_set.push_entry(entry2)
           expect(vertex1).to receive(:production).and_return(prod1)
           expect(prod1).to receive(:lhs).and_return(:dummy)
           expect(vertex2).to receive(:production).and_return(prod2)
           expect(vertex2).to receive(:reduce_item?).and_return(true)
           expect(prod2).to receive(:lhs).and_return(non_term)
-          expect(subject.states_rewriting(non_term)).to eq([entry2])
+          expect(a_set.states_rewriting(non_term)).to eq([entry2])
         end
 
 
 
-        it 'should complain when impossible predecessor of parse state' do
-          subject.push_entry(entry1)
-          subject.push_entry(entry2)
+        it 'complains when impossible predecessor of parse state' do
+          a_set.push_entry(entry1)
+          a_set.push_entry(entry2)
           expect(vertex1).to receive(:prev_position).and_return(nil)
           err = StandardError
-          expect { subject.predecessor_state(entry1) }.to raise_error(err)
+          expect { a_set.predecessor_state(entry1) }.to raise_error(err)
         end
 =end
       end # context