mini_kraken 0.2.04 → 0.3.00

data/spec/core/association_copy_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../support/factory_atomic'
+require_relative '../../lib/mini_kraken/core/context'
+require_relative '../../lib/mini_kraken/core/log_var'
+require_relative '../../lib/mini_kraken/core/log_var_ref'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/association_copy'
+
+module MiniKraken
+  module Core
+    describe AssociationCopy do
+      include MiniKraken::FactoryAtomic # Use mix-in module
+
+      let(:pea) { k_symbol(:pea) }
+      let(:q_assoc) { Association.new('q', pea) }
+      subject { AssociationCopy.new('q_x', q_assoc) }
+
+      context 'Initialization:' do
+        it 'should be initialized with a name and an association' do
+          expect { AssociationCopy.new('q_x', q_assoc) }.not_to raise_error
+        end
+
+        it 'should be initialized with a variable and an association' do
+          q_x_var = LogVar.new('q_x')
+          expect { AssociationCopy.new(q_x_var, q_assoc) }.not_to raise_error
+        end
+
+        it 'should know the internal variable name' do
+          expect(subject.i_name).to eq('q_x')
+        end
+
+        it 'should know the associated value' do
+          expect(subject.value).to eq(pea)
+        end
+      end # context
+
+      context 'Provided services:' do
+        let(:ctx) { Context.new }
+
+        it 'should tell whether the associated value is pinned' do
+          ctx.add_vars(%w[q x q_x])
+          expect(subject).to be_pinned(ctx)
+
+          a = Association.new(ctx.lookup('q'), LogVarRef.new('x'))
+          instance = AssociationCopy.new(ctx.lookup('q_x'), a)
+          expect(instance).not_to be_pinned(ctx)
+        end
+
+        it 'should tell whether the associated value is floating' do
+          ctx.add_vars(%w[q x q_x])
+
+          expect(subject).not_to be_floating(ctx)
+        end
+
+        it 'should retrieve the dependencies in its value' do
+          expect(subject.dependencies(ctx)).to be_empty
+
+          ctx.add_vars(%w[q x q_x])
+          a = Association.new(ctx.lookup('q'), LogVarRef.new('x'))
+          instance = AssociationCopy.new(ctx.lookup('q_x'), a)
+          expect(instance.dependencies(ctx).size).to eq(1)
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/association_spec.rb

@@ -2,7 +2,9 @@
 
 require_relative '../spec_helper' # Use the RSpec framework
 require_relative '../support/factory_atomic'
+require_relative '../../lib/mini_kraken/core/context'
 require_relative '../../lib/mini_kraken/core/log_var'
+require_relative '../../lib/mini_kraken/core/log_var_ref'
 
 # Load the class under test
 require_relative '../../lib/mini_kraken/core/association'
@@ -34,6 +36,29 @@ module MiniKraken
       end # context
 
       context 'Provided services:' do
+        let(:ctx) { Context.new }
+
+        it 'should tell whether the associated value is pinned' do
+          ctx.add_vars(%w[q x])
+
+          expect(subject).to be_pinned(ctx)
+          instance = Association.new(ctx.lookup('q'), LogVarRef.new('x'))
+          expect(instance).not_to be_pinned(ctx)
+        end
+
+        it 'should tell whether the associated value is floating' do
+          ctx.add_vars(%w[q x])
+
+          expect(subject).not_to be_floating(ctx)
+        end
+
+        it 'should retrieve the dependencies in its value' do
+          expect(subject.dependencies(ctx)).to be_empty
+
+          ctx.add_vars(%w[q x])
+          instance = Association.new(ctx.lookup('q'), LogVarRef.new('x'))
+          expect(instance.dependencies(ctx).size).to eq(1)
+        end
       end # context
     end # describe
   end # module

data/spec/core/blackboard_spec.rb

