porolog 0.0.7 → 0.0.8

data/test/porolog/core_ext_test.rb

@@ -53,15 +53,14 @@ describe 'Object' do
   
   describe '#/' do
     
-    it 'should create a n Array with a Tail' do
-      skip 'until Variable added'
+    it 'should create an n Array with a Tail' do
       assert_Array_with_Tail    object1 / :T,     [object1], '*:T'
       assert_Array_with_Tail    [object2] / :T,   [object2], '*:T'
-      assert_Array_with_Tail    object2.tail(:T), [object2], '*:T'
+      #assert_Array_with_Tail    object2.tail(:T), [object2], '*:T'
       assert_Array_with_Tail    object3 / :T,     [object3], '*:T'
       assert_Array_with_Tail    object4 / :T,     [object4], '*:T'
       assert_Array_with_Tail    [object5] / :T,   [object5], '*:T'
-      assert_Array_with_Tail    object2.tail(:T), [object5], '*:T'
+      #assert_Array_with_Tail    object5.tail(:T), [object5], '*:T'
     end
     
   end
@@ -115,7 +114,6 @@ describe 'Symbol' do
   describe '#/' do
     
     it 'should create a HeadTail' do
-      skip 'until Variable added'
       assert_Array_with_Tail    symbol1 / :T,     [symbol1], '*:T'
       assert_Array_with_Tail    symbol2 / :T,     [symbol2], '*:T'
       assert_Array_with_Tail    symbol3 / :T,     [symbol3], '*:T'
@@ -136,8 +134,21 @@ describe 'Array' do
   
   describe '#/' do
     
+    it 'creates an Array using the slash notation with Arrays' do
+      head_tail = [1] / [2,3,4,5]
+      
+      assert_equal              [1,2,3,4,5],      head_tail
+    end
+    
+    it 'should combine a head Array and a tail Array when they have no variables' do
+      assert_equal    [1,2,3,4,5,6],              [1,2,3] / [4,5,6]
+    end
+    
+    it 'should combine an embedded head Array and an embedded tail Array when they have no variables' do
+      assert_equal    [1,2,3,4,5,6,7,8,9],        [1,2,3] / [4,5,6] / [7,8,9]
+    end
+    
     it 'should create a HeadTail' do
-      skip 'until Variable added'
       assert_Array_with_Tail    array1 / :T,      array1, '*:T'
       assert_Array_with_Tail    array2 / :T,      array2, '*:T'
       assert_Array_with_Tail    array3 / :T,      array3, '*:T'
@@ -149,7 +160,6 @@ describe 'Array' do
   describe '#variables' do
     
     it 'should return an array of the embedded Symbols' do
-      skip 'until Tail added'
       assert_equal    [:A, :B, :C],     array1.variables
       assert_equal    [],               array2.variables
       assert_equal    [],               array3.variables
@@ -161,7 +171,6 @@ describe 'Array' do
   describe '#value' do
     
     it 'should return simple Arrays as is' do
-      skip 'until Tail added'
       assert_equal    [1, 2, :A, 4, [:B, 6, 7, :C], 9],     array1.value
       assert_equal    [],                                   array2.value
       assert_equal    [UNKNOWN_TAIL],                       array3.value
@@ -169,14 +178,12 @@ describe 'Array' do
     end
     
     it 'should expand Tails that are an Array' do
-      skip 'until Tail added'
       array = [1,2,3,Tail.new([7,8,9])]
       
       assert_equal    [1,2,3,7,8,9],                        array.value
     end
     
     it 'should return the value of instantiated variables in a Tail' do
-      skip 'until Variable added'
       goal  = new_goal :tailor, :h, :t
       array = goal.variablise([:h, :b] / :t)
       goal.instantiate :h, [1,2,3]
@@ -185,12 +192,18 @@ describe 'Array' do
       assert_equal    [goal.value([1,2,3]),goal.variable(:b), goal.value(7), goal.value(8), goal.value(9)],     array.value
     end
     
