porolog 0.0.4 → 1.0.0

data/test/porolog/porolog_test.rb

@@ -13,13 +13,38 @@ describe 'Porolog' do
     reset
   end
   
+  describe 'UNKNOWN_TAIL' do
+    
+    describe '#inspect' do
+      
+      it 'should return distinctive notation' do
+        assert_equal      '...',            UNKNOWN_TAIL.inspect
+      end
+      
+    end
+    
+    describe '#tail' do
+      
+      it 'should return itself' do
+        assert_equal      UNKNOWN_TAIL,     UNKNOWN_TAIL.tail
+        assert_equal      UNKNOWN_TAIL,     UNKNOWN_TAIL.tail(1)
+        assert_equal      UNKNOWN_TAIL,     UNKNOWN_TAIL.tail(5)
+      end
+      
+    end
+    
+  end
+  
   describe '#predicate' do
     
     it 'should create a Predicate' do
-      assert_equal    0,        Scope[:default].predicates.size
+      # -- Precondition Baseline --
+      assert_equal      0,                Scope[:default].predicates.size
       
+      # -- Test --
       single_predicate = predicate :single
       
+      # -- Compare Result Against Baseline --
       assert_equal      1,                Scope[:default].predicates.size
       assert_equal      :single,          Scope[:default].predicates.first.name
       assert_Predicate  single_predicate, :single, []
@@ -31,23 +56,23 @@ describe 'Porolog' do
       predicate :delta
       
       assert                    respond_to?(:delta)
-      assert_Arguments          delta(1, :X, ['left','right']), :delta, [1, :X, ['left','right']]
+      assert_Arguments          delta(1, :X, ['left','right']),   :delta, [1, :X, ['left','right']]
     end
     
     it 'should create multiple Predicates' do
-      assert_equal    0,        Scope[:default].predicates.size
+      assert_equal              0,        Scope[:default].predicates.size
       
       multiple_predicates = predicate :alpha, :beta, :gamma
       
-      assert_equal          3,        Scope[:default].predicates.size
-      assert_equal          :alpha,   Scope[:default].predicates[0].name
-      assert_equal          :beta,    Scope[:default].predicates[1].name
-      assert_equal          :gamma,   Scope[:default].predicates[2].name
-      assert_instance_of    Array,    multiple_predicates
-      assert_equal          3,        multiple_predicates.size
-      assert_Predicate      multiple_predicates[0], :alpha, []
-      assert_Predicate      multiple_predicates[1], :beta,  []
-      assert_Predicate      multiple_predicates[2], :gamma, []
+      assert_equal              3,        Scope[:default].predicates.size
+      assert_equal              :alpha,   Scope[:default].predicates[0].name
+      assert_equal              :beta,    Scope[:default].predicates[1].name
+      assert_equal              :gamma,   Scope[:default].predicates[2].name
+      assert_instance_of        Array,    multiple_predicates
+      assert_equal              3,        multiple_predicates.size
+      assert_Predicate          multiple_predicates[0], :alpha, []
+      assert_Predicate          multiple_predicates[1], :beta,  []
+      assert_Predicate          multiple_predicates[2], :gamma, []
     end
     
     it 'should define multiple methods to create Arguments for solving' do
@@ -57,11 +82,2349 @@ describe 'Porolog' do
       predicate :epsilon, :upsilon
       
       assert                    respond_to?(:epsilon)
-      assert_Arguments          epsilon(), :epsilon, []
       assert                    respond_to?(:upsilon)
+      assert_Arguments          epsilon(),   :epsilon, []
       assert_Arguments          upsilon([]), :upsilon, [[]]
     end
     
