cauldron 0.1.0

data/test/unit/core/structure/tc_instance_call_container_structure.rb

@@ -0,0 +1,41 @@
+require 'required'
+require 'test/unit'
+
+class TestInstanceCallContainerStructure < Test::Unit::TestCase
+  
+  def setup
+    
+    # Create an array of variables to allow <runtime_method_var>.push(<statement_var>)
+    @runtime_method_var = RuntimeMethod.new(MethodUsage.new).to_var
+    @statement_var = Statement.new().to_var
+    @statement_and_runtime_method_var = [
+      @runtime_method_var,
+      @statement_var
+    ]
+    
+  end
+  
+  def teardown
+    System.reset
+  end  
+  
+  def test_statements
+    
+    # Chect that <runtime_method_var>.push(<statement_var>) can be created
+    assert_equal(1,InstanceCallContainerStructure.new().statements(@statement_and_runtime_method_var).length)
+    assert_equal(
+      @runtime_method_var.write+'.push('+@statement_var.write+')',
+      InstanceCallContainerStructure.new().statements(@statement_and_runtime_method_var).first.write
+    )
+    
+    # Check that <runtime_method_var>.push(<statement_var>) changes uniq_id but retains old reference
+    resulting_statement = InstanceCallContainerStructure.new().statements(@statement_and_runtime_method_var).first
+    assert_equal(resulting_statement.first.subject.variable_id,@runtime_method_var.variable_id)
+    #assert_not_equal(resulting_statement.first.subject.uniq_id,@runtime_method_var.uniq_id)
+    assert(resulting_statement.first.subject.uniq_id_history.kind_of?(Array))
+    #assert(resulting_statement.first.subject.uniq_id_history.any? {|x| x == @runtime_method_var.uniq_id})
+    #assert_equal(1,resulting_statement.first.subject.uniq_id_history.length)    
+    
+  end
+      
+end

data/test/unit/core/structure/tc_return_structure.rb

@@ -0,0 +1,32 @@
+require 'required'
+require 'test/unit'
+
+class TestReturnStructure < Test::Unit::TestCase
+  
+  def setup
+    
+    # Create the structure instance that generates the appropriate statement
+    @statement_generator = ReturnStructure.new()
+    @scabb = 'Scabb'.to_var
+    
+    
+  end
+  
+  def teardown
+    CodeHandler.reset_global_id
+System.reset
+    RuntimeMethod.reset_global_id    
+  end
+  
+  def test_statements
+    
+    # Check that 'scabb' was returned
+    assert_equal(1,@statement_generator.statements([@scabb]).length)
+    assert_equal(
+      'return var_'+@scabb.variable_id.to_s,
+      @statement_generator.statements([@scabb]).first.write
+    )    
+    
+  end
+  
+end

data/test/unit/core/syntax/tc_block_container.rb

@@ -0,0 +1,32 @@
+require 'required'
+require 'test/unit'
+
+class TestBlockContainer < Test::Unit::TestCase
+  
+  def setup
+    
+    # Create block containers with different numbers of variables
+    @block_container_1 = BlockContainer.new('lotus'.to_var)
+    @block_container_2 = BlockContainer.new(9.to_var,'test'.to_var)
+    
+  end
+  
+  def teardown
+System.reset
+    RuntimeMethod.reset_global_id
+  end  
+
+  def test_write
+    assert_equal('|var_0|',@block_container_1.write)
+    assert_equal('|var_1, var_2|',@block_container_2.write)
+  end
+  
+  def test_copy
+    assert_equal(@block_container_1.length,@block_container_1.copy.length)
+    assert_equal(@block_container_2.length,@block_container_2.copy.length)
+    assert_equal(@block_container_1.first.variable_id,@block_container_1.copy.first.variable_id)
+    assert_equal(@block_container_2.first.variable_id,@block_container_2.copy.first.variable_id)    
+    assert_equal(@block_container_2.last.variable_id,@block_container_2.copy.last.variable_id)        
+  end
+      
+end

data/test/unit/core/syntax/tc_if_container.rb