+    it 'should return the value of instantiated variables in a Tail' do
+      goal  = new_goal :taylor, :head, :tail
+      array = [Tail.new(goal.value([5,6,7,8]))]
+      
+      assert_equal    [5,6,7,8],                            array.value
+    end
+    
   end
   
   describe '#type' do
     
     it 'should return :variable for symbols' do
-      skip 'until Tail added'
       assert_equal    :array,           array1.type
       assert_equal    :array,           array2.type
       assert_equal    :array,           array3.type
@@ -202,7 +215,6 @@ describe 'Array' do
   describe '#head' do
     
     it 'should return the first element when no headsize is provided' do
-      skip 'until Tail added'
       assert_equal    1,                array1.head
       assert_nil                        array2.head
       assert_nil                        array3.head
@@ -210,7 +222,6 @@ describe 'Array' do
     end
     
     it 'should return the first headsize elements' do
-      skip 'until Tail added'
       assert_equal    [1, 2],           array1.head(2)
       assert_equal    [],               array2.head(2)
       assert_equal    [UNKNOWN_TAIL],   array3.head(2)
@@ -218,7 +229,6 @@ describe 'Array' do
     end
     
     it 'should return an extended head if the tail is uninstantiated' do
-      skip 'until Tail added'
       assert_equal    [1, 2, :A, 4, [:B, 6, 7, :C], 9],   array1.head(9)
       assert_equal    [],                                 array2.head(9)
       assert_equal    [UNKNOWN_TAIL],                     array3.head(9)
@@ -230,7 +240,6 @@ describe 'Array' do
   describe '#tail' do
     
     it 'should return the tail after the first element when no headsize is provided' do
-      skip 'until Tail added'
       assert_equal    [2, :A, 4, [:B, 6, 7, :C], 9],      array1.tail
       assert_equal    [],                                 array2.tail
       assert_equal    [UNKNOWN_TAIL],                     array3.tail
@@ -238,7 +247,6 @@ describe 'Array' do
     end
     
     it 'should return the tail after the first headsize elements' do
-      skip 'until Tail added'
       assert_equal    [:A, 4, [:B, 6, 7, :C], 9],         array1.tail(2)
       assert_equal    [],                                 array2.tail(2)
       assert_equal    [UNKNOWN_TAIL],                     array3.tail(2)
@@ -246,7 +254,6 @@ describe 'Array' do
     end
     
     it 'should return an extended tail if the tail is uninstantiated' do
-      skip 'until Tail added'
       assert_equal    [],                                 array1.tail(9)
       assert_equal    [],                                 array2.tail(9)
       assert_equal    [UNKNOWN_TAIL],                     array3.tail(9)

data/test/porolog/goal_test.rb

@@ -16,6 +16,10 @@ describe 'Porolog' do
 
   describe 'Goal' do
     
+    let(:pred) { Predicate.new :p }
+    let(:args) { pred.(:x,:y) }
+    let(:goal) { Goal.new args }
+    
     describe '.reset' do
       
       it 'should clear all goals' do
@@ -45,10 +49,6 @@ describe 'Porolog' do
         Goal.reset
       end
       
-      it 'should clear the goal cache' do
-        # TECH-CREDIT: Probably not going to use a cache; we'll see ...
-      end
-      
     end
     
     describe '.goals' do
@@ -58,17 +58,14 @@ describe 'Porolog' do
         
         goal1 = new_goal :predicate1, :a
         
-        assert_equal  1,                      Goal.goals.size
         assert_equal  [goal1],                Goal.goals
         
         goal2 = new_goal :predicate2, :a, :b
         
-        assert_equal  2,                      Goal.goals.size
         assert_equal  [goal1,goal2],          Goal.goals
         
         goal3 = new_goal :predicate3, :a, :b, :c
         