+    it 'should define a method in a base class as an instance method and a class method' do
+      class Base1 ; end
+      
+      refute_includes   Base1.methods,            :localised_predicate
+      refute_includes   Base1.instance_methods,   :localised_predicate
+      
+      class Base1
+        
+        builtin :between,                 class_base: self
+        predicate :localised_predicate,   class_base: self
+        
+        localised_predicate(:X) << [
+          between(:X, 1, 5)
+        ]
+        
+        def process
+          localised_predicate(:X).solve_for(:X)
+        end
+      end
+      
+      assert_includes   Base1.methods,            :localised_predicate
+      assert_includes   Base1.instance_methods,   :localised_predicate
+      
+      refute_includes   methods,                  :localised_predicate
+      
+      assert_solutions    Base1.localised_predicate(:X),  [
+        { X: 1 },
+        { X: 2 },
+        { X: 3 },
+        { X: 4 },
+        { X: 5 },
+      ]
+      
+      assert_equal    [1,2,3,4,5],    Base1.new.process
+    end
+    
+  end
+  
+  describe '#unify_goals' do
+    
+    it 'should unify goals for the same predicate' do
+      # -- Setup --
+      goal1 = new_goal :p, :m, :n
+      goal2 = new_goal :p, :s, :t
+      
+      # -- Precondition Baseline --
+      assert_Goal_variables   goal1,    { m: nil, n: nil }, [
+        'Goal1.:m',
+        'Goal1.:n',
+      ].join("\n")
+      
+      assert_Goal_variables   goal2,    { s: nil, t: nil }, [
+        'Goal2.:s',
+        'Goal2.:t',
+      ].join("\n")
+      
+      # -- Test --
+      assert  unify_goals(goal1, goal2), name
+      
+      # -- Compare Result Against Baseline --
+      assert_Goal_variables   goal1,    { m: nil, n: nil }, [
+        'Goal1.:m',
+        '  Goal2.:s',
+        'Goal1.:n',
+        '  Goal2.:t',
+      ].join("\n")
+      
+      assert_Goal_variables   goal2,    { s: nil, t: nil }, [
+        'Goal2.:s',
+        '  Goal1.:m',
+        'Goal2.:t',
+        '  Goal1.:n',
+      ].join("\n")
+    end
+    
+    it 'should not unify goals for different predicates' do
+      goal1 = new_goal :p, :x, :y
+      goal2 = new_goal :q, :x, :y
+      
+      refute  unify_goals(goal1, goal2), name
+      
+      assert_equal      ['Cannot unify goals because they are for different predicates: :p and :q'],    goal1.log
+      assert_equal      ['Cannot unify goals because they are for different predicates: :p and :q'],    goal2.log
+    end
+    
+  end
+  
+  describe '#instantiate_unifications' do
+    
+    let(:goal1) { new_goal :p, :x, :y }
+    let(:goal2) { new_goal :q, :i, :j, :k }
+    let(:goal3) { new_goal :r, :n }
+    
+    it 'should precheck inconsistent unifications' do
+      unifications = [
+        [:x, :k, goal1, goal2],
+        [:x, :j, goal1, goal2],
+        [:x, 12, goal1, goal3],
+        [:x, 37, goal1, goal3],
+      ]
+      
+      refute    instantiate_unifications(unifications), name
+    end
+    
+    it 'should create instantiations' do
+      # -- Setup --
+      unifications = [
+        [:x, :k, goal1, goal2],
+        [:x, :j, goal1, goal2],
+        [:x, 12, goal1, goal3],
+      ]
+      
+      # -- Precondition Baseline --
+      assert_Goal_variables     goal1, { x: nil, y: nil }, [
+        'Goal1.:x',
+        'Goal1.:y',
+      ].join("\n")
+      
+      assert_Goal_variables     goal2, { i: nil, j: nil, k: nil }, [
+        'Goal2.:i',
+        'Goal2.:j',
+        'Goal2.:k',
+      ].join("\n")
+      
+      assert_Goal_variables     goal3, { n: nil }, [
+        'Goal3.:n',
+      ].join("\n")
+      
+      # -- Test --
+      assert    instantiate_unifications(unifications), name
+      
+      # -- Compare Result Against Baseline --
+      assert_Goal_variables     goal1, { x: 12, y: nil }, [
+        'Goal1.:x',
+        '  Goal2.:k',
+        '  Goal2.:j',
+        '  Goal3.12',
+        'Goal1.:y',
+      ].join("\n")
+      
+      assert_Goal_variables     goal2, { i: nil, j: 12, k: 12 }, [
+        'Goal2.:i',
+        'Goal2.:j',
+        '  Goal1.:x',
+        '    Goal2.:k',
+        '    Goal3.12',
+        'Goal2.:k',
+        '  Goal1.:x',
+        '    Goal2.:j',
+        '    Goal3.12',
+      ].join("\n")
+      
+      assert_Goal_variables     goal3, { n: nil }, [
+        'Goal3.:n',
+      ].join("\n")
+    end
+    
+    it 'should return false for inconsistent unifications not picked up by the precheck' do
+      #   12
+      #  /
+      # i
+      #  \
+      #   x
+      #  /
+      # j
+      #  \
+      #   y
+      #  /
+      # k
+      #  \
+      #   37
+      unifications = [
+        [:x, :i, goal1, goal2],
+        [:i, 12, goal2, goal3],
+        [:j, :x, goal2, goal1],
+        [:j, :y, goal2, goal1],
+        [:k, :y, goal2, goal1],
+        [:k, 37, goal2, goal3],
+      ]
+      
+      refute    instantiate_unifications(unifications), name
+      
+      assert_Goal_variables     goal1, { x: nil, y: nil }, [
+        'Goal1.:x',
+        'Goal1.:y',
+      ].join("\n")
+      
+      assert_Goal_variables     goal2, { i: nil, j: nil, k: nil }, [
+        'Goal2.:i',
+        'Goal2.:j',
+        'Goal2.:k',
+      ].join("\n")
+      
+      assert_Goal_variables     goal3, { n: nil }, [
+        'Goal3.:n',
+      ].join("\n")
+    end
+    
+  end
+  
+  describe '#unify' do
+    
+    let(:goal)  { new_goal :p, :x, :y }
+    let(:goal2) { new_goal :q, :x, :y }
+    
+    describe 'when [:atomic,:atomic]' do
+      
+      it 'should unify equal atomic numbers' do
+        assert    unify(42, 42, goal),                    name
+      end
+      
+      it 'should not unify unequal atomic numbers' do
+        refute    unify(42, 99, goal),                    name
+        
+        expected_log = [
+          'Cannot unify because 42 != 99 (atomic != atomic)',
+        ]
+        
+        assert_equal    expected_log,                     goal.log
+      end
+      
+    end
+    
+    describe 'when [:array,:array]' do
+      
+      before do
+        @spy = Spy.on(self, :unify_arrays).and_call_through
+      end
+      
+      after do
+        assert_equal  1,  @spy.calls.size, "expected unify_arrays to be called once for #{name}"
+      end
+      
+      it 'should unify empty arrays' do
+        assert    unify([], [], goal),                    name
+      end
+      
+      it 'should unify equal arrays' do
+        assert    unify([7,11,13], [7,11,13], goal),      name
+      end
+      
+      it 'should not unify unequal arrays' do
+        refute    unify([7,11,13], [7,11,14], goal),      name
+        
+        expected_log = [
+          'Cannot unify incompatible values: 13 with 14',
+          'Cannot unify because [7, 11, 13] != [7, 11, 14] (array != array)',
+        ]
+        
+        assert_equal    expected_log,                     goal.log
+      end
+      
+      it 'should not unify arrays of different lengths' do
+        refute    unify([7,11,13], [7,11,13,13], goal),   name
+        
+        expected_log = [
+          'Cannot unify arrays of different lengths: [7, 11, 13] with [7, 11, 13, 13]',
+          'Cannot unify because [7, 11, 13] != [7, 11, 13, 13] (array != array)',
+        ]
+        
+        assert_equal    expected_log,                     goal.log
+      end
+      
+    end
+    
+    describe 'when [:variable,:atomic]' do
+      
+      before do
+        expects(:unify_arrays).times(0)
+      end
+      
+      it 'should return an instantiation' do
+        assert_equal    [[:word, 'word', goal, goal]],    unify(:word, 'word', goal),      name
+      end
+      
+      it 'should not unify an instantiated variable with a different value' do
+        goal.instantiate :word, 'other'
+        
+        assert_nil                                        unify(:word, 'word', goal),      name
+        
+        expected_log = [
+          'Cannot unify because Goal1."other" != "word" (variable != atomic)',
+        ]
+        
+        assert_equal    expected_log,                     goal.log
+      end
+      
+    end
+    
+    describe 'when [:atomic,:variable]' do
+      
+      before do
+        expects(:unify_arrays).times(0)
+      end
+      
+      it 'should return an instantiation' do
+        assert_equal    [[:word, 'word', goal, goal]],    unify('word', :word, goal),      name
+      end
+      
+      it 'should not unify instantiated variables with different values' do
+        goal.instantiate :word, 'something'
+        
+        assert_nil                                        unify('word', :word, goal),      name
+        
+        expected_log = [
+          'Cannot unify because "word" != Goal1."something" (atomic != variable)',
+        ]
+        
+        assert_equal    expected_log,                     goal.log
+      end
+      
+    end
+    
+    describe 'when [:variable, :variable]' do
+      
+      before do
+        expects(:unify_arrays).times(0)
+      end
+      
+      it 'should return an instantiation' do
+        assert_equal    [[:x, :y, goal, goal2]],    unify(:x, :y, goal, goal2),      name
+      end
+      
+      it 'should not unify instantiated variables with different values' do
+        goal.instantiate :word, 'something'
+        goal.instantiate :draw, 'picturing'
+        
+        assert_nil                                        unify(:draw, :word, goal),      name
+        
+        expected_log = [
+          'Cannot unify because "picturing" != "something" (variable != variable)'
+        ]
+        
+        assert_equal    expected_log,   goal.log
+      end
+      
+      it 'should unify the unknown array with a variable' do
+        goal.instantiate :X, UNKNOWN_ARRAY
+        goal.instantiate :Y, [1,2,3,4]
+        
+        unifications = unify(goal[:X], goal[:Y], goal)
+        
+        expected_unifications = [
+          [goal[:X], goal[:Y], goal, goal]
+        ]
+        
+        assert_equal    expected_unifications,    unifications
+        
+        expected_log = []
+        
+        assert_equal    expected_log,   goal.log
+      end
+      
+      it 'should unify the unknown array with an array' do
+        goal.instantiate :X, [1,2,3,4]
+        goal.instantiate :Y, UNKNOWN_ARRAY
+        
+        unifications = unify(goal[:X], goal[:Y], goal)
+        
+        expected_unifications = [
+          [goal[:X], goal[:Y], goal, goal]
+        ]
+        
+        assert_equal    expected_unifications,    unifications
+        
+        expected_log = []
+        
+        assert_equal    expected_log,   goal.log
+      end
+      
+    end
+    
+    describe 'when [:variable, :array]' do
+      
+      it 'should return an instantiation' do
+        expects(:unify_arrays).times(0)
+        
+        assert_equal    [[:list, [7,11,13], goal, goal]],     unify(:list, [7,11,13], goal),      name
+      end
+      
+      it 'should not unify instantiated variables with different values' do
+        goal.instantiate :word, [1,2,3,4]
+        expects(:unify_arrays).times(1)
+        
+        assert_nil                                            unify(:word, [1,2,3,5], goal),      name
+        
+        expected_log = [
+          'Cannot unify because Goal1.[1, 2, 3, 4] != [1, 2, 3, 5] (variable/array != array)'
+        ]
+        
+        assert_equal    expected_log,   goal.log
+      end
+      
+      it 'should not unify instantiated variables with a non-array value' do
+        goal.instantiate :word, 1234
+        expects(:unify_arrays).times(0)
+        
+        assert_nil                                            unify(:word, [1,2,3,5], goal),      name
+        
+        expected_log = [
+          'Cannot unify because Goal1.1234 != [1, 2, 3, 5] (variable != array)'
+        ]
+        
+        assert_equal    expected_log,   goal.log
+      end
+      
+    end
+    
+    describe 'when [:array, :variable]' do
+      
+      it 'should not unify instantiated variables that are not instantiated with an array' do
+        goal.instantiate :word, '1 2 3 4'
+        
+        assert_nil                                            unify([1,2,3,4], :word, goal),      name
+        
+        expected_log = [
+          'Cannot unify because [1, 2, 3, 4] != Goal1."1 2 3 4" (array != variable)'
+        ]
+        
+        assert_equal    expected_log,                     goal.log
+      end
+      
+      it 'should return an instantiation' do
+        expects(:unify_arrays).times(0)
+        
+        assert_equal    [[:list, [7,11,13], goal, goal]],     unify([7,11,13], :list, goal),      name
+      end
+      
+      it 'should not unify instantiated variables with different values' do
+        goal.instantiate :word, [1,2,3,4]
+        expects(:unify_arrays).times(1)
+        
+        assert_nil                                            unify([1,2,3,5], :word, goal),      name
+        
+        expected_log = [
+          'Cannot unify because [1, 2, 3, 5] != Goal1.[1, 2, 3, 4] (variable/array != array)'
+        ]
+        
+        assert_equal    expected_log,                     goal.log
+      end
+      
+      it 'should unify instantiated variables with unifiable values' do
+        goal.instantiate :word, [1,2,3]/:w
+        
+        instantiations = unify([nil,nil,3,4,5], :word, goal)
+        
+        expected_log            = []
+        expected_instantiations = [
+          [:w, [4,5], goal, goal],
+        ]
+        
+        assert_equal    expected_log,             goal.log
+        assert_equal    expected_instantiations,  instantiations
+      end
+      
+    end
+    
+    describe 'when [:array,:atomic], [:atomic,:array]' do
+      
+      before do
+        expects(:unify_arrays).times(0)
+      end
+      
+      it 'should return nil for unifying array and atomic' do
+        assert_nil                                           unify([7,11,13], 'word', goal),      name
+        
+        expected_log = [
+          'Cannot unify [7, 11, 13] with "word" (array != atomic)',
+        ]
+        
+        assert_equal    expected_log,                     goal.log
+      end
+      
+      it 'should return nil for unifying atomic and array' do
+        assert_nil                                           unify('word', [7,11,13], goal),      name
+        
+        expected_log = [
+          'Cannot unify "word" with [7, 11, 13] (atomic != array)',
+        ]
+        
+        assert_equal    expected_log,                     goal.log
+      end
+      
+    end
+    
+    describe 'when [:array, :tail]' do
+      
+      let(:goal)  { new_goal :p, :x, :y }
+      
+      it 'should unify an array and a tail' do
+        assert    unify([7,11,13], Tail.new([[7,11,goal[:P]]]), goal),      name
+        
+        expected_log = []
+        
+        assert_equal    expected_log,                     goal.log
+      end
+      
+      it 'should not unify an array and tail when they cannot be unified' do
+        refute    unify([7,11,13], Tail.new([[7,11,14]]), goal),      name
+        
+        expected_log = [
+          'Cannot unify incompatible values: 13 with 14',
+          'Cannot unify: [7, 11, 13] with [7, 11, 14]',
+          'Cannot unify because [7, 11, 13] != *[[7, 11, 14]] (array != tail)'
+        ]
+        
+        assert_equal    expected_log,                     goal.log
+      end
+      
+    end
+    
+    describe 'when [:tail, :array]' do
+      
+      let(:goal)  { new_goal :p, :x, :y }
+      
+      it 'should unify a tail and an array' do
+        assert    unify(Tail.new([[7,11,13]]), [7,11,goal[:P]], goal),      name
+        
+        expected_log = []
+        
+        assert_equal    expected_log,                     goal.log
+      end
+      
+      it 'should not unify a tail and an array when they cannot be unified' do
+        refute    unify(Tail.new([[7,11,13]]), [7,11,14], goal),      name
+        
+        expected_log = [
+          'Cannot unify incompatible values: 13 with 14',
+          'Cannot unify: [7, 11, 13] with [7, 11, 14]',
+          'Cannot unify because *[[7, 11, 13]] != [7, 11, 14] (tail != array)'
+        ]
+        
+        assert_equal    expected_log,                     goal.log
+      end
+      
+    end
+    
+    describe 'when [:tail, :tail]' do
+      
+      it 'something' do
+        expected_unifications = [
+          [goal[:B], [goal[:H]]/:T,  goal, goal],
+          [goal[:C], [goal[:H]]/:NT, goal, goal]
+        ]
+        assert_equal    expected_unifications, unify(
+          [:A, :B,      :C],
+          [:A, [:H]/:T, [:H]/:NT],
+          goal
+        )
+      end
+      
+    end
+    
+  end
+  
+  describe '#unify_arrays' do
+    
+    let(:g1)    { new_goal(:p, :x, :y) }
+    let(:g2)    { new_goal(:q, :a, :b) }
+    let(:goals) { [g1, g2]             }
+    
+    it 'should not unify arrays when left is not an Array' do
+      expect_unify_arrays_with_calls 0, 0, 0
+      
+      refute_Unify_arrays [{}, []], goals, [
+        'Cannot unify a non-array with an array: {} with []',
+      ]
+    end
+    
+    it 'should not unify arrays when right is not an Array' do
+      expect_unify_arrays_with_calls 0, 0, 0
+      
+      refute_Unify_arrays [[], 4], goals, [
+        'Cannot unify a non-array with an array: [] with 4',
+      ]
+    end
+    
+    it 'should unify but without unifications when left is the unknown array' do
+      expect_unify_arrays_with_calls 0, 0, 0
+      
+      assert_Unify_arrays [UNKNOWN_ARRAY, [:a,:b,:c]], goals, [g2[:a], g2[:b], g2[:c]]
+    end
+    
+    it 'should unify but without unifications when right is the unknown array' do
+      expect_unify_arrays_with_calls 0, 0, 0
+      
+      assert_Unify_arrays [[:x,:y,:z], UNKNOWN_ARRAY], goals, [g1[:x], g1[:y], g1[:z]]
+    end
+    
+    it 'should unify but without unifications when left and right are the unknown array' do
+      expect_unify_arrays_with_calls 0, 0, 0
+      
+      assert_Unify_arrays [[UNKNOWN_TAIL], UNKNOWN_ARRAY], goals, UNKNOWN_ARRAY
+    end
+    
+    arrays_without_tails = [
+      [],
+      [1, 2, 3],
+      [1, 2, 3, 4],
+      [:x, :y, :z],
+      [['one'], ['word'], ['sentences']],
+    ]
+    
+    arrays_with_tails = [
+      []/:t,
+      [1]/:z,
+      [1, 2]/:s,
+      [1, UNKNOWN_TAIL],
+      [1, 2, 3, UNKNOWN_TAIL],
+      [1, 2, 3, 4, UNKNOWN_TAIL],
+      [:x, :y, :z, UNKNOWN_TAIL],
+      [['one'], ['word'], ['sentences']]/:tail,
+    ]
+    
+    arrays_without_tails.combination(2).each do |arrays|
+      it "should call unify_arrays_with_no_tails when there are no tails: #{arrays.map(&:inspect).join(' and ')}" do
+        expect_unify_arrays_with_calls 1, 0, 0
+        
+        unify_arrays(*arrays, *goals)
+      end
+    end
+    
+    arrays_with_tails.combination(2).each do |arrays|
+      it "should call unify_arrays_with_all_tails when all arrays have tails: #{arrays.map(&:inspect).join(' and ')}" do
+        expect_unify_arrays_with_calls 0, 0, 1
+        
+        unify_arrays(*arrays, *goals)
+      end
+    end
+    
+    (
+      arrays_without_tails.product(arrays_with_tails) +
+      arrays_with_tails.product(arrays_without_tails)
+    ).each do |arrays|
+      it "should call unify_arrays_with_some_tails when one array has a tail and the other does not: #{arrays.map(&:inspect).join(' and ')}" do
+        expect_unify_arrays_with_calls 0, 1, 0
+        
+        unify_arrays(*arrays, *goals)
+      end
+    end
+    
+    it 'should unify identical arrays without variables' do
+      assert_Unify_arrays [[1,2,3], [1,2,3]], goals, [1,2,3]
+    end
+    
+    it 'should unify an array of variables with an array of atomics' do
+      assert_Unify_arrays [[:a,:b,:c], [1,2,3]], goals, [1,2,3], [
+        [:a, 1, g1, g2],
+        [:b, 2, g1, g2],
+        [:c, 3, g1, g2],
+      ]
+    end
+    
+    it 'should unify an array of atomics with an array of variables' do
+      assert_Unify_arrays [[1,2,3], [:a,:b,:c]], goals, [1,2,3], [
+        [:a, 1, g2, g1],
+        [:b, 2, g2, g1],
+        [:c, 3, g2, g1],
+      ]
+    end
+    
+    it 'should unify arrays of variables' do
+      assert_Unify_arrays [[:x,:y,:z], [:a,:b,:c]], goals, [nil,nil,nil], [
+        [:x, :a, g1, g2],
+        [:y, :b, g1, g2],
+        [:z, :c, g1, g2],
+      ]
+    end
+    
+    it 'should unify a fixed array with an array with a tail' do
+      assert_Unify_arrays [[:a, 2, 3], [1]/:t], goals, [1,2,3], [
+        [:a, 1,     g1, g2],
+        [:t, [2,3], g2, g1],
+      ]
+    end
+    
+    it 'should unify a fixed array with the unknown array' do
+      assert_Unify_arrays [[1,2,3], UNKNOWN_ARRAY], goals, [1,2,3]
+    end
+    
+    it 'should unify the unknown array with the unknown array' do
+      assert_Unify_arrays [UNKNOWN_ARRAY, UNKNOWN_ARRAY], goals, UNKNOWN_ARRAY
+    end
+    
+    it 'should unify arrays with variable tails' do
+      assert_Unify_arrays [[:a, :b]/:c, [:x, :y]/:z], goals, [nil,nil,UNKNOWN_TAIL], [
+        [:a, :x, g1, g2],
+        [:b, :y, g1, g2],
+        [:c, :z, g1, g2],
+      ]
+    end
+    
+    it 'should unify arrays with variable tails of different lenths' do
+      assert_Unify_arrays [[:a, :b]/:c, [:x]/:z], goals, [nil,nil,UNKNOWN_TAIL], [
+        [g2[:x], g1[:a],            g2, g1],
+        [g2[:z], [g1[:b]]/g1[:c],   g2, g1],
+      ]
+    end
+    
+    it 'should unify arrays with overlapping variables' do
+      assert_Unify_arrays [[:a,:a,:c,:c,:e], [1,:b,:b,:d,:d]], goals, [1, nil, nil, nil, nil], [
+        [g1[:a], g2[1],  g1, g2],
+        [g1[:a], g2[:b], g1, g2],
+        [g1[:c], g2[:b], g1, g2],
+        [g1[:c], g2[:d], g1, g2],
+        [g1[:e], g2[:d], g1, g2],
+      ]
+    end
+    
+    it 'should unify complementary arrays' do
+      assert_Unify_arrays [[1,2]/:t, [:a,:b,3,4,5]], goals, [1,2,3,4,5], [
+        [g2[:a], g1[1],     g2, g1],
+        [g2[:b], g1[2],     g2, g1],
+        [g1[:t], [3, 4, 5], g1, g2],
+      ]
+    end
+    
+  end
+  
+  describe '#unify_many_arrays' do
+    
+    let(:goal)   { new_goal(:p, :x, :y) }
+    
+    it 'should return nil when not all arrays are Arrays or variables' do
+      arrays = [
+        [1,2,3],
+        123,
+        :x,
+      ]
+      
+      assert_nil      unify_many_arrays(arrays, [goal] * arrays.size),      name
+      
+      expected_log = [
+        'Cannot unify: [1, 2, 3] with 123 with :x',
+      ]
+      
+      assert_equal    expected_log,                     goal.log
+    end
+    
+    it 'should not return nil when all arrays are Arrays or variables' do
+      arrays = [
+        [1,2,3],
+        UNKNOWN_ARRAY,
+        :x,
+      ]
+      
+      result = unify_many_arrays(arrays, [goal] * arrays.size)
+      refute_nil      result,      name
+      
+      merged, unifications = result
+      
+      expected_merged       = [1,2,3]
+      expected_unifications = [
+      ]
+      
+      assert_equal    expected_merged,          merged
+      assert_equal    expected_unifications,    unifications
+    end
+    
+    it 'should automatically merge unknown arrays' do
+      arrays = [
+        [1,2,3],
+        UNKNOWN_ARRAY,
+      ]
+      
+      assert_equal    [[1,2,3], []],        unify_many_arrays(arrays, [goal] * arrays.size),      name
+    end
+    
+    it 'should call unify_arrays_with_no_tails when there are no Arrays with Tails' do
+      expect_unify_arrays_with_calls 1, 0, 0
+      
+      arrays = [
+        [1,   2,    3,  nil],
+        [1,   nil,  3,  4],
+        [nil, 2,    3,  nil],
+      ]
+      
+      unify_many_arrays(arrays, [goal] * arrays.size)
+    end
+    
+    it 'should call unify_arrays_with_all_tails when all Arrays have Tails' do
+      expect_unify_arrays_with_calls 0, 0, 1
+      
+      arrays = [
+        [1,   2,    3,  UNKNOWN_TAIL],
+        [1,   nil,  3,  ]/:x,
+      ]
+      
+      unify_many_arrays(arrays, [goal] * arrays.size)
+    end
+    
+    it 'should call unify_arrays_with_some_tails when there is a combination of Arrays with and without Tails' do
+      expect_unify_arrays_with_calls 0, 1, 0
+      
+      arrays = [
+        [1,   2,    3,  UNKNOWN_TAIL],
+        [1,   nil,  3,  4],
+        [nil, 2,    3,  nil],
+      ]
+      
+      unify_many_arrays(arrays, [goal] * arrays.size)
+    end
+    
+  end
+  
+  describe '#has_tail?' do
+    
+    # -- Non-Arrays --
+    let(:goal)                      { new_goal(:p, :x, :y) }
+    let(:variable)                  { goal.variable(:x) }
+    let(:object)                    { Object.new }
+    let(:symbol)                    { :symbol }
+    let(:integer)                   { 789 }
+    
+    # -- Arrays --
+    let(:empty_array)               { [] }
+    let(:finite_array)              { [1,2,3,4,5] }
+    let(:array_with_unknown_tail)   { [1,2,3,4,5,UNKNOWN_TAIL] }
+    let(:array_with_variable_tail)  { [1,2,3,4,5]/:tail }
+    let(:unknown_array)             { UNKNOWN_ARRAY }
+    
+    describe 'when not given an Array' do
+      
+      it 'should return false when given an uninstantiated variable' do
+        refute  has_tail?(variable), name
+      end
+      
+      it 'should return false when given an Object' do
+        refute  has_tail?(object), name
+      end
+      
+      it 'should return false when given a Symbol' do
+        refute  has_tail?(symbol), name
+      end
+      
+      it 'should return false when given an Integer' do
+        refute  has_tail?(integer), name
+      end
+      
+    end
+    
+    describe 'when given an Array' do
+      
+      it 'should return false when the Array is empty' do
+        refute  has_tail?(empty_array), name
+      end
+      
+      it 'should return false when the last element is atomic' do
+        refute  has_tail?(finite_array), name
+      end
+      
+      it 'should return true when the last element is unknown' do
+        assert  has_tail?(array_with_unknown_tail), name
+      end
+      
+      it 'should return true when the last element is a Tail' do
+        assert  has_tail?(array_with_variable_tail), name
+      end
+      
+      it 'should return true when given an unknown array' do
+        assert  has_tail?(unknown_array), name
+      end
+      
+      describe 'and the array has an instantiated tail' do
+        
+        before do
+          goal.instantiate :a, 1
+          goal.instantiate :b, 2
+          goal.instantiate :c, 3
+          goal.instantiate :d, 4
+          goal.instantiate :e, [5]
+        end
+        
+        describe 'and to apply value to the array' do
+          
+          it 'should return false' do
+            array = goal.variablise([:a, :b, :c, :d]/:e)
+            
+            refute  has_tail?(array, true), name
+          end
+          
+        end
+        
+        describe 'and to not apply value to the array' do
+          
+          it 'should return true' do
+            array = goal.variablise([:a, :b, :c, :d]/:e)
+            
+            assert  has_tail?(array, false), name
+          end
+          
+        end
+        
+      end
+      
+    end
+    
+  end
+  
+  describe '#expand_splat' do
+    
+    it 'should return an empty array as is' do
+      assert_equal    [],     expand_splat([])
+    end
+    
+    it 'should return non-arrays as is' do
+      assert_equal    5,      expand_splat(5)
+    end
+    
+    it 'should expand an array of just a Tail' do
+      assert_equal    :t,     expand_splat([]/:t)
+    end
+    
+    it 'should not expand an array with a Tail' do
+      assert_equal    [1,2,3]/:t,     expand_splat([1,2,3]/:t)
+    end
+    
+    it 'should expand a tail' do
+      assert_equal    [1,2,3,4,5],    expand_splat([1,2,3,Tail.new([4,5])])
+    end
+    
+    it 'should expand nested arrays' do
+      assert_equal    [99, [1,2,3,4], 99],    expand_splat([99,[1,2,3,Tail.new([4])],99])
+    end
+    
+  end
+  
+  describe '#unify_arrays_with_no_tails' do
+    
+    let(:g1)    { new_goal(:p, :x, :y) }
+    let(:g2)    { new_goal(:q, :a, :b) }
+    let(:g3)    { new_goal(:r, :s, :t) }
+    let(:g4)    { new_goal(:v, :i, :j) }
+    let(:goals) { [g1, g2, g3, g4]     }
+    
+    it 'should return nil when any array has a tail' do
+      arrays = [
+        [1,  2,  3,  4],
+        [1,  2,  3]/:tail,
+        [:w, :x, :y, :z]
+      ]
+      arrays_goals = goals[0..arrays.size]
+      
+      assert_nil      unify_arrays_with_no_tails(arrays, arrays_goals, []), name
+      
+      expected_log = [
+        'Wrong unification method called: no_tails but one or more of [[1, 2, 3, 4], [1, 2, 3, *:tail], [:w, :x, :y, :z]] has a tail',
+      ]
+      
+      arrays_goals.each do |goal|
+        assert_equal    expected_log,                     goal.log
+      end
+    end
+    
+    it 'should not unify finite arrays with unequal sizes' do
+      # -- First > Last --
+      arrays = [
+        [nil, nil, nil, nil],
+        [1,   2,   3]
+      ]
+      arrays_goals = goals[0...arrays.size]
+
+      assert_nil                        unify_arrays_with_no_tails(arrays, arrays_goals, []), name
+      
+      # -- First = Last --
+      arrays = [
+        [nil, nil, nil],
+        [1,   2,   3]
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      expected_merged       = [1,2,3]
+      expected_unifications = []
+
+      merged, unifications = unify_arrays_with_no_tails(arrays, arrays_goals, [])
+      
+      assert_equal    expected_merged,          merged
+      assert_equal    expected_unifications,    unifications
+      
+      # -- First < Last --
+      arrays = [
+        [nil, nil],
+        [1,   2,   3]
+      ]
+      arrays_goals = goals[0...arrays.size]
+
+      assert_nil                        unify_arrays_with_no_tails(arrays, arrays_goals, []), name
+      
+      # -- Check Log --
+      expected_log = [
+        'Cannot unify arrays of different lengths: [nil, nil, nil, nil] with [1, 2, 3]',
+        'Cannot unify arrays of different lengths: [nil, nil] with [1, 2, 3]',
+      ]
+      
+      arrays_goals.each do |goal|
+        assert_equal    expected_log,                     goal.log
+      end
+    end
+    
+    it 'should merge values with nil as an empty slot' do
+      arrays = [
+        [1,   2,   3,   nil, nil],
+        [nil, nil, nil, 4,   nil],
+        [nil, nil, nil, nil, 5],
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      merged, unifications = unify_arrays_with_no_tails(arrays, arrays_goals, [])
+      
+      expected_merged       = [1, 2, 3, 4, 5]
+      expected_unifications = []
+      
+      assert_equal  expected_merged,        merged
+      assert_equal  expected_unifications,  unifications
+    end
+    
+    it 'should return nil when the finite arrays have different sizes' do
+      arrays = [
+        [nil],
+        [nil, nil, nil, nil],
+        [nil, nil, nil, nil, nil, nil],
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      assert_nil                        unify_arrays_with_no_tails(arrays, arrays_goals, []), name
+      
+      expected_log = [
+        'Cannot unify arrays of different lengths: [nil] with [nil, nil, nil, nil] with [nil, nil, nil, nil, nil, nil]',
+      ]
+      
+      arrays_goals.each do |goal|
+        assert_equal    expected_log,                     goal.log
+      end
+    end
+    
+    it 'should return nil when the arrays have incompatible values' do
+      arrays = [
+        [1,   2,   3,   nil, nil],
+        [nil, nil, nil, 4,   nil],
+        [8,   nil, nil, nil, 5],
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      assert_nil                        unify_arrays_with_no_tails(arrays, arrays_goals, []), name
+      
+      expected_log = [
+        'Cannot unify incompatible values: 1 with 8',
+      ]
+      
+      arrays_goals.each do |goal|
+        assert_equal    expected_log,                     goal.log
+      end
+    end
+    
+    it 'should return necessary unifications to unify variables' do
+      arrays = [
+        [1,   2,   nil, nil, nil],
+        [:j,  :n,  :n,  4,   nil],
+        [:x,  nil, :m,  :y,  :z],
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      merged, unifications = unify_arrays_with_no_tails(arrays, arrays_goals, [])
+      
+      expected_merged       = [1, 2, nil, 4, nil]
+      expected_unifications = [
+        [g2[:j], g1[1],   g2, g1],
+        [g3[:x], g1[1],   g3, g1],
+        [g2[:j], g3[:x],  g2, g3],
+        [g2[:n], g1[2],   g2, g1],
+        [g2[:n], g3[:m],  g2, g3],
+        [g3[:y], g2[4],   g3, g2],
+      ]
+      
+      assert_equal    expected_merged,          merged
+      assert_equal    expected_unifications,    unifications
+    end
+    
+    it 'should deduce array goals from array elements when missing' do
+      arrays = [
+        [         nil, 2,   nil, g1.value(4), nil],
+        g2.value([1,   nil, 3,   nil,         nil]),
+        g3.value([nil, :x,  nil, nil,         5]),
+      ]
+      missing_goals = [nil, nil, nil]
+      
+      merged, unifications = unify_arrays_with_no_tails(arrays, missing_goals, [])
+      
+      expected_merged       = [1, 2, 3, 4, 5]
+      expected_unifications = [
+        [g3.variable(:x), g1.value(2), g3, g1]
+      ]
+      
+      assert_equal    expected_merged,            merged
+      assert_equal    expected_unifications,      unifications
+    end
+    
+    it 'should map Values as is' do
+      value1 = g1.value(91)
+      g1.instantiate(:gi, [nil, value1, nil, 93])
+      
+      arrays = [
+        [         nil, 2,    nil,  :gi,                   nil],
+        g2.value([1,   nil,  3,    [90,  nil, nil, nil],  nil]),
+        g3.value([nil, :x,   nil,  [nil, nil, 92,  :gy],  5]),
+      ]
+      
+      arrays_goals = [g1, nil, nil]
+      
+      merged, unifications = unify_arrays_with_no_tails(arrays, arrays_goals, [])
+      
+      expected_merged       = [1, 2, 3, [90, 91, 92, 93], 5]
+      expected_unifications = [
+        [g3.variable(:x),  g1.value(2),  g3, g1],
+        [g3.variable(:gy), g1.value(93), g3, g1],
+      ]
+      
+      assert_equal    expected_merged,          merged
+      assert_equal    expected_unifications,    unifications
+    end
+    
+    it 'should detect ununifiable values embedded in subarrays' do
+      value1 = g1.value(91)
+      g1.instantiate(:gi, [nil, value1, 92.1, 93])
+      
+      arrays = [
+        [         nil, 2,    nil,  :gi,                   nil],
+        g2.value([1,   nil,  3,    [90,  nil, nil, nil],  nil]),
+        g3.value([nil, :x,   nil,  [nil, nil, 92,  :gy],  5]),
+      ]
+      
+      arrays_goals = [g1, nil, nil]
+      
+      assert_nil      unify_arrays_with_no_tails(arrays, arrays_goals, []), name
+      
+      expected_log = [
+        'Cannot unify incompatible values: 92.1 with 92',
+        'Cannot unify: [nil, 91, 92.1, 93] with [90, nil, nil, nil] with [nil, nil, 92, Goal3.:gy]',
+      ]
+      
+      [g1, g2, g3].each do |goal|
+        assert_equal    expected_log,   goal.log
+      end
+    end
+    
+    it 'should not expand variables when they are instantiated to the unknown array' do
+      arrays_goals = goals[0...4]
+      g4.instantiate :z, UNKNOWN_ARRAY
+      arrays = [
+        [1,   2,   nil, nil, nil],
+        [:j,  :n,  :n,  4,   nil],
+        [:x,  nil, :m,  :y,  :z],
+        :z
+      ]
+      
+      assert_equal    UNKNOWN_ARRAY,      g4[:z].value
+      
+      merged, unifications = unify_arrays_with_no_tails(arrays, arrays_goals, [])
+      
+      expected_merged       = [1, 2, nil, 4, g3[:z]]
+      expected_unifications = [
+        [g2[:j], g1[1],   g2, g1],
+        [g2[:n], g1[2],   g2, g1],
+        [g3[:x], g1[1],   g3, g1],
+        [g4[:z], [g1[1],  g1[2], g1.value(nil), g1.value(nil), g1.value(nil)], g4, g1],
+        [g2[:j], g3[:x],  g2, g3],
+        [g2[:n], g3[:m],  g2, g3],
+        [g3[:y], g2[4],   g3, g2],
+        [g4[:z], [g2[:j], g2[:n],  g2[:n], g2[4],  g2.value(nil)], g4, g2],
+        [g4[:z], [g3[:x], g3.value(nil), g3[:m], g3[:y], g3[:z]],  g4, g3],
+      ]
+      
+      assert_equal    expected_merged,          merged
+      assert_equal    expected_unifications,    unifications
+    end
+    
+    it 'should not expand variables when they are instantiated to the unknown tail' do
+      arrays_goals = goals[0...4]
+      g4.instantiate :z, UNKNOWN_TAIL
+      arrays = [
+        [1,   2,   nil, nil, nil],
+        [:j,  :n,  :n,  4,   nil],
+        [:x,  nil, :m,  :y,  :z],
+        :z
+      ]
+      
+      assert_equal    g4[:z],             g4[:z].value
+      
+      merged, unifications = unify_arrays_with_no_tails(arrays, arrays_goals, [])
+      
+      expected_merged       = [1, 2, nil, 4, nil]
+      expected_unifications = [
+        [g2[:j], g1[1],   g2, g1],
+        [g2[:n], g1[2],   g2, g1],
+        [g3[:x], g1[1],   g3, g1],
+        [g4[:z], [g1[1],  g1[2], g1.value(nil), g1.value(nil), g1.value(nil)], g4, g1],
+        [g2[:j], g3[:x],  g2, g3],
+        [g2[:n], g3[:m],  g2, g3],
+        [g3[:y], g2[4],   g3, g2],
+        [g4[:z], [g2[:j], g2[:n],  g2[:n], g2[4],  g2.value(nil)], g4, g2],
+        [g4[:z], [g3[:x], g3.value(nil), g3[:m], g3[:y], g3[:z]],  g4, g3],
+      ]
+      
+      assert_equal    expected_merged,          merged
+      assert_equal    expected_unifications,    unifications
+    end
+    
+    it 'should not unify an atomic with an embedded unknown array ' do
+      value1 = g1.value(91)
+      g1.instantiate(:gi, [nil, value1, 92.1, 93])
+      
+      arrays = [
+        [         nil, 2,    nil,  :gi,                   nil],
+        g2.value([1,   nil,  3,    [90,  nil, nil, nil],  nil]),
+        g3.value([nil, :x,   nil,  [nil, nil, UNKNOWN_ARRAY,  :gy],  5]),
+      ]
+      
+      arrays_goals = [g1, nil, nil]
+      
+      assert_nil      unify_arrays_with_no_tails(arrays, arrays_goals, []), name
+      
+      expected_log = [
+        'Cannot unify incompatible values: 92.1 with [...]',
+        'Cannot unify: [nil, 91, 92.1, 93] with [90, nil, nil, nil] with [nil, nil, [...], Goal3.:gy]',
+      ]
+      
+      [g1, g2, g3].each do |goal|
+        assert_equal    expected_log,   goal.log
+      end
+    end
+    
+    it 'should not unify arrays where one embedded variable cannot be unified' do
+      g1.instantiate(:a, :b)
+      g2.instantiate(:a, 2)
+      g3.instantiate(:a, 3)
+      
+      arrays = [
+        [[:a]],
+        [[:a]],
+        [[:a]],
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      assert_nil      unify_arrays_with_no_tails(arrays, arrays_goals, []), name
+      
+      assert_equal [
+        'Cannot unify: [Goal1.:a] with [Goal2.2] with [Goal3.3]',
+      ], g1.log
+      
+      assert_equal [
+        'Cannot unify because Goal2.2 != Goal3.3 (atomic != atomic)',
+        'Cannot unify: Goal2.2 with Goal3.3',
+        'Cannot unify: [Goal1.:a] with [Goal2.2] with [Goal3.3]',
+      ], g2.log
+      
+      assert_equal [
+        'Cannot unify because Goal2.2 != Goal3.3 (atomic != atomic)',
+        'Cannot unify: Goal2.2 with Goal3.3',
+        'Cannot unify: [Goal1.:a] with [Goal2.2] with [Goal3.3]',
+      ], g3.log
+    end
+    
+  end
+  
+  describe '#unify_arrays_with_some_tails' do
+    
+    let(:g1)    { new_goal(:p, :x, :y) }
+    let(:g2)    { new_goal(:q, :a, :b) }
+    let(:g3)    { new_goal(:r, :s, :t) }
+    let(:goals) { [g1, g2, g3]         }
+    
+    it 'should not unify a finite array with an array with a tail that has more finite elements' do
+      arrays = [
+        [nil, nil, nil, nil, UNKNOWN_TAIL],
+        [1,   2,   3]
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      assert_nil                        unify_arrays_with_some_tails(arrays, arrays_goals, []), name
+      
+      expected_log = [
+        'Cannot unify enough elements: [nil, nil, nil, nil, ...] with [Goal2.1, Goal2.2, Goal2.3]',
+      ]
+      
+      assert_equal    expected_log,                     g1.log
+      assert_equal    expected_log,                     g2.log
+    end
+    
+    it 'should unify a finite array with an array with a tail that has less finite elements' do
+      arrays = [
+        [nil, nil, UNKNOWN_TAIL],
+        [1,   2,   3]
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      assert_equal  [[1,2,3],[]],       unify_arrays_with_some_tails(arrays, arrays_goals, []), name
+    end
+    
+    it 'should merge values with an unknown tail' do
+      arrays = [
+        [1,   2,   3,   UNKNOWN_TAIL],
+        [nil, nil, nil, 4,   nil],
+        [nil, nil, nil, nil, 5],
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      assert_equal  [[1,2,3,4,5],[]],   unify_arrays_with_some_tails(arrays, arrays_goals, []), name
+    end
+    
+    it 'should return nil when the finite arrays have different sizes' do
+      arrays = [
+        [nil, UNKNOWN_TAIL],
+        [nil, nil, nil, nil],
+        [nil, nil, nil, nil, nil, nil],
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      assert_nil                        unify_arrays_with_some_tails(arrays, arrays_goals, []), name
+      
+      expected_log = [
+        'Cannot unify different sizes of arrays: [nil, ...] with [nil, nil, nil, nil] with [nil, nil, nil, nil, nil, nil]',
+      ]
+      
+      assert_equal    expected_log,                     g1.log
+      assert_equal    expected_log,                     g2.log
+      assert_equal    expected_log,                     g3.log
+    end
+    
+    it 'should return nil when the arrays have incompatible values' do
+      arrays = [
+        [1, 2, 3, UNKNOWN_TAIL],
+        [nil, nil, nil, 4, nil],
+        [5,   nil, nil, nil, 5],
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      assert_nil                        unify_arrays_with_some_tails(arrays, arrays_goals, []), name
+      
+      expected_log = [
+        'Cannot unify enough elements: Goal1.1 with Goal3.5',
+      ]
+      
+      assert_equal    expected_log,                     g1.log
+      assert_equal    expected_log,                     g2.log
+      assert_equal    expected_log,                     g3.log
+    end
+    
+    it 'should return necessary unification to unify variables' do
+      arrays = [
+        [1,   2,   nil, UNKNOWN_TAIL],
+        [:j,  :n,  :n,  4,  nil],
+        [:x,  nil, :m,  :y, :z],
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      merged, unifications = unify_arrays_with_some_tails(arrays, arrays_goals, [])
+      
+      expected_merged       = [1, 2, nil, 4, g3[:z]]
+      expected_unifications = [
+        [g2.variable(:j), g1.value(1),      g2, g1],
+        [g3.variable(:x), g1.value(1),      g3, g1],
+        [g2.variable(:j), g3.variable(:x),  g2, g3],
+        [g2.variable(:n), g1.value(2),      g2, g1],
+        [g2.variable(:n), g3.variable(:m),  g2, g3],
+        [g3.variable(:y), g2.value(4),      g3, g2],
+      ]
+      
+      assert_equal  [expected_merged, expected_unifications],   [merged, unifications], name
+    end
+    
+    it 'should handle a range of cases' do
+      [
+        [[[],                        [1,UNKNOWN_TAIL]      ],   nil, ['Cannot unify enough elements: [] with [Goal2.1, ...]']],
+        [[[]/:t,                     [1]                   ],   [[1], [[g1.variable(:t), [1], g1, g2]]]],
+        [[[],                        [1,2]/:s              ],   nil, ['Cannot unify enough elements: [] with [Goal2.1, Goal2.2, *Goal2.:s]']],
+        [[[]/:t,                     [1,2]                 ],   [[1,2], [[g1.variable(:t), [1,2], g1, g2]]]],
+        [[[1,2,3],                   [1,UNKNOWN_TAIL]      ],   [[1,2,3],[]]],
+        [[[1,2,3,UNKNOWN_TAIL],      [1]                   ],   nil, ['Cannot unify enough elements: [Goal1.1, Goal1.2, Goal1.3, ...] with [Goal2.1]']],
+        [[[1],                       [1,2,3,UNKNOWN_TAIL]  ],   nil, ['Cannot unify enough elements: [Goal1.1] with [Goal2.1, Goal2.2, Goal2.3, ...]']],
+        [[[1]/:z,                    [1,2,3]               ],   [[1,2,3], [[g1.variable(:z), [2, 3], g1, g2]]]],
+        [[[:x,:y,:z],                [1,2,3,4,UNKNOWN_TAIL]],   nil, ['Cannot unify enough elements: [Goal1.:x, Goal1.:y, Goal1.:z] with [Goal2.1, Goal2.2, Goal2.3, Goal2.4, ...]']],
+        [[[:x,:y,:z,UNKNOWN_TAIL],   [1,2,3,4]             ],   [
+          [1,2,3,4],
+          [
+            [g1.variable(:x), g2.value(1), g1, g2],
+            [g1.variable(:y), g2.value(2), g1, g2],
+            [g1.variable(:z), g2.value(3), g1, g2]
+          ]
+        ]],
+      ].each do |arrays, expected, expected_log|
+        arrays_goals = goals[0...arrays.size]
+        
+        result = unify_arrays_with_some_tails(arrays, arrays_goals, [])
+        
+        if expected.nil?
+          assert_nil                  result
+          
+          arrays_goals.uniq.each do |goal|
+            assert_equal    expected_log,                     goal.log
+            goal.log[0..-1] = []
+          end
+        else
+          assert_equal    expected,   result
+        end
+      end
+    end
+    
+    it 'should raise a no goal error when no goals are supplied and the arrays have no embedded goals' do
+      arrays = [
+        [nil, nil, nil, nil, UNKNOWN_TAIL],
+        [1,   2,   3]
+      ]
+      arrays_goals = [nil] * arrays.size
+      
+      error = assert_raises Porolog::NoGoalError do
+        unify_arrays_with_some_tails(arrays, arrays_goals, [])
+      end
+      
+      assert_equal '[nil, nil, nil, nil, ...] has no associated goal!  Cannot variablise!', error.message
+    end
+    
+    it 'should derive goals from embedded goals when the goals are not supplied' do
+      arrays_goals = [g1, nil]
+      arrays = [
+        [nil, nil, nil,   nil, UNKNOWN_TAIL],
+        [1,   2,   g2[3], 4]
+      ]
+      
+      refute              arrays.all?{|array| has_tail?(array, false)  },  "not all arrays should have a tail"
+      refute              arrays.all?{|array| !has_tail?(array, false) },  "not all arrays should not have a tail"
+      
+      merged, unifications = unify_arrays_with_some_tails(arrays, arrays_goals, [])
+      
+      expected_merged       = [1,2,3,4]
+      expected_unifications = [
+      ]
+      
+      assert_equal    expected_merged,              merged
+      assert_equal    expected_unifications,        unifications
+    end
+    
+    it 'should extract embedded variables and values in an array in a value' do
+      arrays = [
+        g1.value([nil, :b, nil,   nil, 5]),
+        [1,   2,   g2[3], 4]/:t
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      refute              arrays.all?{|array| has_tail?(array, false)  },  "not all arrays should have a tail"
+      refute              arrays.all?{|array| !has_tail?(array, false) },  "not all arrays should not have a tail"
+      
+      merged, unifications = unify_arrays_with_some_tails(arrays, arrays_goals, [])
+      
+      expected_merged       = [1,2,3,4,5]
+      expected_unifications = [
+        [g1[:b], g2[2], g1, g2],
+        [g2[:t], [5],   g2, g1],
+      ]
+      
+      assert_equal    expected_merged,              merged
+      assert_equal    expected_unifications,        unifications
+    end
+    
+    it 'should unify multiple atomics and tails' do
+      arrays = [
+        g1.value([nil, :b, nil,   nil, 5, 6, 7]),
+        [1,   2,   g2[3], 4]/:t,
+        [1,   2,   g3[3], 4]/:t,
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      refute          arrays.all?{|array| has_tail?(array, false)  },  "not all arrays should have a tail"
+      refute          arrays.all?{|array| !has_tail?(array, false) },  "not all arrays should not have a tail"
+      
+      merged, unifications = unify_arrays_with_some_tails(arrays, arrays_goals, [])
+      
+      expected_merged       = [1,2,3,4,5,6,7]
+      expected_unifications = [
+        [g1[:b], g2[2],     g1, g2],
+        [g1[:b], g3[2],     g1, g3],
+        [g2[:t], [5,6,7],   g2, g1],
+        [g3[:t], [5,6,7],   g3, g1],
+      ]
+      
+      assert_equal    expected_merged,              merged
+      assert_equal    expected_unifications,        unifications
+    end
+    
+    it 'should not unify incompatible atomics' do
+      arrays = [
+        g1.value([nil, :b, nil,   nil, 5]),
+        [1,   2,   g2[3], 4]/:t,
+        [1,   3,   g3[3], 4]/:t,
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      refute          arrays.all?{|array| has_tail?(array, false)  },  "not all arrays should have a tail"
+      refute          arrays.all?{|array| !has_tail?(array, false) },  "not all arrays should not have a tail"
+      
+      assert_nil      unify_arrays_with_some_tails(arrays, arrays_goals, []), name
+      
+      assert_equal [
+        'Cannot unify non-variables: 2 with 3'
+      ], g1.log
+      
+      assert_equal [
+        'Cannot unify non-variables: 2 with 3'
+      ], g2.log
+      
+      assert_equal [
+        'Cannot unify non-variables: 2 with 3'
+      ], g3.log
+    end
+    
+  end
+  
+  describe '#unify_arrays_with_all_tails' do
+    
+    let(:g1)    { new_goal(:p, :x, :y) }
+    let(:g2)    { new_goal(:q, :a, :b) }
+    let(:g3)    { new_goal(:r, :s, :t) }
+    let(:goals) { [g1, g2, g3]         }
+    
+    let(:array_with_tail_1) { [1,  2,  Tail.new(:h)] }
+    let(:array_with_tail_2) { [:h, :b]/:t }
+    let(:array_with_tail_3) { [:x, :y, UNKNOWN_TAIL] }
+    let(:head_and_tail_1)   { [1,  Tail.new([2,3])] }
+    let(:head_and_tail_2)   { [:h]/:t }
+    let(:head_and_tail_3)   { [:x, UNKNOWN_TAIL] }
+    
+    it 'should call unify_tail_with_tail when no array is headtail' do
+      expects(:unify_tail_with_tail).times(1)
+      expects(:unify_headtail_with_tail).times(0)
+      expects(:unify_headtail_with_headtail).times(0)
+      
+      arrays = [
+        array_with_tail_1,
+        array_with_tail_2,
+        array_with_tail_3,
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      unify_arrays_with_all_tails(arrays, arrays_goals, [])
+    end
+    
+    it 'should call unify_headtail_with_tail when all arrays but one are headtail' do
+      expects(:unify_tail_with_tail).times(0)
+      expects(:unify_headtail_with_tail).times(1)
+      expects(:unify_headtail_with_headtail).times(0)
+      
+      arrays = [
+        array_with_tail_1,
+        head_and_tail_2,
+        head_and_tail_3,
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      unify_arrays_with_all_tails(arrays, arrays_goals, [])
+    end
+    
+    it 'should include unifications of variables in a tail' do
+      arrays = [
+        [nil, nil, nil]/:list,
+        [1,   2,   3,   nil, :y, UNKNOWN_TAIL],
+        [nil, :x,  nil, 4,   Tail.new([nil,6])],
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      g1.instantiate :list, [4,5,:z]
+      
+      merged, unifications = unify_arrays_with_all_tails(arrays, arrays_goals, [])
+      
+      expected_merged       = [1,2,3,4,5,6]
+      expected_unifications = [
+        [g3[:x], g2[2], g3, g2],
+        [g2[:y], g1[5], g2, g1],
+        [g1[:z], g3[6], g1, g3],
+        [g1[:z], g1[6], g1, g1],
+      ]
+      
+      assert_equal    expected_merged,              merged
+      assert_equal    expected_unifications,        unifications
+    end
+    
+    it 'should not unify arrays where one embedded variable cannot be unified' do
+      g1.instantiate(:a, [g1.value(1), g1.value(2), g1.value(3), UNKNOWN_TAIL])
+      g2.instantiate(:a, :b)
+      g3.instantiate(:a, :b)
+      
+      arrays = [
+        :a,
+        [:a,Tail.new([1])],
+        [:a, UNKNOWN_TAIL],
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      assert_nil      unify_arrays_with_all_tails(arrays, arrays_goals, []), name
+      
+      assert_equal [
+        'Cannot unify enough elements: Goal1.[Goal1.1, Goal1.2, Goal1.3, ...] with [Goal2.:a, Goal2.1]',
+        'Cannot unify because Goal1.[Goal1.1, Goal1.2, Goal1.3, ...] != [:a, 1] (variable/array != array)',
+        'Cannot unify embedded arrays: :a with [:a, 1]',
+      ], g1.log
+      
+      assert_equal [
+        'Cannot unify enough elements: Goal1.[Goal1.1, Goal1.2, Goal1.3, ...] with [Goal2.:a, Goal2.1]',
+        'Cannot unify because Goal1.[Goal1.1, Goal1.2, Goal1.3, ...] != [:a, 1] (variable/array != array)',
+        'Cannot unify embedded arrays: :a with [:a, 1]',
+      ], g2.log
+      
+      assert_equal [
+        'Cannot unify embedded arrays: :a with [:a, 1]',
+      ], g3.log
+    end
+    
+    it 'should unify arrays where all embedded variables can be unified' do
+      arrays = [
+        [g1.variable(:a), g1.value(2), g1.variable(:c), g1.value(4)],
+        [g2.value(1), g1.variable(:b), g2.value(3), UNKNOWN_TAIL],
+        [:a, :b, Tail.new([3,:d])],
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      assert arrays.map(&:headtail?).none?
+      
+      expected_merged = [1,2,3,4]
+      expected_unifications = [
+        [g1.variable(:a), g2.value(1),      g1, g2],
+        [g1.variable(:a), g3.variable(:a),  g1, g3],
+        [g3.variable(:a), g2.value(1),      g3, g2],
+        [g1.variable(:b), g1.value(2),      g1, g1],
+        [g3.variable(:b), g1.value(2),      g3, g1],
+        [g1.variable(:b), g3.variable(:b),  g1, g3],
+        [g1.variable(:c), g2.value(3),      g1, g2],
+        [g1.variable(:c), g3.value(3),      g1, g3],
+        [g3.variable(:d), g1.value(4),      g3, g1]
+      ]
+      merged, unifications = unify_arrays_with_all_tails(arrays, arrays_goals, [])
+      
+      assert_equal [], g1.log
+      assert_equal [], g2.log
+      assert_equal [], g3.log
+      
+      assert_equal    expected_merged,        merged
+      assert_equal    expected_unifications,  unifications
+    end
+    
+    it 'should unify embedded arrays where all embedded variables can be unified' do
+      arrays = [
+        :e,
+        [[1],[2],[3],[4]],
+        [[1],[2],[3],[4]],
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      assert arrays.map(&:headtail?).none?
+      
+      expected_merged = [[1],[2],[3],[4]]
+      expected_unifications = [
+        [:e, [[1], [2], [3], [4]], g1, g2]
+      ]
+      merged, unifications = unify_arrays_with_all_tails(arrays, arrays_goals, [])
+      
+      assert_equal [], g1.log
+      assert_equal [], g2.log
+      assert_equal [], g3.log
+      
+      assert_equal    expected_merged,        merged
+      assert_equal    expected_unifications,  unifications
+    end
+    
+  end
+  
+  describe '#unify_tail_with_tail' do
+    
+    let(:g1)    { new_goal(:p, :x, :y) }
+    let(:g2)    { new_goal(:q, :a, :b) }
+    let(:g3)    { new_goal(:r, :s, :t) }
+    let(:g4)    { new_goal(:j, :k, :l) }
+    let(:goals) { [g1, g2, g3, g4]     }
+    
+    it 'should reject a non-headtail array' do
+      arrays = [
+        [1,Tail.new([2,3])],
+        [4],
+        [7,UNKNOWN_TAIL],
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      refute              arrays.all?(&:headtail?)
+      
+      assert_nil          unify_tail_with_tail(arrays, arrays_goals, [])
+      
+      msg = 'Wrong method called to unify [[1, *[2, 3]], [4], [7, ...]]'
+      
+      assert_equal        [msg],      g1.log
+      assert_equal        [msg],      g2.log
+      assert_equal        [msg],      g3.log
+    end
+    
+    it 'should process more than two arrays that are a non-headtail' do
+      arrays = [
+        [1, 2, Tail.new([3,4])],
+        [:a, :b]/:c,
+        [:d, :e, UNKNOWN_TAIL],
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      assert        arrays.all?{|array| has_tail?(array, false) }
+      assert        arrays.map(&:headtail?).map(&:!).all?
+      
+      merged, unifications = unify_tail_with_tail(arrays, arrays_goals, [])
+      
+      expected_merged = [1,2,3,4]
+      
+      expected_unifications = [
+        [g2.variable(:a), g1.value(1),          g2, g1],
+        [g3.variable(:d), g1.value(1),          g3, g1],
+        [g2.variable(:a), g3.variable(:d),      g2, g3],
+        [g2.variable(:b), g1.value(2),          g2, g1],
+        [g3.variable(:e), g1.value(2),          g3, g1],
+        [g2.variable(:b), g3.variable(:e),      g2, g3],
+        [g2.variable(:c), g1.variablise([3,4]), g2, g1],
+      ]
+      
+      assert_equal  expected_merged,        merged
+      assert_equal  expected_unifications,  unifications
+    end
+    
+    it 'should unify arrays of different lengths' do
+      arrays = [
+        [1,   2,   UNKNOWN_TAIL],
+        [nil, nil, 3,   4,   UNKNOWN_TAIL],
+        [nil, nil, nil, nil, 5, 6, UNKNOWN_TAIL],
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      assert        arrays.all?{|array| has_tail?(array) }
+      assert        arrays.map(&:headtail?).map(&:!).all?
+      
+      merged, unifications = unify_tail_with_tail(arrays, arrays_goals, [])
+      
+      expected_merged = [
+        g1.value(1),
+        g1.value(2),
+        g2.value(3),
+        g2.value(4),
+        g3.value(5),
+        g3.value(6),
+        UNKNOWN_TAIL,
+      ]
+      
+      expected_unifications = [
+      ]
+      
+      assert_equal expected_merged,       merged
+      assert_equal expected_unifications, unifications
+    end
+    
+    it 'should unify all combinations of tails and tails' do
+      arrays = [
+        [:a,:b]/:c,
+        [:d,:e]/:f,
+        [:g,:h]/:i,
+        [:j,:k]/:l,
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      assert        arrays.all?{|array| has_tail?(array) }
+      assert        arrays.map(&:headtail?).map(&:!).all?
+      
+      merged, unifications = unify_tail_with_tail(arrays, arrays_goals, [])
+      
+      expected_merged = [nil, nil, UNKNOWN_TAIL]
+      
+      expected_unifications = [
+        [g1[:a], g2[:d], g1, g2],
+        [g1[:a], g3[:g], g1, g3],
+        [g1[:a], g4[:j], g1, g4],
+        [g2[:d], g3[:g], g2, g3],
+        [g2[:d], g4[:j], g2, g4],
+        [g3[:g], g4[:j], g3, g4],
+        [g1[:b], g2[:e], g1, g2],
+        [g1[:b], g3[:h], g1, g3],
+        [g1[:b], g4[:k], g1, g4],
+        [g2[:e], g3[:h], g2, g3],
+        [g2[:e], g4[:k], g2, g4],
+        [g3[:h], g4[:k], g3, g4],
+        [g1[:c], g2[:f], g1, g2],
+        [g1[:c], g3[:i], g1, g3],
+        [g1[:c], g4[:l], g1, g4],
+        [g2[:f], g3[:i], g2, g3],
+        [g2[:f], g4[:l], g2, g4],
+        [g3[:i], g4[:l], g3, g4],
+      ]
+      
+      assert_equal expected_merged,       merged
+      assert_equal expected_unifications, unifications
+    end
+    
+    it 'should not unify ununifiable arrays' do
+      arrays = [
+        [1,2,3,4,UNKNOWN_TAIL],
+        [1,4,3,2,UNKNOWN_TAIL],
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      assert        arrays.all?{|array| has_tail?(array) }
+      assert        arrays.map(&:headtail?).map(&:!).all?
+      
+      assert_nil    unify_tail_with_tail(arrays, arrays_goals, []), name
+      
+      expected_log = [
+        'Cannot unify incompatible values: 2 with 4',
+        'Cannot unify Goal1.2 with Goal2.4',
+      ]
+      
+      arrays_goals.each do |goal|
+        assert_equal    expected_log,   goal.log
+      end
+    end
+    
+  end
+  
+  describe '#unify_headtail_with_tail' do
+    
+    let(:g1)    { new_goal(:p, :x, :y) }
+    let(:g2)    { new_goal(:q, :a, :b) }
+    let(:g3)    { new_goal(:r, :s, :t) }
+    let(:g4)    { new_goal(:j, :k, :l) }
+    let(:goals) { [g1, g2, g3, g4]     }
+    
+    it 'should reject a non-tail array' do
+      arrays = [
+        [1,Tail.new([2,3])],
+        [4],
+        [1,2,3,7,UNKNOWN_TAIL],
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      refute              arrays.all?{|array| has_tail?(array) }
+      
+      assert_nil          unify_headtail_with_tail(arrays, arrays_goals, [])
+      
+      msg = 'Wrong method called to unify [[1, *[2, 3]], [4], [1, 2, 3, 7, ...]]'
+      
+      assert_equal        [msg],      g1.log
+      assert_equal        [msg],      g2.log
+      assert_equal        [msg],      g3.log
+    end
+    
+    it 'should unify more than two arrays that have a tail' do
+      arrays = [
+        [1,  Tail.new([2,3])],
+        [:a, :b]/:f,
+        [:c, UNKNOWN_TAIL],
+        [:d, :e, UNKNOWN_TAIL]
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      assert              arrays.all?{|array| has_tail?(array, false) }
+      
+      merged, unifications = unify_headtail_with_tail(arrays, arrays_goals, [])
+      
+      expected_merged = [1,2,3]
+      
+      expected_unifications = [
+        [g3[:c], g1[1],   g3, g1],
+        [g2[:a], g4[:d],  g2, g4],
+        [g2[:b], g4[:e],  g2, g4],
+        [g2[:a], g1[1],   g2, g1],
+        [g2[:b], g1[2],   g2, g1],
+        [g2[:f], [3],     g2, g1],
+        [g4[:d], g1[1],   g4, g1],
+        [g4[:e], g1[2],   g4, g1],
+        [g3[:c], g2[:a],  g3, g2],
+        [g3[:c], g4[:d],  g3, g4]
+      ]
+      
+      assert_equal expected_merged,       merged
+      assert_equal expected_unifications, unifications
+    end
+    
+    it 'should unify unifiable arrays with different length tails' do
+      arrays = [
+        [1,  UNKNOWN_TAIL],
+        [:a, :b, :c, :d]/:f,
+        [:c, UNKNOWN_TAIL],
+        [:d, 2, UNKNOWN_TAIL]
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      assert              arrays.all?{|array| has_tail?(array, false) }
+      
+      merged, unifications = unify_headtail_with_tail(arrays, arrays_goals, [])
+      
+      expected_merged = [1,2,nil,nil,UNKNOWN_TAIL]
+      
+      expected_unifications = [
+        [g3[:c], g1[1],   g3, g1],
+        [g2[:a], g4[:d],  g2, g4],
+        [g2[:b], g4[2],   g2, g4],
+        [g2[:a], g1[1],   g2, g1],
+        [g4[:d], g1[1],   g4, g1],
+        [g3[:c], g2[:a],  g3, g2],
+        [g3[:c], g4[:d],  g3, g4],
+      ]
+      
+      assert_equal expected_merged,       merged
+      assert_equal expected_unifications, unifications
+    end
+    
+    it 'should not unify unifiable heads across a headtail and an array with a tail' do
+      g1.instantiate :h, 1
+      g2.instantiate :h, 2
+      arrays = [
+        [:h]/:t,
+        [:h,:b]/:t,
+        [:h]/:t,
+        [:h]/:t,
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      assert              arrays.all?{|array| has_tail?(array, false) },  'all arrays should have a tail'
+      refute              arrays.map(&:headtail?).all?,                   'not all arrays should be a headtail array'
+      refute              arrays.map(&:headtail?).map(&:!).all?,          'not all arrays should be an array with a tail'
+      
+      assert_nil          unify_headtail_with_tail(arrays, arrays_goals, []), name
+      
+      assert_equal [
+        'Cannot unify because 1 != 2 (variable != variable)',
+        'Cannot unify heads: Goal1.:h with Goal2.:h',
+      ],   g1.log
+      assert_equal [
+        'Cannot unify because 1 != 2 (variable != variable)',
+        'Cannot unify heads: Goal1.:h with Goal2.:h',
+      ],   g2.log
+      assert_equal [
+      ],   g3.log
+      assert_equal [
+      ],   g4.log
+    end
+    
+    it 'should not unify tails with different values' do
+      g1.instantiate :t, [2,3]
+      g2.instantiate :t, [2,4]
+      g3.instantiate :t, 4
+      arrays = [
+        [:h]/:t,
+        [:h]/:t,
+        [:h,:b]/:t,
+        [:h]/:t,
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      assert              arrays.all?{|array| has_tail?(array, false) },  'all arrays should have a tail'
+      refute              arrays.map(&:headtail?).all?,                   'not all arrays should be a headtail array'
+      refute              arrays.map(&:headtail?).map(&:!).all?,          'not all arrays should be an array with a tail'
+      
+      assert_nil          unify_headtail_with_tail(arrays, arrays_goals, []), name
+      
+      assert_equal [
+        'Cannot unify because [2, 3] != [2, 4] (variable != variable)',
+        'Cannot unify headtail tails: Goal1.:t with Goal2.:t',
+        'Could not unify headtail arrays: [Goal1.:h, Goal1.2, Goal1.3] with [Goal2.:h, Goal2.2, Goal2.4] with [Goal4.:h, *Goal4.:t]',
+      ],   g1.log
+      assert_equal [
+        'Cannot unify because [2, 3] != [2, 4] (variable != variable)',
+        'Cannot unify headtail tails: Goal1.:t with Goal2.:t',
+        'Could not unify headtail arrays: [Goal1.:h, Goal1.2, Goal1.3] with [Goal2.:h, Goal2.2, Goal2.4] with [Goal4.:h, *Goal4.:t]',
+      ],   g2.log
+      assert_equal        [
+      ],   g3.log
+      assert_equal        [
+        'Could not unify headtail arrays: [Goal1.:h, Goal1.2, Goal1.3] with [Goal2.:h, Goal2.2, Goal2.4] with [Goal4.:h, *Goal4.:t]',
+      ],   g4.log
+    end
+    
+    it 'should not unify variable length arrays that have been instantiatd to different lengths' do
+      g1.instantiate :t, [2,3]
+      g2.instantiate :t, 3
+      g3.instantiate :t, [2,3,4]
+      arrays = [
+        [:h]/:t,
+        [:h,:b]/:t,
+        [:h]/:t,
+        [:h]/:t,
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      assert              arrays.all?{|array| has_tail?(array, false) },  'all arrays should have a tail'
+      refute              arrays.map(&:headtail?).all?,                   'not all arrays should be a headtail array'
+      refute              arrays.map(&:headtail?).map(&:!).all?,          'not all arrays should be an array with a tail'
+      
+      assert_nil      unify_headtail_with_tail(arrays, arrays_goals, []), name
+      
+      assert_equal [
+      ], g1.log
+      assert_equal [
+      ], g2.log
+      assert_equal [
+        'Cannot unify [Goal3.:h, Goal3.2, Goal3.3, Goal3.4] because it has a different length from 3'
+      ], g3.log
+      assert_equal [
+      ], g4.log
+    end
+    
+    it 'should not unify incompatible tails' do
+      g1.instantiate :t, [2,3]
+      g2.instantiate :b, 2
+      g2.instantiate :t, [3]
+      g3.instantiate :t, [4]
+      arrays = [
+        [:h]/:t,
+        [:h,:b]/:t,
+        [:h,:b]/:t,
+        [:h]/:t,
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      assert              arrays.all?{|array| has_tail?(array, false) },  'all arrays should have a tail'
+      refute              arrays.map(&:headtail?).all?,                   'not all arrays should be a headtail array'
+      refute              arrays.map(&:headtail?).map(&:!).all?,          'not all arrays should be an array with a tail'
+      
+      assert_nil    unify_headtail_with_tail(arrays, arrays_goals, []), name
+      
+      assert_equal [
+      ], g1.log
+      assert_equal [
+        'Cannot unify incompatible values: 3 with 4',
+        'Cannot unify: [3] with [4]',
+      ], g2.log
+      assert_equal [
+        'Cannot unify incompatible values: 3 with 4',
+        'Cannot unify: [3] with [4]',
+      ], g3.log
+      assert_equal [
+      ], g4.log
+    end
+    
+    it 'should expand tails that overlap extended heads' do
+      g1.instantiate :t, [3,3]
+      g2.instantiate :b, 2
+      g2.instantiate :t, [3]
+      arrays = [
+        [:h]/:t,
+        [:h,:b]/:t,
+        [:h,:b]/:t,
+        [:h]/:t,
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      assert              arrays.all?{|array| has_tail?(array, false) },  'all arrays should have a tail'
+      refute              arrays.map(&:headtail?).all?,                   'not all arrays should be a headtail array'
+      refute              arrays.map(&:headtail?).map(&:!).all?,          'not all arrays should be an array with a tail'
+      
+      assert_nil        unify_headtail_with_tail(arrays, arrays_goals, []), name
+      
+      assert_equal [
+        'Cannot unify incompatible values: 3 with 2',
+        'Cannot unify because Goal1.[3, 3] != [Goal2.:b, *Goal2.:t] (variable/array != array)',
+        'Cannot unify tails: Goal1.:t with [Goal2.:b, *Goal2.:t]',
+      ], g1.log
+      assert_equal [
+        'Cannot unify incompatible values: 3 with 2',
+        'Cannot unify because Goal1.[3, 3] != [Goal2.:b, *Goal2.:t] (variable/array != array)',
+        'Cannot unify tails: Goal1.:t with [Goal2.:b, *Goal2.:t]',
+      ], g2.log
+      assert_equal [
+      ], g3.log
+      assert_equal [
+      ], g4.log
+    end
+    
+    it 'prioritises X over Y when merging' do
+      # -- atomic over known array over non-array over unknown array/tail --
+      # atomic over known
+      #             known array over non-array
+      #                              non-array over unknown array/tail
+      # atomic over                  non-array
+      #                   array over                unknown array/tail
+      # atomic over                                 unknown array/tail
+      
+      g1.instantiate :t, [1,2,3]
+      arrays = [
+        :h/:t,
+        UNKNOWN_ARRAY,
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      merged, unifications = unify_headtail_with_tail(arrays, arrays_goals, [])
+      
+      expected_merged       = [nil, 1, 2, 3]
+      expected_unifications = []
+      
+      assert_equal expected_merged,       merged
+      assert_equal expected_unifications, unifications
+    end
+    
+  end
+  
+  describe '#unify_headtail_with_headtail' do
+    
+    let(:g1)    { new_goal(:p, :x, :y) }
+    let(:g2)    { new_goal(:q, :a, :b) }
+    let(:g3)    { new_goal(:r, :s, :t) }
+    let(:g4)    { new_goal(:j, :k, :l) }
+    let(:goals) { [g1, g2, g3, g4]     }
+    
+    it 'should reject a non-headtail array' do
+      arrays = [
+        [1,Tail.new([2,3])],
+        [4],
+        [7,UNKNOWN_TAIL],
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      refute              arrays.all?(&:headtail?)
+      
+      assert_nil          unify_headtail_with_headtail(arrays, arrays_goals, [])
+      
+      msg = 'Wrong method called to unify [[1, *[2, 3]], [4], [7, ...]]'
+      
+      arrays_goals.each do |goal|
+        assert_equal        [msg],      goal.log
+      end
+    end
+    
+    it 'should not unify unequal heads' do
+      arrays = [
+        [1,Tail.new([2,3])],
+        [4]/:y,
+        [7,UNKNOWN_TAIL],
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      assert              arrays.all?(&:headtail?), "arrays should all be headtails: #{arrays.reject(&:headtail?).map(&:inspect).join(' and ')}"
+      
+      assert_nil          unify_headtail_with_headtail(arrays, arrays_goals, [])
+      
+      assert_equal [
+        'Cannot unify because 1 != 4 (atomic != atomic)',
+        'Cannot unify headtail heads: "1 with 4"',
+      ], g1.log
+      assert_equal [
+        'Cannot unify because 1 != 4 (atomic != atomic)',
+        'Cannot unify headtail heads: "1 with 4"',
+      ], g2.log
+      assert_equal [
+      ], g3.log
+    end
+    
+    it 'should process more than two arrays that are a headtail' do
+      arrays = [
+        [1, Tail.new([2,3])],
+        [:a]/:f,
+        [:c, UNKNOWN_TAIL],
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      assert              arrays.all?(&:headtail?)
+      
+      merged, unifications = unify_headtail_with_headtail(arrays, arrays_goals, [])
+      
+      expected_merged = [1,2,3]
+      
+      expected_unifications = [
+        [:a, 1,             g2, g1],
+        [:f, [2,3],         g2, g1],
+        [:c, 1,             g3, g1],
+        [:a, :c,            g2, g3],
+        [:f, UNKNOWN_TAIL,  g2, g3],
+      ]
+      
+      assert_equal expected_merged,       merged
+      assert_equal expected_unifications, unifications
+      
+      arrays_goals.each do |goal|
+        assert_equal        [],         goal.log
+      end
+    end
+    
+    it 'should unify all combinations of heads and tails' do
+      arrays = [
+        [:a]/:b,
+        [:c]/:d,
+        [:e]/:f,
+        [:g]/:h,
+      ]
+      arrays_goals = goals[0...arrays.size]
+      
+      assert              arrays.all?(&:headtail?)
+      
+      merged, unifications = unify_headtail_with_headtail(arrays, arrays_goals, [])
+      
+      expected_merged = [nil, UNKNOWN_TAIL]
+      
+      expected_unifications = [
+        [:a, :c, g1, g2],
+        [:b, :d, g1, g2],
+        [:a, :e, g1, g3],
+        [:b, :f, g1, g3],
+        [:a, :g, g1, g4],
+        [:b, :h, g1, g4],
+        [:c, :e, g2, g3],
+        [:d, :f, g2, g3],
+        [:c, :g, g2, g4],
+        [:d, :h, g2, g4],
+        [:e, :g, g3, g4],
+        [:f, :h, g3, g4],
+      ]
+      
+      assert_equal expected_merged,       merged
+      assert_equal expected_unifications, unifications
+      
+      arrays_goals.each do |goal|
+        assert_equal        [],         goal.log
+      end
+    end
+    
+  end
+  
+  describe '#builtin' do
+    
+    it 'should create a Predicate' do
+      # -- Precondition Baseline --
+      assert_equal      0,                Scope[:default].predicates.size
+      
+      # -- Test --
+      single_predicate = builtin :member
+      
+      # -- Compare Result Against Baseline --
+      assert_equal      1,                Scope[:default].predicates.size
+      assert_equal      :member,          Scope[:default].predicates.first.name
+      assert_Predicate  single_predicate, :member, []
+    end
+    
+    it 'should define a method to create Arguments for solving' do
+      Object.class_eval{
+        remove_method(:member) if public_method_defined?(:member)
+      }
+      
+      refute                    respond_to?(:member)
+      
+      builtin :member
+      
+      assert                    respond_to?(:member)
+      assert_Arguments          member(:X, ['left','right']),   :member, [:X, ['left','right']]
+      
+      assert_includes           methods,                        :member
+    end
+    
+    it 'should create multiple Predicates' do
+      assert_equal              0,        Scope[:default].predicates.size
+      
+      multiple_predicates = builtin :member, :append, :is
+      
+      assert_equal              3,        Scope[:default].predicates.size
+      assert_equal              :member,  Scope[:default].predicates[0].name
+      assert_equal              :append,  Scope[:default].predicates[1].name
+      assert_equal              :is,      Scope[:default].predicates[2].name
+      assert_instance_of        Array,    multiple_predicates
+      assert_equal              3,        multiple_predicates.size
+      assert_Predicate          multiple_predicates[0], :member,  []
+      assert_Predicate          multiple_predicates[1], :append,  []
+      assert_Predicate          multiple_predicates[2], :is,      []
+    end
+    
+    it 'should define multiple methods to create Arguments for solving' do
+      Object.class_eval{
+        remove_method(:member) if public_method_defined?(:member)
+        remove_method(:append) if public_method_defined?(:append)
+      }
+      
+      refute                    respond_to?(:member)
+      refute                    respond_to?(:append)
+      
+      builtin :member, :append
+      
+      assert                    respond_to?(:member)
+      assert                    respond_to?(:append)
+      assert_Arguments          member(:X, :L),       :member, [:X, :L]
+      assert_Arguments          append(:A, :B, :AB),  :append, [:A, :B, :AB]
+    end
+    
+    it 'should define a method in a base class as an instance method and a class method' do
+      Object.class_eval{
+        remove_method(:member) if public_method_defined?(:member)
+      }
+      
+      class Base2 ; end
+      
+      refute_includes   Base2.methods,            :member
+      refute_includes   Base2.instance_methods,   :member
+      
+      builtin :member, class_base: Base2
+      
+      assert_includes   Base2.methods,            :member
+      assert_includes   Base2.instance_methods,   :member
+      
+      refute_includes   methods,                  :member
+      
+      class Base2
+        def process
+          member(:X, [4,5,6]).solve_for(:X)
+        end
+      end
+      
+      assert_solutions    Base2.member(:X, [1,2,3]),  [
+        { X: 1 },
+        { X: 2 },
+        { X: 3 },
+      ]
+      
+      assert_equal        [4,5,6],    Base2.new.process
+    end
+    
+  end
+  
+  describe '#_' do
+    
+    let(:goal)  { new_goal :p, :x, :y }
+    
+    it 'should return a different variable on each call' do
+      # _ is overridden by MiniTest
+      variable1 = Porolog._
+      variable2 = Porolog._
+      variable3 = Porolog._
+      
+      assert_equal    :_a,            variable1
+      assert_equal    :_b,            variable2
+      assert_equal    :_c,            variable3
+      
+      refute_equal    variable1,      variable2
+      refute_equal    variable2,      variable3
+      refute_equal    variable3,      variable1
+    end
+    
   end
   
 end