porolog 0.0.4 → 1.0.0

data/test/porolog/core_ext_test.rb

@@ -0,0 +1,290 @@
+#
+#   test/porolog/core_ext_test.rb     - Test Suite for Core Extensions
+#
+#     Luis Esteban      2 May 2018
+#       created
+#
+
+require_relative '../test_helper'
+
+describe 'Object' do
+  
+  let (:object1) { Object.new }
+  let (:object2) { 42 }
+  let (:object3) { { name: 'hello' } }
+  let (:object4) { 'abc' }
+  let (:object5) { 0.5 }
+  
+  describe '#myid' do
+    
+    it 'should return inspect' do
+      assert_equal  object1.inspect,   object1.myid
+      assert_equal  object2.inspect,   object2.myid
+      assert_equal  object3.inspect,   object3.myid
+      assert_equal  object4.inspect,   object4.myid
+      assert_equal  object5.inspect,   object5.myid
+    end
+    
+  end
+  
+  describe '#variables' do
+    
+    it 'should return empty array' do
+      assert_equal  [],                object1.variables
+      assert_equal  [],                object2.variables
+      assert_equal  [],                object3.variables
+      assert_equal  [],                object4.variables
+      assert_equal  [],                object5.variables
+    end
+    
+  end
+  
+  describe '#type' do
+    
+    it 'should return :atomic for atomic types' do
+      assert_equal  :atomic,           object1.type
+      assert_equal  :atomic,           object2.type
+      assert_equal  :atomic,           object3.type
+      assert_equal  :atomic,           object4.type
+      assert_equal  :atomic,           object5.type
+    end
+    
+  end
+  
+  describe '#/' do
+    
+    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    object3 / :T,     [object3], '*:T'
+      assert_Array_with_Tail    object4 / :T,     [object4], '*:T'
+      assert_Array_with_Tail    [object5] / :T,   [object5], '*:T'
+      #assert_Array_with_Tail    object5.tail(:T), [object5], '*:T'
+    end
+    
+  end
+  
+end
+
+describe 'Symbol' do
+  
+  let (:symbol1) { :alpha }
+  let (:symbol2) { :_ }
+  let (:symbol3) { :'with some spaces' }
+  let (:symbol4) { :X }
+  let (:symbol5) { :p }
+  
+  describe '#myid' do
+    
+    it 'should return inspect' do
+      assert_equal  symbol1.inspect,  symbol1.myid
+      assert_equal  symbol2.inspect,  symbol2.myid
+      assert_equal  symbol3.inspect,  symbol3.myid
+      assert_equal  symbol4.inspect,  symbol4.myid
+      assert_equal  symbol5.inspect,  symbol5.myid
+    end
+    
+  end
+  
+  describe '#variables' do
+    
+    it 'should return an array of itself' do
+      assert_equal  [symbol1],        symbol1.variables
+      assert_equal  [symbol2],        symbol2.variables
+      assert_equal  [symbol3],        symbol3.variables
+      assert_equal  [symbol4],        symbol4.variables
+      assert_equal  [symbol5],        symbol5.variables
+    end
+    
+  end
+  
+  describe '#type' do
+    
+    it 'should return :variable for symbols' do
+      assert_equal  :variable,        symbol1.type
+      assert_equal  :variable,        symbol2.type
+      assert_equal  :variable,        symbol3.type
+      assert_equal  :variable,        symbol4.type
+      assert_equal  :variable,        symbol5.type
+    end
+    
+  end
+  
+  describe '#/' do
+    
+    it 'should create a HeadTail' do
+      assert_Array_with_Tail    symbol1 / :T,     [symbol1], '*:T'
+      assert_Array_with_Tail    symbol2 / :T,     [symbol2], '*:T'
+      assert_Array_with_Tail    symbol3 / :T,     [symbol3], '*:T'
+      assert_Array_with_Tail    symbol4 / :T,     [symbol4], '*:T'
+      assert_Array_with_Tail    symbol5 / :T,     [symbol5], '*:T'
+    end
+    
+  end
+  
+end
+
+describe 'Array' do
+  
+  let(:array1) { [1, 2, :A, 4, [:B, 6, 7, :C], 9] }
+  let(:array2) { [] }
+  let(:array3) { UNKNOWN_ARRAY }
+  let(:array4) { [1, :B, 3, UNKNOWN_TAIL] }
+  
+  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
+      assert_Array_with_Tail    array1 / :T,      array1, '*:T'
+      assert_Array_with_Tail    array2 / :T,      array2, '*:T'
+      assert_Array_with_Tail    array3 / :T,      array3, '*:T'
+      assert_Array_with_Tail    array4 / :T,      array4, '*:T'
+    end
+    
+  end
+  
+  describe '#variables' do
+    
+    it 'should return an array of the embedded Symbols' do
+      assert_equal    [:A, :B, :C],     array1.variables
+      assert_equal    [],               array2.variables
+      assert_equal    [],               array3.variables
+      assert_equal    [:B],             array4.variables
+    end
+    
+  end
+  
+  describe '#value' do
+    
+    it 'should return simple Arrays as is' do
+      assert_equal    [1, 2, :A, 4, [:B, 6, 7, :C], 9],     array1.value
+      assert_equal    [],                                   array2.value
+      assert_equal    [UNKNOWN_TAIL],                       array3.value
+      assert_equal    [1, :B, 3, UNKNOWN_TAIL],             array4.value
+    end
+    
+    it 'should expand Tails that are an Array' do
+      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
+      goal  = new_goal :tailor, :h, :t
+      array = goal.variablise([:h, :b] / :t)
+      goal.instantiate :h, [1,2,3]
+      goal.instantiate :t, [7,8,9]
+      
+      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
+      assert_equal    :array,           array1.type
+      assert_equal    :array,           array2.type
+      assert_equal    :array,           array3.type
+      assert_equal    :array,           array4.type
+    end
+    
+  end
+  
+  describe '#head' do
+    
+    it 'should return the first element when no headsize is provided' do
+      assert_equal    1,                array1.head
+      assert_nil                        array2.head
+      assert_nil                        array3.head
+      assert_equal    1,                array4.head
+    end
+    
+    it 'should return the first headsize elements' do
+      assert_equal    [1, 2],           array1.head(2)
+      assert_equal    [],               array2.head(2)
+      assert_equal    [UNKNOWN_TAIL],   array3.head(2)
+      assert_equal    [1, :B],          array4.head(2)
+    end
+    
+    it 'should return an extended head if the tail is uninstantiated' do
+      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)
+      assert_equal    [1, :B, 3, UNKNOWN_TAIL],           array4.head(9)
+    end
+    
+  end
+  
+  describe '#tail' do
+    
+    it 'should return the tail after the first element when no headsize is provided' do
+      assert_equal    [2, :A, 4, [:B, 6, 7, :C], 9],      array1.tail
+      assert_equal    [],                                 array2.tail
+      assert_equal    [UNKNOWN_TAIL],                     array3.tail
+      assert_equal    [:B, 3, UNKNOWN_TAIL],              array4.tail
+    end
+    
+    it 'should return the tail after the first headsize elements' do
+      assert_equal    [:A, 4, [:B, 6, 7, :C], 9],         array1.tail(2)
+      assert_equal    [],                                 array2.tail(2)
+      assert_equal    [UNKNOWN_TAIL],                     array3.tail(2)
+      assert_equal    [3, UNKNOWN_TAIL],                  array4.tail(2)
+    end
+    
+    it 'should return an extended tail if the tail is uninstantiated' do
+      assert_equal    [],                                 array1.tail(9)
+      assert_equal    [],                                 array2.tail(9)
+      assert_equal    [UNKNOWN_TAIL],                     array3.tail(9)
+      assert_equal    [UNKNOWN_TAIL],                     array4.tail(9)
+    end
+    
+  end
+  
+  describe '#clean' do
+    
+    let(:predicate1)  { Predicate.new :generic }
+    let(:arguments1)  { predicate1.arguments(:m,:n) }
+    let(:goal1)       { arguments1.goal }
+    
+    let(:array5)      { [1, 2, goal1[:A], 4, [goal1[:B], 6, 7, goal1[:C]], 9] }
+    let(:array6)      { [1, goal1[:B], 3]/:T }
+    let(:array7)      { [1, goal1[:B], 3]/goal1[:T] }
+    
+    it 'should return simple Arrays as is' do
+      assert_equal    [1, 2, :A, 4, [:B, 6, 7, :C], 9],     array1.clean
+      assert_equal    [],                                   array2.clean
+      assert_equal    [UNKNOWN_TAIL],                       array3.clean
+      assert_equal    [1, :B, 3, UNKNOWN_TAIL],             array4.clean
+    end
+    
+    it 'should return the values of its elements with variables replaced by nil and Tails replaced by UNKNOWN_TAIL' do
+      assert_equal    [1, 2, nil, 4, [nil, 6, 7, nil], 9],  array5.clean
+      assert_equal    [1, nil, 3, UNKNOWN_TAIL],            array6.clean
+      assert_equal    [1, nil, 3, UNKNOWN_TAIL],            array7.clean
+    end
+    
+  end
+  
+end