-        assert_equal  3,                      Goal.goals.size
         assert_equal  [goal1,goal2,goal3],    Goal.goals
       end
       
@@ -87,9 +84,6 @@ describe 'Porolog' do
     describe '#initialize' do
       
       it 'should initialize calling_goal' do
-        pred = Predicate.new :p
-        args = pred.(:x,:y)
-        
         goal1 = Goal.new args
         goal2 = Goal.new args, goal1
         
@@ -101,40 +95,112 @@ describe 'Porolog' do
       end
       
       it 'should initialize arguments' do
-        pred = Predicate.new :p
-        args = pred.(:x,:y)
-        
         goal = Goal.new args, nil
         
-        assert_equal  args,     goal.arguments
+        assert_equal  goal.variablise(args),      goal.arguments
       end
       
       it 'should initialize terminate' do
-        pred = Predicate.new :p
-        args = pred.(:x,:y)
-        
         goal = Goal.new args, nil
         
-        assert_equal  false,    goal.terminate
+        assert_equal  false,                      goal.terminated?
       end
       
       it 'should initialize variables' do
-        pred = Predicate.new :p
-        args = pred.(:x,:y)
-        
         goal = Goal.new args, nil
         
-        assert_Goal_variables   goal, {}, ''
+        assert_Goal_variables   goal, { x: nil, y: nil }, [
+          'Goal1.:x',
+          'Goal1.:y',
+        ].join("\n")
       end
       
       it 'should register the goal as undeleted' do
-        pred = Predicate.new :p
-        args = pred.(:x,:y)
+        goal1 = Goal.new args, nil
+        goal2 = Goal.new args, goal1
         
+        assert_equal  [goal1,goal2],              Goal.goals
+      end
+      
+    end
+    
+    describe '#myid' do
+      
+      it 'should return the pretty id of the goal' do
         goal1 = Goal.new args, nil
         goal2 = Goal.new args, goal1
         
-        assert_equal  [goal1,goal2],    Goal.goals
+        assert_equal  'Goal1',          goal1.myid
+        assert_equal  'Goal2',          goal2.myid
+      end
+      
+    end
+
+    describe '#ancestors' do
+      
+      it 'should return an Array of the parent goals' do
+        goal1 = Goal.new args
+        goal2 = Goal.new args, goal1
+        goal3 = Goal.new args, goal2
+        goal4 = Goal.new args, goal3
+        
+        assert_equal  [goal1],                          goal1.ancestors
+        assert_equal  [goal1, goal2],                   goal2.ancestors
+        assert_equal  [goal1, goal2, goal3],            goal3.ancestors
+        assert_equal  [goal1, goal2, goal3, goal4],     goal4.ancestors
+      end
+      
+    end
+    
+    describe '#ancestry' do
+      
+      it 'should return an Array of the parent goals' do
+        goal1 = Goal.new args
+        goal2 = Goal.new args, goal1
+        goal3 = Goal.new args, goal2
+        goal4 = Goal.new args, goal3
+        
+        ancestors = [
+          'Goal1 -- Solve p(:x,:y)  {:x=>nil, :y=>nil}',
+          '  Goal2 -- Solve p(:x,:y)  {:x=>nil, :y=>nil}',
+          '    Goal3 -- Solve p(:x,:y)  {:x=>nil, :y=>nil}',
+          '      Goal4 -- Solve p(:x,:y)  {:x=>nil, :y=>nil}',
+        ]
+        
+        assert_equal  ancestors[0...1].join("\n"),      goal1.ancestry
+        assert_equal  ancestors[0...2].join("\n"),      goal2.ancestry
+        assert_equal  ancestors[0...3].join("\n"),      goal3.ancestry
+        assert_equal  ancestors[0...4].join("\n"),      goal4.ancestry
+      end
+      
+    end
+    
+    describe '#inspect' do
+      
+      it 'should show a description of the goal' do
+        goal1 = Goal.new args
+        goal2 = Goal.new pred.(1,:b,'word'), goal1
+        goal3 = Goal.new args, goal2
+        goal4 = Goal.new args, goal3
+        
+        assert_equal  'Goal1 -- Solve p(:x,:y)',        goal1.inspect
+        assert_equal  'Goal2 -- Solve p(1,:b,"word")',  goal2.inspect
+        assert_equal  'Goal3 -- Solve p(:x,:y)',        goal3.inspect
+        assert_equal  'Goal4 -- Solve p(:x,:y)',        goal4.inspect
+      end
+      
+    end
+    
+    describe '#delete!' do
+      
+      it 'should delete the goal' do
+        goal1 = Goal.new args
+        goal2 = Goal.new pred.(1,:b,'word'), goal1
+        goal3 = Goal.new args, goal2
+        goal4 = Goal.new args, goal3
+        
+        assert                                          goal2.delete!, 'goal should delete'
+        assert_equal  [goal1, goal3, goal4],            Goal.goals
       end
       
     end