@@ -0,0 +1,39 @@
+require 'required'
+require 'test/unit'
+
+class TestIfContainer < Test::Unit::TestCase
+  
+  def setup
+    
+  end
+  
+  def teardown
+System.reset
+    RuntimeMethod.reset_global_id
+  end  
+
+  def test_write
+    
+    # 1.  if(true)
+    assert_equal('if(true)',IfContainer.new(True.new).write)
+    
+    # 2.  if(var_x == 'test')
+    unknown_variable_2 = Unknown.new
+    if_statement_2 = IfContainer.new(unknown_variable_2,Equivalent.new,Literal.new('test'))
+    assert_equal('if(var_'+unknown_variable_2.variable_id.to_s+" == 'test')",if_statement_2.write)
+    
+  end  
+  
+  def test_copy
+    
+    # 1.  Check copy works if(true)
+    assert_equal(IfContainer.new(True.new).write,IfContainer.new(True.new).copy.write)
+    
+    # 2.  Check copy works for "if(var_x == 'test')"
+    unknown_variable_2 = Unknown.new
+    if_statement_2 = IfContainer.new(unknown_variable_2,Equivalent.new,Literal.new('test'))
+    assert_equal(if_statement_2.copy.write,if_statement_2.write)    
+    
+  end
+  
+end

data/test/unit/core/tc_class_method_call.rb

@@ -0,0 +1,34 @@
+require 'required'
+require 'test/unit'
+
+class TestClassMethodCallContainer < Test::Unit::TestCase
+  
+  def setup
+    
+    # Create a simple method call var_a = MethodUsage.new
+    @simple_method_usage = ClassMethodCallContainer.new(MethodUsageClass.new,New.new)          
+    
+    # Create a simple method usage instance
+    @simple_method_usage_var = MethodUsage.new().to_var
+    @simple_runtime_method_instance = ClassMethodCallContainer.new(RuntimeMethodClass.new,New.new,@simple_method_usage_var)
+          
+  end
+  
+  def teardown
+    System.reset
+    RuntimeMethod.reset_global_id    
+  end
+  
+  def test_select_all
+    
+    # Test where method doesn't exist
+    assert_equal(0,@simple_method_usage.select_all {|x| x.kind_of?(MethodUsageVariable)}.length)
+    
+    assert_equal(
+      @simple_method_usage_var.variable_id,
+      @simple_runtime_method_instance.select_all {|x| x.kind_of?(Variable)}.first.variable_id
+    )
+   
+  end
+  
+end

data/test/unit/core/tc_container.rb

@@ -0,0 +1,41 @@
+require 'required'
+require 'test/unit'
+
+class TestContainer < Test::Unit::TestCase
+  
+  def setup
+    @simple_container = Container.new(Parser.run('var3'),Equivalent.new,Parser.run('var2'))          
+  end
+  
+  def teardown
+    System.reset
+    RuntimeMethod.reset_global_id    
+  end
+  
+  def test_initialize
+    Container.new(
+      Parser.run('var3'),
+      Equivalent.new,
+      Parser.run('var2')
+    )    
+  end
+  
+  def test_write
+    assert_equal(
+        Container.new(
+          Parser.run('var3'),
+          Equivalent.new,
+          Parser.run('var2')
+        ).write,
+        '(var_3 == var_2)'
+    )
+  end  
+  
+  def test_select_all
+    assert_equal(
+      2,
+      @simple_container.select_all {|x| x.kind_of?(BaseVariable)}.length
+    )
+  end    
+   
+end

data/test/unit/core/tc_ctest_case.rb

@@ -0,0 +1,25 @@
+require 'required'
+require 'test/unit'
+
+class TestCTestCase < Test::Unit::TestCase
+  
+  def setup
+    @cauldron_test_case_1 = CTestCase.new() 
+    @cauldron_test_case_1[:params] = ['something']
+    @cauldron_test_case_1[:output] = 'exists'      
+  end
+  
+  def teardown
+    System.reset
+    RuntimeMethod.reset_global_id    
+  end
+  
+  def test_cauldron_method_calls
+    assert_equal(2,@cauldron_test_case_1.cauldron_method_calls.length)
+    assert_equal(
+      "[:output]",
+      @cauldron_test_case_1.cauldron_method_calls.first
+    )
+  end
+  
+end

data/test/unit/core/tc_instance_call_container.rb