data/test/porolog/goal_test.rb

@@ -0,0 +1,891 @@
+#
+#   test/porolog/goal_test.rb     - Test Suite for Porolog::Goal
+#
+#     Luis Esteban      2 May 2018
+#       created
+#
+
+require_relative '../test_helper'
+
+
+describe 'Porolog' do
+  
+  before(:all) do
+    reset
+  end
+
+  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
+        new_goal :predicate1, :a
+        new_goal :predicate2, :a, :b
+        new_goal :predicate3, :a, :b, :c
+        
+        assert_equal  3,  Goal.goals.size
+        
+        Goal.reset
+        
+        assert_empty      Goal.goals
+      end
+      
+      it 'should call check_deleted for each goal' do
+        Goal.any_instance.expects(:check_deleted).with().returns(false).times(5)
+        
+        new_goal :p, :x, :y
+        new_goal :q, :a
+        new_goal :r, :a, :b, :c
+        
+        Goal.reset
+        
+        new_goal :j, 1
+        new_goal :k, ['a', 'b', 'c']
+        
+        Goal.reset
+      end
+      
+    end
+    
+    describe '.goals' do
+      
+      it 'should return all registered goals' do
+        assert_equal  0,  Goal.goals.size
+        
+        goal1 = new_goal :predicate1, :a
+        
+        assert_equal  [goal1],                Goal.goals
+        
+        goal2 = new_goal :predicate2, :a, :b
+        
+        assert_equal  [goal1,goal2],          Goal.goals
+        
+        goal3 = new_goal :predicate3, :a, :b, :c
+        
+        assert_equal  [goal1,goal2,goal3],    Goal.goals
+      end
+      
+    end
+    
+    describe '.new' do
+      
+      it 'should create a new Goal' do
+        goal = Goal.new nil
+        
+        assert_instance_of  Goal,   goal
+      end
+      
+    end
+    
+    describe '#initialize' do
+      
+      it 'should initialize calling_goal' do
+        goal1 = Goal.new args
+        goal2 = Goal.new args, goal1
+        
+        assert_nil              goal1.calling_goal
+        assert_equal  goal1,    goal2.calling_goal
+        
+        assert_Goal   goal1,    :p, [:x,:y]
+        assert_Goal   goal2,    :p, [:x,:y]
+      end
+      
+      it 'should initialize arguments' do
+        goal = Goal.new args, nil
+        
+        assert_equal  goal.variablise(args),      goal.arguments
+      end
+      
+      it 'should initialize terminate' do
+        goal = Goal.new args, nil
+        
+        assert_equal  false,                      goal.terminated?
+      end
+      
+      it 'should initialize variables' do
+        goal = Goal.new args, nil
+        
+        assert_Goal_variables   goal, { x: nil, y: nil }, [
+          'Goal1.:x',
+          'Goal1.:y',
+        ].join("\n")
+      end
+      
+      it 'should register the goal as undeleted' do
+        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',          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
+    
+    describe '#myid' do
+      
+      let(:pred) { Predicate.new :p }
+      let(:args) { pred.(:x,:y) }
+      
+      it 'should return the pretty id of the goal' do
+        goal1 = Goal.new args, nil
+        goal2 = Goal.new args, goal1
+        
+        assert_equal  'Goal1',          goal1.myid
+        assert_equal  'Goal2',          goal2.myid
+      end
+      
+    end
+    
+    describe '#deleted?' do
+      
+      it 'should return the deleted state of a goal' do
+        goal = Goal.new args
+        
+        refute    goal.deleted?, 'goal should not be deleted'
+        
+        Goal.reset
+        
+        assert    goal.deleted?, 'goal should be deleted'
+      end
+      
+      it 'should memoize the deleted state of a goal' do
+        goal = Goal.new args
+        
+        check_deleted_spy = Spy.on(goal, :check_deleted).and_call_through
+        
+        refute    goal.deleted?
+        refute    goal.deleted?
+        refute    goal.deleted?
+        refute    goal.deleted?
+        
+        Goal.reset
+        
+        assert    goal.deleted?
+        assert    goal.deleted?
+        assert    goal.deleted?
+        assert    goal.deleted?
+        
+        assert_equal    5,    check_deleted_spy.calls.size
+      end
+      
+    end
+    
+    describe '#check_deleted' do
+      
+      it 'should return false when the goal is not deleted and keep variables intact' do
+        goal = Goal.new args
+        goal.variable(:x)
+        goal.variable(:y)
+        goal.variable(:z)
+        
+        variable_remove_spy = Spy.on_instance_method(Variable, :remove)
+        
+        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
+        goal = Goal.new args
+        goal.variable(:x)
+        goal.variable(:y)
+        goal.variable(:z)
+        
+        variable_remove_spy = Spy.on_instance_method(Variable, :remove)
+        
+        Goal.reset
+        
+        assert  goal.check_deleted, 'goal should be deleted'
+        
+        assert_equal    3,    variable_remove_spy.calls.size
+      end
+      
+    end
+    
+    describe '#terminate!' do
+      
+      it 'should set the goal to terminate and log the event' do
+        goal = Goal.new args
+        
+        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)
+        goal.variable(:z)
+        
+        variables = goal.variables
+        
+        assert_instance_of      Hash, variables
+        
+        assert_Goal             goal, :p, [:x,:y]
+        assert_Goal_variables   goal, { x: nil, y: nil, z: nil }, [
+          'Goal1.:x',
+          'Goal1.:y',
+          'Goal1.:z',
+        ].join("\n")
+      end
+      
+    end
+    
+    describe '#inspect_variables' do
+      
+      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
+      
+    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
+        refute    goal.variables.key?(:v), ':v should not be a variable'
+        
+        variable1 = goal.variable :v
+        
+        assert    goal.variables.key?(:v), ':v should be a variable'
+        
+        variable2 = goal.variable :v
+        
+        assert    goal.variables.key?(:v), ':v should be a variable'
+        
+        variable3 = goal.variable variable2
+        
+        assert_equal    variable1, variable2
+        assert_equal    variable2, variable3
+      end
+      
+    end
+    
+    describe '#value' do
+      
+      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
+          refute        goal.variables.key?(variable_name), "#{variable_name} should not exist"
+          
+          refute_nil    goal.value_of(variable_name)
+          
+          assert        goal.variables.key?(variable_name), "#{variable_name} should exist"
+          
+          variable       = goal.variable(variable_name)
+          variable.instantiate 44.5
+          
+          assert_equal      44.5,   goal.value_of(variable_name)
+        end
+        
+      end
+      
+      describe 'when name is not a Symbol' do
+        
+        let(:variable_name) { 99.28 }
+        
+        it 'should return the name as the value' do
+          assert_equal    99.28,    goal.value_of(variable_name)
+        end
+        
+      end
+      
+    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
+        goal1 = new_goal :p, :x, :y
+        
+        solutions = goal1.solve
+        
+        assert_equal  [], solutions
+      end
+      
+      it 'should solve a fact' do
+        predicate :fact
+        
+        fact(42).fact!
+        
+        solutions = fact(42).solve
+        
+        assert_equal  [{}],  solutions
+      end
+      
+      it 'should not solve a falicy' do
+        predicate :fact
+        
+        fact(42).falicy!
+        
+        solutions = fact(42).solve
+        
+        assert_equal  [],  solutions
+      end
+      
+      it 'should solve using head and tail with lists' do
+        predicate :head_tail
+        
+        head_tail([1,2,3,4,5,6,7]).fact!
+        head_tail(['head','body','foot']).fact!
+        
+        solutions = head_tail(:head/:tail).solve
+        
+        assert_equal    [
+          { head: 1,      tail: [2,3,4,5,6,7] },
+          { head: 'head', tail: ['body','foot'] },
+        ], solutions
+      end
+      
+      it 'should solve a goal recursively' do
+        builtin :write
+        predicate :recursive
+        
+        recursive([]) << [:CUT, true]
+        recursive(:head/:tail) << [
+          write('(',:head,')'),
+          recursive(:tail)
+        ]
+        
+        assert_output '(1)(2)(3)(four)(5)(6)(7)' do
+          solutions = recursive([1,2,3,'four',5,6,7]).solve
+          
+          assert_equal    [{}], solutions
+        end
+      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)
+        
+        refute          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)
+        
+        refute          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).returns(true).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
+    
+    describe '#inherit_variables' do
+      
+      it 'should return true for an initial goal' do
+        goal    = new_goal :goal,    :x, :y, :z
+        
+        assert                  goal.inherit_variables
+        assert_Goal_variables   goal, { x: nil, y: nil, z: nil }, [
+          'Goal1.:x',
+          'Goal1.:y',
+          'Goal1.:z',
+        ].join("\n")
+      end
+      
+      it 'should instantiate combined variables of both goals' do
+        goal    = new_goal :goal,    :x, :y, :z
+        subgoal = new_goal :subgoal, :a, :b, :c
+        
+        assert  subgoal.inherit_variables(goal)
+        assert_Goal_variables   goal, { x: nil, y: nil, z: nil, a: nil, b: nil, c: nil }, [
+          'Goal1.:x',
+          '  Goal2.:x',
+          'Goal1.:y',
+          '  Goal2.:y',
+          'Goal1.:z',
+          '  Goal2.:z',
+          'Goal1.:a',
+          '  Goal2.:a',
+          'Goal1.:b',
+          '  Goal2.:b',
+          'Goal1.:c',
+          '  Goal2.:c',
+        ].join("\n")
+        assert_Goal_variables   subgoal, { a: nil, b: nil, c: nil, x: nil, y: nil, z: nil }, [
+          'Goal2.:a',
+          '  Goal1.:a',
+          'Goal2.:b',
+          '  Goal1.:b',
+          'Goal2.:c',
+          '  Goal1.:c',
+          'Goal2.:x',
+          '  Goal1.:x',
+          'Goal2.:y',
+          '  Goal1.:y',
+          'Goal2.:z',
+          '  Goal1.:z',
+        ].join("\n")
+      end
+      
+      it 'should not make any instantiations when variables cannot be unified' do
+        goal    = new_goal :goal,    :x, :y, :z
+        subgoal = new_goal :subgoal, :a, :b, :c
+        
+        goal[:x].instantiate 1
+        subgoal[:x].instantiate 2
+        
+        refute  subgoal.inherit_variables(goal)
+        assert_equal  [
+          'Cannot unify because 1 != 2 (variable != variable)',
+        ], goal.log
+        assert_equal  [
+          'Cannot unify because 1 != 2 (variable != variable)',
+          "Couldn't unify: :x WITH Goal1 AND Goal2"
+        ], subgoal.log
+        assert_Goal_variables   goal, { x: 1, y: nil, z: nil }, [
+          'Goal1.:x',
+          '  Goal1.1',
+          'Goal1.:y',
+          'Goal1.:z',
+        ].join("\n")
+        assert_Goal_variables   subgoal, { a: nil, b: nil, c: nil, x: 2 }, [
+          'Goal2.:a',
+          'Goal2.:b',
+          'Goal2.:c',
+          'Goal2.:x',
+          '  Goal2.2',
+        ].join("\n")
+      end
+      
+    end
+    
+  end
+  
+end