@@ -157,9 +223,6 @@ describe 'Porolog' do
     describe '#deleted?' do
       
       it 'should return the deleted state of a goal' do
-        pred = Predicate.new :p
-        args = pred.(:x,:y)
-        
         goal = Goal.new args
         
         refute    goal.deleted?, 'goal should not be deleted'
@@ -170,9 +233,6 @@ describe 'Porolog' do
       end
       
       it 'should memoize the deleted state of a goal' do
-        pred = Predicate.new :p
-        args = pred.(:x,:y)
-        
         goal = Goal.new args
         
         check_deleted_spy = Spy.on(goal, :check_deleted).and_call_through
@@ -197,11 +257,6 @@ describe 'Porolog' do
     describe '#check_deleted' do
       
       it 'should return false when the goal is not deleted and keep variables intact' do
-        skip 'until Variable added'
-        
-        pred = Predicate.new :p
-        args = pred.(:x,:y)
-        
         goal = Goal.new args
         goal.variable(:x)
         goal.variable(:y)
@@ -209,17 +264,12 @@ describe 'Porolog' do
         
         variable_remove_spy = Spy.on_instance_method(Variable, :remove)
         
-        refute  goal.check_deleted
+        refute  goal.check_deleted, 'goal should not be deleted'
         
         assert_equal    0,    variable_remove_spy.calls.size
       end
       
       it 'should return true when the goal is deleted and remove all variables' do
-        skip 'until Variable added'
-        
-        pred = Predicate.new :p
-        args = pred.(:x,:y)
-        
         goal = Goal.new args
         goal.variable(:x)
         goal.variable(:y)
@@ -229,21 +279,83 @@ describe 'Porolog' do
         
         Goal.reset
         
-        assert  goal.check_deleted
+        assert  goal.check_deleted, 'goal should be deleted'
         
         assert_equal    3,    variable_remove_spy.calls.size
       end
       
     end
     
-    describe '#variables' do
+    describe '#terminate!' do
       
-      it 'should return a Hash of variables and their values' do
-        skip 'until Variable added'
+      it 'should set the goal to terminate and log the event' do
+        goal = Goal.new args
         
-        pred = Predicate.new :p
-        args = pred.(:x,:y)
+        assert          goal.terminate!,      'the goal should be set to terminate'
+        assert_equal    ['terminating'],      goal.log
+      end
+      
+    end
+    
+    describe '#terminated?' do
+      
+      it 'should return whether the goal is set to terminate or not' do
+        goal = Goal.new args
         