@@ -0,0 +1,93 @@
+require 'required'
+require 'test/unit'
+
+class TestInstanceCallContainer < Test::Unit::TestCase
+  
+  def setup
+      
+  end
+  
+  def teardown
+    System.reset
+    RuntimeMethod.reset_global_id    
+  end
+  
+  def test_equivalent
+    
+    # Create a push statement and confirm they are captured as equivalent
+    instance_call_container_a = InstanceCallContainer.new(RuntimeMethod.new(MethodUsage.new).to_var,Push.new,Statement.new.to_var)
+    assert(true,instance_call_container_a.equivalent?(instance_call_container_a.copy))
+    
+  end
+  
+  def test_subst!
+    
+    # Test that variables are replaced in the instance call
+    # 'warren'.length -> 'marc'.length
+    warren = 'warren'.to_var
+    new_var_length = InstanceCallContainer.new(warren,StringLength.new)
+    marc = 'marc'.to_var
+    assert_equal(warren.uniq_id,new_var_length.subject.uniq_id)
+    new_var_length.subst!(marc) {|x| x.uniq_id == warren.uniq_id}
+    assert_equal(marc.uniq_id,new_var_length.subject.uniq_id)
+    assert_not_equal(warren.uniq_id,new_var_length.subject.uniq_id)
+    
+    # Test the paramters are properly replaced
+    # [].push('dragon') -> [].push('unicorn')
+    dragon = 'dragon'.to_var
+    unicorn = 'unicorn'.to_var
+    pushing_call = InstanceCallContainer.new([].to_var,Push.new,dragon)
+    assert_equal(pushing_call.parameters.last.uniq_id,dragon.uniq_id)
+    pushing_call.subst!(unicorn){|x| x.uniq_id == dragon.uniq_id}
+    assert_not_equal(pushing_call.parameters.last.uniq_id,dragon.uniq_id)   
+    assert_equal(pushing_call.parameters.last.uniq_id,unicorn.uniq_id)       
+        
+  end
+  
+  def test_select_all
+    assert_equal(
+      2,
+      StringToTheory.run(
+        "var1.realise2(var3).params[0].value.length"
+      ).select_all {|x| x.kind_of?(TheoryVariable)}.length
+    )
+  end
+  
+  def test_contains
+    assert_equal(
+      true,
+      Parser.run('var1.push(8)').kind_of?(InstanceCallContainer)
+    )
+    assert_equal(
+      true,
+      Parser.run('var1.push(8)').contains? {|x| x.kind_of?(Unknown)}
+    )
+    assert_equal(
+      true,
+      Parser.run('var1.push(8)').contains? {|x| x.kind_of?(Push)}
+    )
+    assert_equal(
+      true,
+      Parser.run('var1.push(8)').contains? {|x| x.kind_of?(Literal)}
+    )     
+  end
+  
+  def test_equivalent
+    assert_equal(
+      true,
+      Parser.run('var1.push(8)').equivalent?(Parser.run('var1.push(8)'))
+    )
+    assert_equal(
+      true,
+      Parser.run('var2.push(8)').equivalent?(Parser.run('var1.push(8)'))
+    )
+    assert_equal(
+      true,
+      Parser.run('var2.push(var8)').equivalent?(Parser.run('var1.push(var9)'))
+    )
+    assert_equal(
+      false,
+      Parser.run('var2.push(var8)').equivalent?(Parser.run('var1.push(var9,var7)'))
+    )    
+  end
+end

data/test/unit/core/tc_literal.rb

@@ -0,0 +1,30 @@
+require 'required'
+require 'test/unit'
+
+class TestLiteral < Test::Unit::TestCase
+  
+  def setup
+    
+    @spectre = Literal.new('spectre')  
+    @num_2009 = Literal.new(2009)
+    
+  end
+  
+  def teardown
+    System.reset
+    RuntimeMethod.reset_global_id
+  end  
+  
+  def test_initialize
+    
+    # Attempt to create an unknown literal
+    assert_raises(UnliteralisableError){Literal.new(MethodUsage.new)}
+    
+  end
+  
+  def test_to_literal_string      
+    assert_equal("'spectre'",@spectre.to_literal_string)
+    assert_equal("2009",@num_2009.to_literal_string)    
+  end
+      
+end

data/test/unit/core/tc_theory_generator.rb