@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../support/factory_atomic'
+require_relative '../../lib/mini_kraken/core/log_var_ref'
+require_relative '../../lib/mini_kraken/core/scope'
+require_relative '../../lib/mini_kraken/composite/cons_cell'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/blackboard'
+
+module MiniKraken
+  module Core
+    describe Blackboard do
+      include MiniKraken::FactoryAtomic # Use mix-in module
+      subject { Blackboard.new }
+
+      context 'Initialization:' do
+        it 'should be initialized without argument' do
+          expect { Blackboard.new }.not_to raise_error
+        end
+
+        it "shouldn't have internal name entry at initialization" do
+          expect(subject.i_name2moves).to be_empty
+        end
+
+        it 'should have an empty association queue at initialization' do
+          expect(subject.move_queue).to be_empty
+        end
+
+        it 'should be empty at initialization' do
+          expect(subject).to be_empty
+        end
+
+        it 'should be ready to assign a serial number' do
+          expect(subject.next_serial_num).to be_zero
+        end
+
+        it 'should have its resultant attribute un-initialized' do
+          expect(subject.resultant).to be_nil
+        end
+      end # context
+
+      context 'Provided services:' do
+        let(:a_ser_num) { 42 }
+        let(:pea) { k_symbol(:pea) }
+        let(:pod) { k_symbol(:pod) }
+        let(:x_assoc) { Core::Association.new('x', pea) }
+        let(:y_assoc) { Core::Association.new('y', pod) }
+        let(:z_assoc) { Core::Association.new('z', pea) }
+
+        def var_ref(aName)
+          LogVarRef.new(aName)
+        end
+
+        def cons(car, cdr = nil)
+          Composite::ConsCell.new(car, cdr)
+        end
+
+        it 'should allow the enqueuing of one association' do
+          expect { subject.enqueue_association(x_assoc) }.not_to raise_error
+          expect(subject.i_name2moves).not_to be_empty
+          expect(subject.move_queue).not_to be_empty
+          expect(subject.i_name2moves['x']).to be_kind_of(Array)
+          expect(subject.i_name2moves['x'].first).to eq(0)
+          expect(subject.last_move).to eq(x_assoc)
+        end
+
+        it 'should allow the enqueuing of multiple associations' do
+          expect(subject.enqueue_association(x_assoc)).to eq(x_assoc)
+          expect { subject.enqueue_association(y_assoc) }.not_to raise_error
+          expect(subject.i_name2moves.size).to eq(2)
+          expect(subject.move_queue.size).to eq(2)
+          expect(subject.i_name2moves['y']).to be_kind_of(Array)
+          expect(subject.i_name2moves['y'].first).to eq(1)
+          expect(subject.last_move).to eq(y_assoc)
+        end
+
+        it 'should allow the enqueuing of multiple associations for same i_name' do
+          subject.enqueue_association(x_assoc)
+
+          x_assoc_b = Core::Association.new('x', double('something'))
+          expect { subject.enqueue_association(x_assoc_b) }.not_to raise_error
+          expect(subject.i_name2moves.size).to eq(1)
+          expect(subject.move_queue.size).to eq(2)
+          expect(subject.i_name2moves['x']).to be_kind_of(Array)
+          expect(subject.i_name2moves['x'].size).to eq(2)
+          expect(subject.i_name2moves['x'].last).to eq(1)
+          expect(subject.move_queue.pop).to eq(x_assoc_b)
+        end
+
+        it 'should allow the removal of the association at TOS position' do
+          subject.enqueue_association(x_assoc)
+          x_assoc_b = Core::Association.new('x', double('something'))
+          subject.enqueue_association(x_assoc_b)
+          expect(subject.move_queue.size).to eq(2)
+          expect(subject.i_name2moves.size).to eq(1)
+
+          expect { subject.send(:dequeue_item) }.not_to raise_error
+          expect(subject.move_queue.size).to eq(1)
+          expect(subject.i_name2moves.size).to eq(1)
+
+          subject.send(:dequeue_item)
+          expect(subject.move_queue).to be_empty
+          expect(subject.i_name2moves).to be_empty
+        end
+
+        it 'should allow the enqueuing of a backtrack bookmark' do
+          subject.enqueue_association(x_assoc)
+
+          expect { subject.place_bt_point }.not_to raise_error
+          expect(subject.i_name2moves.size).to eq(1)
+          expect(subject.move_queue.size).to eq(2)
+          expect(subject.i_name2moves['x']).to be_kind_of(Array)
+          expect(subject.i_name2moves['x'].size).to eq(1)
+          expect(subject.last_move).to be_kind_of(Bookmark)
+        end
+
+        it 'should allow the enqueuing of a scope bookmark' do
+          subject.enqueue_association(x_assoc)
+
+          expect { subject.enter_scope }.not_to raise_error
+          expect(subject.i_name2moves.size).to eq(1)
+          expect(subject.move_queue.size).to eq(2)
+          expect(subject.i_name2moves['x']).to be_kind_of(Array)
+          expect(subject.i_name2moves['x'].size).to eq(1)
+          expect(subject.last_move).to be_kind_of(Bookmark)
+        end
+
+        it 'should allow the fusion of two unbound variables' do
+          q_var = LogVar.new('q')
+          x_var = LogVar.new('x')
+          q_x_var = LogVar.new('q_x')
+          fusion = Fusion.new(q_x_var.i_name, [q_var.i_name, x_var.i_name])
+          pre_size = subject.move_queue.size
+          subject.enqueue_fusion(fusion)
+
+          expect(subject.move_queue.size).to eq(pre_size + 1)
+          expect(subject.i_name2moves).to be_include(q_x_var.i_name)
+          expect(subject.vars2cv[q_var.i_name]).to eq(q_x_var.i_name)
+          expect(subject.vars2cv[x_var.i_name]).to eq(q_x_var.i_name)
+        end
+
+        it 'should allow the fusion of one unbound and one floating variable' do
+          q_var = LogVar.new('q')
+          x_var = LogVar.new('x')
+          assoc_x = Association.new('x', cons(LogVarRef.new('y'), pea))
+          subject.enqueue_association(assoc_x)
+          q_x_var = LogVar.new('q_x')
+          fusion = Fusion.new(q_x_var.i_name, [q_var.i_name, x_var.i_name])
+          pre_size = subject.move_queue.size
+
+          subject.enqueue_fusion(fusion)
+          expect(subject.move_queue.size).to eq(pre_size + 2)
+          expect(subject.i_name2moves).to be_include(q_x_var.i_name)
+          indices = subject.i_name2moves[q_x_var.i_name]
+          expect(indices.size).to eq(2) # 2 = 1 Fusion + 1 AssocCopy
+          new_assoc = subject.move_queue[indices.last]
+          expect(new_assoc.value).to eq(assoc_x.value)
+        end
+
+        it 'should allow the fusion of two floating variables' do
+          q_var = LogVar.new('q')
+          x_var = LogVar.new('x')
+          assoc_q = Association.new('x', cons(pod, var_ref('z')))
+          subject.enqueue_association(assoc_q)
+          assoc_x = Association.new('x', cons(var_ref('y'), pea))
+          subject.enqueue_association(assoc_x)
+          q_x_var = LogVar.new('q_x')
+          fusion = Fusion.new(q_x_var.i_name, [q_var.i_name, x_var.i_name])
+          pre_size = subject.move_queue.size
+
+          subject.enqueue_fusion(fusion)
+          expect(subject.move_queue.size).to eq(pre_size + 3)
+          expect(subject.i_name2moves).to be_include(q_x_var.i_name)
+          indices = subject.i_name2moves[q_x_var.i_name]
+          expect(indices.size).to eq(3)
+          new_move1 = subject.move_queue[indices[0]]
+          expect(new_move1).to be_kind_of(Core::Fusion)
+          new_move2 = subject.move_queue[indices[1]]
+          expect(new_move2.value).to eq(assoc_q.value)
+          new_move3 = subject.move_queue[indices[2]]
+          expect(new_move3.value).to eq(assoc_x.value)
+        end
+
+        it 'should allow the removal of a fusion object at TOS position' do
+          q_var = LogVar.new('q')
+          x_var = LogVar.new('x')
+          q_x_var = LogVar.new('q_x')
+          fusion = Fusion.new(q_x_var.i_name, [q_var.i_name, x_var.i_name])
+          pre_size = subject.move_queue.size
+          subject.enqueue_fusion(fusion)
+
+          expect(subject.move_queue.size).to eq(pre_size + 1)
+          expect(subject.i_name2moves).to be_include(q_x_var.i_name)
+          expect(subject.vars2cv[q_var.i_name]).to eq(q_x_var.i_name)
+          expect(subject.vars2cv[x_var.i_name]).to eq(q_x_var.i_name)
+
+          expect { subject.send(:dequeue_item) }.not_to raise_error
+          expect(subject.move_queue.size).to eq(pre_size)
+          expect(subject.i_name2moves).not_to be_include(q_x_var.i_name)
+          expect(subject.vars2cv[q_var.i_name]).to be_nil
+          expect(subject.vars2cv[x_var.i_name]).to be_nil
+        end
+
+        it 'should retrieve association for a given i_name (0 fusion)' do
+          subject.enqueue_association(x_assoc)
+          subject.enqueue_association(y_assoc)
+
+          x_assoc_b = Core::Association.new('x', double('something'))
+          subject.enqueue_association(x_assoc_b)
+          expect(subject.associations_for('z')).to be_empty
+          expect(subject.associations_for('y').size).to eq(1)
+          expect(subject.associations_for('x').size).to eq(2)
+          expect(subject.associations_for('x').last).to eq(x_assoc_b)
+        end
+
+        it 'should retrieve association for a given i_name (1 fusion)' do
+          subject.enqueue_association(x_assoc)
+          expect(subject.associations_for('x').size).to eq(1)
+          expect(subject.associations_for('z').size).to eq(0)
+          expect(subject.associations_for('z', true).size).to eq(0)
+
+          x_z_var = LogVar.new('x_z')
+          fusion = Fusion.new(x_z_var.i_name, %w[x z])
+          subject.enqueue_fusion(fusion)
+          expect(subject.associations_for('z', true).size).to eq(1)
+          x_z_assoc = Core::Association.new(x_z_var.i_name, var_ref('y'))
+          subject.enqueue_association(x_z_assoc)
+          expect(subject.associations_for('z', false).size).to eq(0)
+          expect(subject.associations_for('z', true).size).to eq(2)
+          expect(subject.associations_for('x', false).size).to eq(1)
+          expect(subject.associations_for('x', true).size).to eq(2)
+        end
+
+        it 'should accept the succeeded notification' do
+          subject.enqueue_association(x_assoc)
+          subject.enqueue_association(y_assoc)
+          subject.succeeded!
+          expect(subject).to be_success
+          expect(subject.move_queue.size).to eq(2)
+        end
+
+        it 'should accept the failed notification in absence of bookmarks' do
+          subject.enqueue_association(x_assoc)
+          subject.enqueue_association(y_assoc)
+          subject.failed!
+          expect(subject).to be_failure
+          expect(subject.move_queue).to be_empty
+          expect(subject.i_name2moves).to be_empty
+        end
+
+        it 'should accept the failed notification with backtrack' do
+          x_assoc2 = Core::Association.new('x', pea)
+
+          subject.enqueue_association(x_assoc)
+          subject.enqueue_association(y_assoc)
+          subject.place_bt_point
+          subject.enqueue_association(z_assoc)
+          subject.enqueue_association(x_assoc2)
+          expect(subject.i_name2moves['x'].size).to eq(2)
+
+          subject.failed!
+          expect(subject.resultant).to eq(:"#u")
+          expect(subject.last_move).to be_kind_of(Core::Bookmark)
+          expect(subject.i_name2moves.include?('z')).to be_falsey
+          expect(subject.i_name2moves['x'].size).to eq(1)
+        end
+
+        it 'should accept the failed notification on a bookmark' do
+          subject.enqueue_association(x_assoc)
+          subject.enqueue_association(y_assoc)
+          subject.place_bt_point # Backtrack point bookmark added...
+
+          subject.enqueue_association(z_assoc)
+          subject.enter_scope # Scope bookmark
+
+          expect(subject.move_queue.size).to eq(5)
+
+          subject.failed!
+          expect(subject.resultant).to eq(:"#u")
+          expect(subject.move_queue.size).to eq(3) # 3 = 2 assocs + 1 bookmark
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/bookmark_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/bookmark'
+
+module MiniKraken
+  module Core
+    describe Bookmark do
+      let(:one_ser_num) { 42 }
+      let(:a_kind) { :scope }
+      subject { Bookmark.new(a_kind, one_ser_num) }
+
+      context 'Initialization:' do
+        it 'should be initialized with a Symbol and an Integer' do
+          expect { Bookmark.new(a_kind, one_ser_num) }.not_to raise_error
+        end
+
+        it 'should know its kind' do
+          expect(subject.kind).to eq(a_kind)
+        end
+
+        it 'should know its serial number' do
+          expect(subject.ser_num).to eq(one_ser_num)
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should compare to another instance' do
+          same = Bookmark.new(a_kind, one_ser_num)
+          expect(subject).to eq(same)
+
+          distinct = Bookmark.new(a_kind, 3)
+          expect(subject).not_to eq(distinct)
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/core/context_spec.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/mini_kraken/core/association'
+require_relative '../../lib/mini_kraken/core/log_var'
+require_relative '../../lib/mini_kraken/composite/all_composite'
+
+require_relative '../support/factory_atomic'
+require_relative '../support/factory_methods'
+
+# Load the class under test
+require_relative '../../lib/mini_kraken/core/context'
+
+module MiniKraken
+  module Core
+    describe Context do
+      include MiniKraken::FactoryAtomic # Use mix-in module
+      subject { Context.new }
+
+      context 'Initialization:' do
+        it 'should be initialized without argument' do
+          expect { Context.new }.not_to raise_error
+        end
+
+        it 'should have an empty symbol table' do
+          expect(subject.symbol_table).to be_empty
+        end
+
+        it 'should have an empty blackboard' do
+          expect(subject.blackboard).to be_empty
+        end
+      end # context
+
+      context 'Initialization:' do
+        def var(aName)
+          LogVar.new(aName)
+        end
+
+        it 'should accept the addition of an entry in symbol table' do
+          subject.insert(var('x'))
+          expect(subject.symbol_table).not_to be_empty
+          expect(subject.symbol_table.current_scope.defns['x']).to be_kind_of(LogVar)
+        end
+
+        it 'should create one or more variables from name(s)' do
+          # Case: single name
+          subject.add_vars('x')
+          expect(subject.symbol_table).not_to be_empty
+          expect(subject.symbol_table.current_scope.defns['x']).to be_kind_of(LogVar)
+
+          # Case: multiple names
+          subject.add_vars(%w[y z])
+          expect(subject.symbol_table.current_scope.defns['y']).to be_kind_of(LogVar)
+          expect(subject.symbol_table.current_scope.defns['z']).to be_kind_of(LogVar)
+        end
+
+        it 'should accept the addition of an association to a given i_name' do
+          i_name_x = subject.insert(var('x'))
+          i_name_y = subject.insert(var('y'))
+
+          expect(subject.associations_for('x')).to be_empty
+          something = double('something')
+          assoc_x = subject.associate('x', something)
+          expect(subject.associations_for('x')).to eq([assoc_x])
+
+          thing = double('thing')
+          assoc_y = Association.new(i_name_y, thing)
+          subject.enqueue_association(assoc_y)
+          expect(subject.associations_for('y')).to eq([assoc_y])
+
+          blob = double('blob')
+          assoc2_x = Association.new(i_name_x, blob)
+          subject.enqueue_association(assoc2_x)
+          expect(subject.associations_for('x')).to eq([assoc_x, assoc2_x])
+
+          var_y = subject.lookup('y')
+          foo = double('bar')
+          assoc2_y = subject.associate(var_y, foo)
+          expect(subject.associations_for('y')).to eq([assoc_y, assoc2_y])
+        end
+
+        it 'should allow the fusion of two variables' do
+          symb_tbl = subject.symbol_table
+          i_name_q = subject.insert(var('q'))
+          symb_tbl.enter_scope(Core::Scope.new)
+          i_name_x = subject.insert(var('x'))
+
+          expect(subject.associations_for('q')).to be_empty
+          something = double('something')
+          assoc_x = subject.associate('x', something)
+          expect(subject.associations_for('x')).to eq([assoc_x])
+          pre_queue_size = subject.blackboard.move_queue.size
+          fusion = subject.fuse(%w[q x])
+
+          expect(fusion).to be_kind_of(Fusion)
+          expect(fusion.elements).to eq(%w[q x].map { |e| subject.lookup(e).i_name })
+          expect(subject.blackboard.move_queue.size).to eq(pre_queue_size + 2)
+          expect(subject.cv2vars).to be_include(fusion.i_name)
+          expect(subject.cv2vars[fusion.i_name]).to eq(fusion.elements)
+          expect(subject.blackboard.vars2cv[i_name_q]).to eq(fusion.i_name)
+          expect(subject.blackboard.vars2cv[i_name_x]).to eq(fusion.i_name)
+          expect(subject.associations_for('q')).not_to be_empty
+        end
+
+        it 'should allow the search of an entry based on its name' do
+          symb_tbl = subject.symbol_table
+          subject.add_vars(%w[q x])
+          symb_tbl.enter_scope(Core::Scope.new)
+          subject.add_vars(%w[q y])
+
+          # Search for unknown name
+          expect(subject.lookup('z')).to be_nil
+
+          # Search for existing unique names
+          expect(subject.lookup('y')).to eq(symb_tbl.current_scope.defns['y'])
+          expect(subject.lookup('x')).to eq(symb_tbl.root.defns['x'])
+
+          # Search for redefined name
+          expect(subject.lookup('q')).to eq(symb_tbl.current_scope.defns['q'])
+        end
+
+        it 'should determine the ranks of fresh variables' do
+          subject.add_vars(%w[x y z])
+
+          ref_y = LogVarRef.new('y')
+          subject.associate('x', ref_y)
+          subject.send(:calc_ranking)
+          expect(subject.ranking.size).to eq(2)
+          i_name_y = subject.lookup('y').i_name
+          expect(subject.ranking[i_name_y]).to eq(0)
+          i_name_z = subject.lookup('z').i_name
+          expect(subject.ranking[i_name_z]).to eq(1)
+        end
+
+        it 'should allow entering in a new scope' do
+          new_scope = Scope.new
+          expect { subject.enter_scope(new_scope) }.not_to raise_error
+          expect(subject.symbol_table.current_scope).to eq(new_scope)
+        end
+
+        it 'should allow leaving out current scope' do
+          subject.add_vars(%w[q x])
+          x_val = k_symbol(:foo)
+          assoc_x = subject.associate('x', x_val) # x => :foo
+          expect(subject.blackboard.move_queue.size).to eq(1)
+          new_scope = Scope.new
+          subject.enter_scope(new_scope) # Adds one bookmark
+          expect(subject.blackboard.move_queue.size).to eq(2)
+          subject.add_vars(%w[w x y z])
+
+          q_val = LogVarRef.new('x')
+          assoc_q = subject.associate('q', q_val)
+          w_val = k_symbol(:bar)
+          subject.associate('w', w_val)
+          x2_val = LogVarRef.new('z')
+          assoc2_x = subject.associate('x', x2_val)
+          y_val = k_symbol(:foobar)
+          subject.associate('y', y_val)
+          # x => :foo
+          # ------
+          # q => x
+          # w => :bar
+          # x => z
+          # y => :foobar
+          expect(subject.blackboard.i_name2moves.keys.size).to eq(5)
+          expect(subject.blackboard.move_queue.size).to eq(6)
+          # require 'debug'
+          expect { subject.leave_scope }.not_to raise_error
+          # Expected state:
+          # x => :foo
+          # q => x'
+          # x' => z
+          expect(subject.blackboard.move_queue.size).to eq(3)
+          symb_table = subject.symbol_table
+          expect(symb_table.current_scope).to eq(symb_table.root)
+          expect(subject.blackboard.i_name2moves.keys.size).to eq(3)
+          expect(subject.blackboard.move_queue).to eq([assoc_x, assoc_q, assoc2_x])
+        end
+
+        it 'should substitute values of associations (if needed)' do
+          subject.add_vars(%w[q x y z])
+
+          x_ref = LogVarRef.new('x')
+          foobar = Composite::ConsCell.new(k_symbol(:foo), k_symbol(:bar))
+          q_val = Composite::ConsCell.new(x_ref, foobar)
+          assoc_q = subject.associate('q', q_val)
+          subject.send(:calc_ranking)
+
+          expect(subject.send(:substitute, assoc_q).to_s).to eq('(_0 :foo . :bar)')
+        end
+
+        it 'should build a solution' do
+          subject.add_vars(%w[x y z])
+
+          subject.succeeded!
+          sol = subject.build_solution
+          expect(sol.size).to eq(3)
+          expect(sol['x']).to eq(:_0)
+          expect(sol['y']).to eq(:_1)
+          expect(sol['z']).to eq(:_2)
+
+          foo = k_symbol(:foo)
+          subject.associate('x', foo)
+          sol = subject.build_solution
+          expect(sol.size).to eq(3)
+          expect(sol['x']).to eq(foo)
+          expect(sol['y']).to eq(:_0)
+          expect(sol['z']).to eq(:_1)
+
+          bar = k_symbol(:bar)
+          subject.associate('y', bar)
+          sol = subject.build_solution
+          expect(sol.size).to eq(3)
+          expect(sol['x']).to eq(foo)
+          expect(sol['y']).to eq(bar)
+          expect(sol['z']).to eq(:_0)
+        end
+      end
+    end # describe
+  end # module
+end # module