+        refute          goal.terminated?,     'the goal should not be initialized to terminate'
+        assert          goal.terminate!,      'the goal should be set to terminate'
+        assert          goal.terminated?,     'the goal should be set to terminate'
+      end
+      
+    end
+    
+    describe '#variablise' do
+      
+      it 'should convert a Symbol into a Variable' do
+        assert_Variable   goal.variablise(:k),  :k, goal, [], []
+      end
+      
+      it 'should return a Variable as is' do
+        v = Variable.new :r, goal
+        assert_equal      v,                goal.variablise(v)
+      end
+      
+      it 'should convert an Array into a Variables and Objects' do
+        assert_equal      [goal.value(1),goal.variable(:a),goal.value('word')],   goal.variablise([1,:a,'word'])
+      end
+      
+      it 'should return a duplicate of an Arguments' do
+        duplicate = goal.variablise(args)
+        assert_Arguments  duplicate,  :p, goal.variablise([:x, :y])
+        refute_equal      args,       duplicate
+      end
+      
+      it 'should convert a Tail into a Tail with a variablised value' do
+        assert_Tail       goal.variablise(Tail.new :m),  '*Goal1.:m'
+      end
+      
+      it 'should return a Value as is' do
+        v = Value.new(45, goal)
+        assert_equal      v,                goal.variablise(v)
+      end
+      
+      it 'should return an unknown array as is' do
+        assert_equal      UNKNOWN_ARRAY,    goal.variablise(UNKNOWN_ARRAY)
+      end
+      
+      it 'should return an unknown tail as is' do
+        assert_equal      UNKNOWN_TAIL,     goal.variablise(UNKNOWN_TAIL)
+      end
+      
+      it 'should convert any other Object into a Value' do
+        assert_Value      goal.variablise(23.61),  23.61, goal
+      end
+      
+    end
+    
+    describe '#variables' do
+      
+      it 'should return a Hash of variables and their values' do
         goal = Goal.new args
         goal.variable(:x)
         goal.variable(:y)
@@ -254,26 +366,148 @@ describe 'Porolog' do
         assert_instance_of      Hash, variables
         
         assert_Goal             goal, :p, [:x,:y]
-        assert_Goal_variables   goal, { x: nil, y: nil, z: nil }, ''
+        assert_Goal_variables   goal, { x: nil, y: nil, z: nil }, [
+          'Goal1.:x',
+          'Goal1.:y',
+          'Goal1.:z',
+        ].join("\n")
       end
       
     end
     
-    describe '#variable' do
+    describe '#inspect_variables' do
       
-      let(:pred) { Predicate.new :p }
-      let(:args) { pred.(:x,:y) }
-      let(:goal) { Goal.new args }
+      it 'should return a string showing the instantiations of the variables of the goal' do
+        # -- Initial Goal --
+        goal = Goal.new args
+        
+        x = goal.variable(:x)
+        y = goal.variable(:y)
+        z = goal.variable(:z)
+        
+        expected = [
+          'Goal1.:x',
+          'Goal1.:y',
+          'Goal1.:z',
+        ].join("\n")
+        
+        assert_equal    expected,     goal.inspect_variables
+        
+        # -- After First Instantiation --
+        #   x.head = y
+        x.instantiate y, nil, :head
+        
+        expected = [
+          'Goal1.:x',
+          '  [:head]Goal1.:y',
+          'Goal1.:y',
+          '  Goal1.:x[:head]',
+          'Goal1.:z',
+        ].join("\n")
+        
+        assert_equal    expected,     goal.inspect_variables
+        
+        # -- After Second Instantiation --
+        #   x.head = y
+        #   x.tail = z
+        x.instantiate z, nil, :tail
+        
+        expected = [
+          'Goal1.:x',
+          '  [:head]Goal1.:y',
+          '  [:tail]Goal1.:z',
+          'Goal1.:y',
+          '  Goal1.:x[:head]',
+          '    [:tail]Goal1.:z',
+          'Goal1.:z',
+          '  Goal1.:x[:tail]',
+          '    [:head]Goal1.:y',
+        ].join("\n")
+        
+        assert_equal    expected,     goal.inspect_variables
+        
+        # -- After Third Instantiation --
+        #   x = [*y, *z]
+        #   y = 1,2,3
+        y.instantiate goal.value([1,2,3])
+        
+        expected = [
+          'Goal1.:x',
+          '  [:head]Goal1.:y',
+          '    Goal1.[1, 2, 3]',
+          '  [:tail]Goal1.:z',
+          'Goal1.:y',
+          '  Goal1.:x[:head]',
+          '    [:tail]Goal1.:z',
+          '  Goal1.[1, 2, 3]',
+          'Goal1.:z',
+          '  Goal1.:x[:tail]',
+          '    [:head]Goal1.:y',
+          '      Goal1.[1, 2, 3]',
+        ].join("\n")
+        
+        assert_equal    expected,     goal.inspect_variables
+        
+        # -- After Fourth Instantiation --
+        #   x = [*y, *z]
+        #   y = 1,2,3
+        #   z = 4,5,6
+        z.instantiate goal.value([4,5,6])
+        
+        expected = [
+          'Goal1.:x',
+          '  [:head]Goal1.:y',
+          '    Goal1.[1, 2, 3]',
+          '  [:tail]Goal1.:z',
+          '    Goal1.[4, 5, 6]',
+          'Goal1.:y',
+          '  Goal1.:x[:head]',
+          '    [:tail]Goal1.:z',
+          '      Goal1.[4, 5, 6]',
+          '  Goal1.[1, 2, 3]',
+          'Goal1.:z',
+          '  Goal1.:x[:tail]',
+          '    [:head]Goal1.:y',
+          '      Goal1.[1, 2, 3]',
+          '  Goal1.[4, 5, 6]',
+        ].join("\n")
+        
+        assert_equal    expected,     goal.inspect_variables
+      end
       