@@ -0,0 +1,336 @@
+require 'required'
+require 'test/unit'
+ 
+class TestTheoryGenerator < Test::Unit::TestCase
+  include ContainsTheories  
+  
+  def setup
+ 
+    test_case_1 = CTestCase.new 
+    test_case_1[:params] = ['something']
+    test_case_1[:output] = 'exists'
+    test_case_2 = CTestCase.new
+    test_case_2[:params] = ['my willpower']
+    test_case_2[:output] = 'does not exist'
+    @set_1_test_cases = [
+      test_case_1,test_case_2
+    ]
+    @runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))    
+    
+  end
+  
+  def teardown
+    System.reset
+    RuntimeMethod.reset_global_id
+  end  
+  
+  def test_initialize
+    assert_nothing_raised(){TheoryGenerator.new}
+  end
+  
+  # This is testing the generator for the problem that can be solved with 
+  # the following solution:
+  #
+  #  def identifyType(word)
+  #    if(word == ‘go’)
+  #      return ‘verb’
+  #    end
+  #    return ‘adjective’
+  #  end    
+  #  
+  def test_generate_with_first_case
+    test_case_1 = CTestCase.new 
+    test_case_1[:params] = ['something']
+    test_case_1[:output] = 'exists'
+    test_case_2 = CTestCase.new
+    test_case_2[:params] = ['my willpower']
+    test_case_2[:output] = 'does not exist'
+    test_cases = [
+      test_case_1,test_case_2
+    ]
+    runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))
+    
+  end
+  
+  def test_generate_theories_for_actions
+    
+    # The folling are the actions that need included in the statement to solve the problem
+    # var1 = RuntimeMethod, var2 = test_cases, var3 = 0, var4 = 0
+    action_one = TheoryAction.new(
+      TheoryStatement.new(StringToTheory.run(
+          'IfStatement.new(var2[var3][:params][var4],Equivalent.new,var2[var3][:output])'
+        )
+      ),
+      StringToTheory.run('var1.statement_id')
+    )
+    action_two = TheoryAction.new(
+      TheoryStatement.new(StringToTheory.run('Statement.new(Return.new,var2[var3][:output])')),
+      StringToTheory.run('var1.last.statement_id')
+    )
+    action_three = TheoryAction.new(
+      TheoryStatement.new(StringToTheory.run('Statement.new(Return.new,var2[var4][:output])')),
+      StringToTheory.run('var1.statement_id')
+    )
+    actions = [action_one,action_two,action_three]
+    
+  end
+  
+  def test_actions_validate_runtime_method
+    
+    # The folling are the actions that need included in the statement to solve the problem
+    # var1 = RuntimeMethod, var2 = test_cases, var3 = 0, var4 = 0
+    action_one = TheoryAction.new(
+      TheoryStatement.new(StringToTheory.run(
+          'IfStatement.new(var2[var3][:params][var4],Equivalent.new,var2[var3][:output])'
+        )
+      ),
+      StringToTheory.run('var1.statement_id')
+    )
+    action_two = TheoryAction.new(
+      TheoryStatement.new(StringToTheory.run('Statement.new(Return.new,var2[var3][:output])')),
+      StringToTheory.run('var1.last.statement_id')
+    )
+    action_three = TheoryAction.new(
+      TheoryStatement.new(StringToTheory.run('Statement.new(Return.new,var2[var4][:output])')),
+      StringToTheory.run('var1.statement_id')
+    )
+    actions = [action_one,action_two,action_three]    
+    generator = TheoryGenerator.new
+    generator.actions_validate_runtime_method?(@runtime_method,@test_cases,actions)
+    
+  end
+  
+  def test_generate_theories_with_some_simple_cases
+    
+    @set_1_test_cases
+    @runtime_method
+    mapping = Mapping.new({
+      1 => @runtime_method.copy,
+      2 => @set_1_test_cases.copy
+    })    
+    accessors = [
+      {:value=>@runtime_method.copy,:statement=>TheoryStatement.new(TheoryVariable.new(1)),:step=>0},
+      {:value=>@set_1_test_cases.copy,:statement=>TheoryStatement.new(TheoryVariable.new(2)),:step=>0}
+    ]    
+    # TODO  I can probably use the runtime method and test case in the mapping
+    assert_kind_of(
+      Array,TheoryGenerator.new.generate_theories(@set_1_test_cases,@runtime_method,accessors,mapping)
+    )
+    assert_equal(
+      true,
+      TheoryGenerator.new.generate_theories(@set_1_test_cases,@runtime_method,accessors,mapping).all? {|x| x.kind_of?(Theory)}
+    )
+
+  end
+
+  def test_extend_accessors_with_some_simple_cases
+    
+    @set_1_test_cases
+    @runtime_method
+    mapping = Mapping.new({
+      1 => @runtime_method.copy,
+      2 => @set_1_test_cases.copy
+    })    
+    accessors = [
+      {:value=>@runtime_method.copy,:statement=>TheoryStatement.new(TheoryVariable.new(1)),:step=>0},
+      {:value=>@set_1_test_cases.copy,:statement=>TheoryStatement.new(TheoryVariable.new(2)),:step=>0}
+    ]
+    assert_equal(
+      2,
+      TheoryGenerator.new.extend_accessors(accessors,mapping,[0,1,2],0).length
+    )
+    assert_equal(
+      9,
+      TheoryGenerator.new.extend_accessors(accessors,mapping,[0,1,2],1).length
+    )
+    # Check that the two test case access has been added e.g. test_case[var3], test_case[var4]
+    assert_equal(4,mapping.length)
+    
+    # NOTE: The step is NOT the number of itterations - it determines what accessors are available 
+    #       to construct new statements.
+    assert_equal(
+      2,
+      TheoryGenerator.new.extend_accessors(accessors,mapping,[0,1,2],2).length
+    )
+  end
+
+  def test_statements_with_first_case
+    
+    potential_values = MappingValues.new([@set_1_test_cases,@runtime_method])    
+    generator = TheoryGenerator.new
+    
+    # Test one itteration mapping has the correct number of accessors
+    one_itteration_accessors, one_itteration_mapping = generator.generate_accessors_and_mapping(@set_1_test_cases,@runtime_method,1)
+    assert_equal(one_itteration_accessors.length,one_itteration_accessors.uniq.length) 
+    assert_equal(9,one_itteration_accessors.length)
+    assert_equal(4,one_itteration_mapping.length)
+    
+    two_itteration_accessors, two_itteration_mapping = generator.generate_accessors_and_mapping(@set_1_test_cases,@runtime_method,2)
+    assert_equal(two_itteration_accessors.length,two_itteration_accessors.collect {|x| x[:statement].write}.uniq.length)
+    assert_equal(18,two_itteration_accessors.length)
+    assert_equal(5,two_itteration_mapping.length)
+     
+    three_itteration_accessors, three_itteration_mapping = generator.generate_accessors_and_mapping(@set_1_test_cases,@runtime_method,3)
+    assert_equal(29,three_itteration_accessors.length)
+    assert_equal(7,three_itteration_mapping.length)
+    assert_equal(three_itteration_accessors.length,three_itteration_accessors.collect {|x| x[:statement].write}.uniq.length)
+    
+    # TODO  Need to check why four itteration doesn't have any effect    
+  end
+  
+  # Check that indexes are re-used.  This allows the test case params to referer to the 
+  # same param in the runtime method.
+  # 
+  # var1.params[var5] == var2[var3][:params][var5]
+  # NOTE: var5 are the same reference 
+  #
+  def test_indexes_are_shared
+    potential_values = MappingValues.new([@set_1_test_cases,@runtime_method])    
+    generator = TheoryGenerator.new
+    accessors, mapping = generator.generate_accessors_and_mapping(@set_1_test_cases,@runtime_method,3)
+    assert_equal(true,accessors.any? {|x| x[:statement].write == 'var1.params[var5]'})    
+    assert_equal(true,accessors.any? {|x| x[:statement].write == 'var2[var3][:params][var5]'})
+  end
+  
+  # Checks that the theory to add the 'return 'does not exist' statement is generated
+  # return var2[var4][:params][var5]
+  #
+  def test_generate_theories_with_case_1_statement_2
+   
+    # Create the runtime method with and add the initial "ifstatement" to it
+    @runtime_method << Parser.run("if(var0 == 'my willpower')\nend\n")
+    
+    # Create the mapping for the generator
+    mapping = Mapping.new({1 => @runtime_method.copy,2 => @set_1_test_cases.copy})
+    mapping[3] = 0
+    mapping[4] = 0
+    mapping[5] = 1
+    # TODO  Should it generate 7 variables surely 6,7 refer to [var2][var3][:params][var6] and [var2][var4][:params][var7]
+    #       - I might only want var6 since you can't right code to account for the difference. - Warren this is a proper
+    #         don't ignore it.
+    mapping[6] = 0
+    mapping[7] = 0
+    
+    # Create the accessors used to generate the action
+    accessors = [
+      {:value=>'does not exist',:statement=>StringToTheory.run('var2[var4][:params][var5]')},
+      {:value=>1,:statement=>StringToTheory.run('var1.last.statement_id')}
+    ]
+    assert_equal('var2[var4][:params][var5]',accessors[0][:statement].write)
+     
+    # Check that all the accessors could be generated
+    generated_accessors, mapping = TheoryGenerator.new.generate_accessors_and_mapping(@set_1_test_cases,@runtime_method,3)
+    accessors.each do |accessor|
+      assert(generated_accessors.any? {|x| x[:statement].write == accessor[:statement].write })
+    end
+    
+    # Generate possible theories given the limited number of accessors
+    theories = TheoryGenerator.new.generate_theories(@set_1_test_cases,@runtime_method,accessors,mapping)
+    assert_equal(
+      true,
+      theories.any? do |theory| 
+        theory.action.write == '<runtime_method>.add_statement_at(Statement.new(Return.new, var2[var4][:params][var5]),var1.last.statement_id)'
+      end
+    )
+    
+  end
+ 
+  def test_generate_theories_with_case_1_statement_3
+    
+    # Create the runtime method with and add the initial "ifstatement" to it
+    @runtime_method << Parser.run("if(var0 == 'my willpower')\nend\n")
+    @runtime_method.add_statement_at(Parser.run("return 'does not exist'"),@runtime_method.last.statement_id)
+    
+    # Create the mapping for the generator
+    mapping = Mapping.new({1 => @runtime_method.copy,2 => @set_1_test_cases.copy})
+    mapping[3] = 0
+    mapping[4] = 0
+    mapping[5] = 1
+    # TODO  Should it generate 7 variables surely 6,7 refer to [var2][var3][:params][var6] and [var2][var4][:params][var7]
+    #       - I might only want var6 since you can't right code to account for the difference.
+    mapping[6] = 0
+    mapping[7] = 0
+    
+    # Create the accessors used to generate the action
+    accessors = [
+      {:value=>'exists',:statement=>StringToTheory.run('var2[var4][:output]')},
+      {:value=>0,:statement=>StringToTheory.run('var1.statement_id')}
+    ]
+    assert_equal('var2[var4][:output]',accessors[0][:statement].write)
+    
+    # Check that all the accessors could be generated
+    generated_accessors, mapping = TheoryGenerator.new.generate_accessors_and_mapping(@set_1_test_cases,@runtime_method,3)
+    accessors.each do |accessor|
+      assert(generated_accessors.any? {|x| x[:statement].write == accessor[:statement].write })
+    end    
+    
+  end
+  
+  def test_simple_chain_head_creation
+    
+    # Create the simple runtime method and test cases used to create the head
+    runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))
+    sparky = CTestCase.new
+    sparky[:params] = ['sparky']
+    sparky[:output] = 'sparky'
+    pip = CTestCase.new
+    pip[:params] = ['pip']
+    pip[:output] = 'pip'
+    test_cases = [
+      sparky,pip
+    ]    
+    
+    # Generate the head theory - this is the starting point and doesn't have any dependents
+    accessors, mapping = TheoryGenerator.new.generate_accessors_and_mapping(test_cases,runtime_method,4,0)
+    
+    # * Generate all the possible results of this runtime method
+    theory_results = TheoryGenerator.new.get_theory_results(accessors)
+    
+    # * Create the actual head theory
+    head_theory = Theory.new([],nil,theory_results,runtime_method.copy)
+    
+    # Check that the generated theory can be implemented - and all the variables have been replaced
+    intrinsic_mapping = TheoryGenerator.new.covert_to_intrinsic_mapping(mapping)
+    
+    # Go through each result and check that the variables can be mapped to intrinsic values
+    head_theory.results.each do |res|
+      mapped_res = res.map_to(intrinsic_mapping)
+      assert_equal(false,mapped_res.write.include?('var'))
+    end
+    
+    implemented_thoery = head_theory.map_to(intrinsic_mapping)
+    assert_not_equal(
+      true,
+      implemented_thoery.write.include?('var')
+    )
+    
+  end
+  
+  def test_generate_accessors_and_mapping_with_theory_6
+    
+    runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))
+    sparky = CTestCase.new
+    sparky[:params] = ['sparky']
+    sparky[:output] = 'sparky'
+    pip = CTestCase.new
+    pip[:params] = ['pip']
+    pip[:output] = 'pip'
+    test_cases = [
+      sparky,pip
+    ]    
+    
+    # Generate the head theory - this is the starting point and doesn't have any dependents
+    accessors, mapping = TheoryGenerator.new.generate_accessors_and_mapping(test_cases,runtime_method,7,0)    
+    
+    # * Generate all the possible results of this runtime method
+    theory_results = TheoryGenerator.new.get_theory_results(accessors)
+    
+    # Check that the results (that would be used in the head) include each do theory_6's dependents
+    theory_6 = Theory.load_theory(6)
+    theory_6.dependents.each do |theory_dependent|
+      assert_equal(true,theory_results.any? {|x| x.write == theory_dependent.write})
+    end
+    
+  end
+      
+end