-      it 'should return a non-variable as is' do
-        skip 'until Variable added'
+    end
+    
+    describe '#values' do
+      
+      it 'should return the values that have been associated with the goal' do
+        goal = Goal.new args
         
+        x = goal.variable(:x)
+        y = goal.variable(:y)
+        z = goal.variable(:z)
+        
+        x.instantiate y, nil, :head
+        x.instantiate z, nil, :tail
+        y.instantiate goal.value([1,2,3])
+        z.instantiate goal.value([4,5,6])
+        
+        expected = [
+          [1,2,3],
+          [4,5,6],
+        ]
+        
+        assert_equal    expected,     goal.values
+      end
+      
+    end
+    
+    describe '#variable' do
+      
+      it 'should return a non-variable as is' do
         assert_equal    4.132,    goal.variable(4.132)
       end
       
       it 'should create and find a variable from a Symbol or Variable' do
-        skip 'until Variable added'
-        
         refute    goal.variables.key?(:v), ':v should not be a variable'
         
         variable1 = goal.variable :v
@@ -292,26 +526,40 @@ describe 'Porolog' do
       
     end
     
-    describe '#value_of' do
+    describe '#value' do
       
-      let(:pred) { Predicate.new :p }
-      let(:args) { pred.(:x,:y) }
-      let(:goal) { Goal.new args }
+      it 'should create and find a value from an Object' do
+        refute    goal.values.include?(99.02), '99.02 should not be a value'
+        
+        value1 = goal.value 99.02
+        
+        assert    goal.values.include?(99.02), '99.02 should be a value'
+        
+        value2 = goal.value 99.02
+        
+        assert_Value    value1,       99.02, goal
+        assert_Value    value2,       99.02, goal
+        
+        assert_equal    [99.02],      goal.values
+      end
+      
+    end
+    
+    describe '#value_of' do
       
       describe 'when name is a Symbol' do
+        
         let(:variable_name) { :cymbal }
         
         it 'should create the Variable' do
-          skip 'until Variable added'
-          
           refute        goal.variables.key?(variable_name), "#{variable_name} should not exist"
           
-          assert_nil    goal.value_of(variable_name)
+          refute_nil    goal.value_of(variable_name)
           
           assert        goal.variables.key?(variable_name), "#{variable_name} should exist"
           
           variable       = goal.variable(variable_name)
-          variable.value = 44.5
+          variable.instantiate 44.5
           
           assert_equal      44.5,   goal.value_of(variable_name)
         end
@@ -319,6 +567,7 @@ describe 'Porolog' do
       end
       
       describe 'when name is not a Symbol' do
+        
         let(:variable_name) { 99.28 }
         
         it 'should return the name as the value' do
@@ -329,11 +578,55 @@ describe 'Porolog' do
       
     end
     
+    describe '#values_of' do
+      
+      it 'should return an Array with values_of applied to each element when given an Array' do
+        goal.instantiate :thomas, '$10'
+        
+        expected = [[1,'two'], '$10', 999, 'giraffe', 0.5]
+        
+        assert_equal    expected,     goal.values_of([[1,'two'], :thomas, 999, 'giraffe', 0.5])
+      end
+      
+      it 'should return the value_of the Variable when given a Variable' do
+        goal.instantiate :jones, 'Fuzzy'
+        
+        variable1 = goal.variable(:jones)
+        
+        assert_equal    'Fuzzy',      goal.values_of(variable1)
+      end
+      
+      it 'should return the value_of the Symbol when given a Symbol' do
+        goal.instantiate :x, 'Staunch'
+        
+        assert_equal    'Staunch',    goal.values_of(:x)
+      end
+      
+      it 'should return the value_of the Value when given a Value' do
+        value1 = goal.value(123.76)
+        
+        assert_equal    123.76,       goal.values_of(value1)
+      end
+      
+      it 'should somehow splat when given a Tail' do
+        tail1 = Tail.new ['apples','oranges','bananas']
+        
+        assert_equal    'apples',     goal.values_of(tail1)
+      end
+      
+      it 'should return the Object as is when given an Object' do
+        object = Object.new
+        
+        goal.expects(:value_of).times(0)
+        
+        assert_equal    object,     goal.values_of(object)
+      end
+      
+    end
+    
     describe '#solve' do
       
       it 'should find no solutions for a goal with no rules' do
-        skip 'until CoreExt added'
-        
         goal1 = new_goal :p, :x, :y
         
         solutions = goal1.solve
@@ -342,8 +635,6 @@ describe 'Porolog' do
       end
       
       it 'should solve a fact' do
-        skip 'until CoreExt added'
-        
         predicate :fact
         
         fact(42).fact!
@@ -354,8 +645,6 @@ describe 'Porolog' do
       end
       
       it 'should not solve a falicy' do
-        skip 'until CoreExt added'
-        
         predicate :fact
         
         fact(42).falicy!
@@ -366,8 +655,6 @@ describe 'Porolog' do
       end
       
       it 'should solve using head and tail with lists' do
-        skip 'until HeadTail added'
-        
         predicate :head_tail
         
         head_tail([1,2,3,4,5,6,7]).fact!
@@ -382,7 +669,8 @@ describe 'Porolog' do
       end
       
       it 'should solve a goal recursively' do
-        skip 'until HeadTail added'
+        #:nocov:
+        skip 'until Standard Predicates added'
         
         predicate :recursive
         
@@ -397,7 +685,126 @@ describe 'Porolog' do
           
           assert_equal    [{}], solutions
         end
+        #:nocov:
+      end
+      
+    end
+    
+    describe '#satisfy' do
+      
+      let(:block) { ->(subgoal){} }
+      
+      it 'should return false when the goal has no arguments' do
+        goal = Goal.new nil
+        
+        block.expects(:call).times(0)
+        
+        refute          goal.satisfy(&block),   name
+      end
+      
+      it 'should access the predicate of its arguments' do
+        goal.arguments.expects(:predicate).with().returns(nil).times(1)
+        block.expects(:call).times(0)
+        
+        assert_nil      goal.satisfy(&block),   name
+      end
+      
+      it 'should try to satisfy the predicate with itself' do
+        pred.expects(:satisfy).with(goal).returns(nil).times(1)
+        block.expects(:call).times(0)
+        
+        assert_nil      goal.satisfy(&block),   name
+      end
+      
+      it 'should call the block when the predicate is satisfied' do
+        pred.(1,2).fact!
+        pred.(3,4).fact!
+        pred.(5,6).fact!
+        
+        block.expects(:call).times(3)
+        
+        assert          goal.satisfy(&block),   name
+      end
+      
+    end
+    
+    describe '#instantiate' do
+      
+      it 'creates an Array with a Tail using the slash notation with Symbols with a goal' do
+        goal      = new_goal  :bravo, :x, :y, :z
+        
+        head_tail = goal.variablise(:head / :tail)
+        
+        assert_Array_with_Tail    head_tail,      [goal.variable(:head)], '*Goal1.:tail'
+        
+        assert_Goal_variables     goal, { x: nil, y: nil, z: nil, head: nil, tail: nil }, [
+          'Goal1.:x',
+          'Goal1.:y',
+          'Goal1.:z',
+          'Goal1.:head',
+          'Goal1.:tail',
+        ].join("\n")
+      end
+      
+      it 'creates an Array with a Tail using the slash notation with a single head with a goal' do
+        goal      = new_goal  :bravo, :x, :y, :z
+        
+        head_tail = goal.variablise([:head] / :tail)
+        
+        assert_Array_with_Tail    head_tail,      [goal.variable(:head)], '*Goal1.:tail'
+        
+        assert_Goal_variables     goal, { x: nil, y: nil, z: nil, head: nil, tail: nil }, [
+          'Goal1.:x',
+          'Goal1.:y',
+          'Goal1.:z',
+          'Goal1.:head',
+          'Goal1.:tail',
+        ].join("\n")
+      end
+      
+      it 'creates variables from its contents with a goal' do
+        predicate :bravo
+        arguments = Predicate[:bravo].arguments(:x,:y,:z)
+        goal      = arguments.goal
+        
+        head_tail = [:alpha,bravo(:a,:b,:c),[:carly]] / [:x,[:y],bravo(:p,:q/:r)]
+        
+        assert_equal  [:alpha,bravo(:a,:b,:c),[:carly], :x,[:y],bravo(:p,:q/:r)].inspect,    head_tail.inspect
+        
+        assert_Goal_variables   goal, { x: nil, y: nil, z: nil }, [
+          'Goal1.:x',
+          'Goal1.:y',
+          'Goal1.:z',
+        ].join("\n")
+        
+        head_tail = goal.variablise(head_tail)
+        
+        assert_equal  '[Goal1.:alpha, bravo(Goal1.:a,Goal1.:b,Goal1.:c), [Goal1.:carly], Goal1.:x, [Goal1.:y], bravo(Goal1.:p,[Goal1.:q, *Goal1.:r])]',    head_tail.inspect
+        
+        assert_Goal_variables   goal, { x: nil, y: nil, z: nil, alpha: nil, a: nil, b: nil, c: nil, carly: nil, p: nil, q: nil, r: nil }, [
+          'Goal1.:x',
+          'Goal1.:y',
+          'Goal1.:z',
+          'Goal1.:alpha',
+          'Goal1.:a',
+          'Goal1.:b',
+          'Goal1.:c',
+          'Goal1.:carly',
+          'Goal1.:p',
+          'Goal1.:q',
+          'Goal1.:r',
+        ].join("\n")
+      end
+      
+      it 'should combine Array value of head and Array value of tail when it has a goal' do
+        head_tail = [:first] / :last
+        
+        goal.instantiate :first, 'alpha',   goal
+        goal.instantiate :last,  ['omega'], goal
+        
+        head_tail = goal.values_of(goal.variablise(head_tail))
         
+        assert_equal    ['alpha','omega'],        head_tail
       end
       
     end