cauldron 0.1.3 → 0.1.5

data/test/unit/theory/tc_theory_connector.rb

@@ -1,361 +0,0 @@
-require 'required'
-require 'test/unit'
-
-class TestTheoryConnector < Test::Unit::TestCase
-  include ContainsTheories
-  
-  def setup
-    super 
-    @potential_values = [
-        Parser.run('0'),
-        Parser.run('test_cases'),
-        Parser.run('runtime_method')
-    ] 
-    @connector = TheoryConnector.new(@potential_values)
-  end
-  
-  def teardown
-    System.reset
-    RuntimeMethod.reset_global_id        
-  end
-  
-  def test_initialize
-    assert_nothing_raised(){TheoryConnector.new(@potential_values)}   
-  end
-  
-  def test_chain_with_a_easy_problem_and_only_one_theory
-    
-    # Create the simple runtime method to be populated
-    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
-    ]
-    finish = Parser.run("if(runtime_method.all_pass?(test_cases))\nreturn true\nend")
-     
-    # NOTE: To solve this it just needs to include an action that returns the first variable
-    # Create the VERY simple theory to solve this.
-    theory_action = TheoryAction.new(
-      TheoryStatement.new(StringToTheory.run('Statement.new(Return.new,var1.params[0])')),
-      StringToTheory.run('var1.statement_id')
-    )
-    result_one = TheoryResult.new(
-      StringToTheory.run("if(var1.all_pass?(var2))\nreturn true\nend")
-    )    
-    solution_theory = Theory.new([],theory_action,[result_one])
-    assert(@connector.chain(runtime_method,test_cases,finish,[solution_theory]).kind_of?(Array))
-    assert_equal(1,@connector.chain(runtime_method,test_cases,finish,[solution_theory]).length)
-    assert(@connector.chain(runtime_method,test_cases,finish,[solution_theory]).all? {|x| x.kind_of?(Chain)})
-    assert(@connector.chain(runtime_method,test_cases,finish,[solution_theory]).all? {|x| x.length == 2})
-    
-    # Check that the generated chain works    
-    implemented = @connector.chain(runtime_method,test_cases,finish,[solution_theory]).first.implement
-    result = TheoryChainValidator.new.build(
-      runtime_method,
-      test_cases,
-      [implemented],
-      []
-    )
-    assert_equal(
-      true,
-      result.kind_of?(RuntimeMethod)
-    )
-        
-  end
-  
-  def test_create_possible_chain_extensions_with_a_very_simple_problem
-     
-    directory_path = $LOC+File.join('test','fixtures','chains','1')
-    raise StandardError.new("chain 1 does not exist") unless(File.exists?(directory_path))
-    dump_file = File.open(File.join(directory_path,'dump'),'r')
-         
-    initial_chain = Marshal.load(dump_file)     
-    theory_6 = Theory.load_theory(6)
-     
-    # Create the simple runtime method to be populated
-    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
-    ]
-    finish = Parser.run("if(runtime_method.all_pass?(test_cases))\nreturn true\nend")
-    
-    # TEMPORARY Hack remove all the results that don't resemble at least one of the theories
-    # dependents.
-    theory_dependents = [theory_6].inject([]) {|total,x| total += x.dependents}
-    new_results = []
-    initial_chain.first.results.each do |r|
-      if theory_dependents.any? {|x| r.same_structure?(x)}
-        new_results.push(r)
-      end
-    end
-    assert_equal(
-      1,
-      @connector.create_possible_chain_extensions(runtime_method,test_cases,finish,[theory_6],initial_chain).length
-    )   
-    assert_equal(
-      true,
-      @connector.chain(runtime_method,test_cases,finish,[theory_6]).all? {|x| x.kind_of?(Chain)}
-    )
-    
-  end
-  
-  def test_chain_with_a_marginally_more_complicated_problem
-    
-    # Create the simple runtime method to be populated
-    runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))
-    test_cases = [
-      {:params=>['sparky'], :output=>3},
-      {:params=>['pip'], :output=>3},
-    ]
-    finish = Parser.run("if(runtime_method.all_pass?(test_cases))\nreturn true\nend") 
-    assert_equal(
-      true,
-      @connector.chain(runtime_method,test_cases,finish,[@theory_3]).kind_of?(Array)
-    )      
-    assert_equal(
-      true,
-      @connector.chain(runtime_method,test_cases,finish,[@theory_3]).all? {|x| x.all? {|y| y.kind_of?(Theory)}}
-    )   
-    
-  end  
-  
-  def test_chain_with_addition_theory
-
-    runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new,MethodParameter.new))
-    test_cases = [
-      {:params=>['left 4','dead'], :output=>'left 4 dead'}
-    ]    
-    finish = Parser.run("if(runtime_method.all_pass?(test_cases))\nend")
-    
-  end
-  
-  def test_chain_with_2_theories
-
-    runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))
-    sparky = CTestCase.new
-    sparky[:params] = ['sparky']
-    sparky[:output] = 6
-    kel = CTestCase.new
-    kel[:params] = ['kel']
-    kel[:output] = 3
-    test_cases = [
-      sparky,kel
-    ]    
-    finish = Parser.run("if(runtime_method.all_pass?(test_cases))\nreturn true\nend")
-    theory_7 = Theory.load_theory(7)
-    theory_5 = Theory.load_theory(5)
-    
-    directory_path = $LOC+File.join('test','fixtures','chains','2')
-    raise StandardError.new("chain 2 does not exist") unless(File.exists?(directory_path))
-    dump_file = File.open(File.join(directory_path,'dump'),'r')    
-    initial_chain = Marshal.load(dump_file)         
-
-    # Temporary Hack remove all the results that don't resemble at least one of the theories
-    # dependents.
-    theory_dependents = [theory_7,theory_5].inject([]) {|total,x| total += x.dependents}
-    new_results = []
-    initial_chain.first.results.each do |r|
-      if theory_dependents.any? {|x| r.same_structure?(x)}
-        new_results.push(r)
-      end
-    end
-    #initial_chain.first.results = new_results
-    initial_chain.first.results = [new_results[0]]
-    
-    
-    #exit
-    # TEMP - Removing most of the dependents
-#    initial_chain.first.results.each_with_index do |x,i|
-#      #if x.write.include?('if(var1.realise2(var2[var3][:params]).params[var4].value.length == var2[var3][:output])')
-#      if x.write.include?('if(var1.realise2(var2[var3][:params]).params[var8].value.length == var2[var3][:output])')        
-#      end
-#    end
-#    exit
-    #initial_chain.first.results = initial_chain.first.results = [initial_chain.first.results[429]]
-    #initial_chain.first.results = initial_chain.first.results[0..1]
-    #if(var1.realise2(var2[var3][:params]).params[var4].value.length == var2[var3][:output])
-    
-
-#    # Quicker version thath uses pre-generated head
-#    assert_equal(
-#      true,
-#      @connector.create_possible_chain_extensions(
-#        runtime_method,
-#        test_cases,
-#        finish,
-#        [theory_4,theory_5],
-#        initial_chain
-#      ).kind_of?(Array)
-#    ) 
-
-#    assert_equal(
-#      true,
-#      @connector.chain(runtime_method,test_cases,finish,[theory_4,theory_5]).kind_of?(Array)
-#    )
-
-#    assert_equal(
-#      true,
-#      @connector.chain(runtime_method,test_cases,finish,[@theory_3]).all? do |x| 
-#        x.all? {|y| y.kind_of?(Theory)}
-#      end
-#    ) 
-#    assert_equal(
-#      true,
-#      @connector.chain(runtime_method,test_cases,finish,[theory_4,theory_5]).all? do |x| 
-#        x.all? {|y| y.kind_of?(Theory)}
-#      end
-#    )    
-#    assert(@connector.chain(runtime_method,test_cases,finish,[theory_4,theory_5]).length > 0)
-#    
-
-    assert_equal(
-      true,
-      @connector.create_possible_chain_extensions(
-        runtime_method,
-        test_cases,
-        finish,
-        [theory_7,theory_5],
-        initial_chain
-      ).any? {|x| x.length > 1 }
-     )
-    
-  end
-  
-  def test_with_case_1
-    theory_1 = Theory.load_theory(20) 
-    # TODO  Do I really want theories with out actions I should maybe move the result 
-    #       for theory_4 to theory 3. - UPDATE I'm pretty sure I need theories with out
-    #       actions need to confirm.
-    theory_2 = Theory.load_theory(14)
-    theory_3 = Theory.load_theory(15)
-    theory_4 = Theory.load_theory(12)
-    
-    # Create the initial starting chain from pre-existing chain
-    directory_path = $LOC+File.join('test','fixtures','chains','3')
-    raise StandardError.new("chain 3 does not exist") unless(File.exists?(directory_path))
-    dump_file = File.open(File.join(directory_path,'dump'),'r')    
-    initial_chain = Marshal.load(dump_file)       
-    
-    # Create the empty runtime method and test cases
-    runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))
-    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
-    ]    
-    finish = Parser.run("if(runtime_method.all_pass?(test_cases))\nreturn true\nend")
-    
-    initial_chain.remove_superfluous_head_results!([theory_1,theory_2,theory_3,theory_4])
-    
-    # Check that at least one complete chain is created
-    assert_equal(
-      true,
-      @connector.create_possible_chain_extensions(
-        runtime_method,
-        test_cases,
-        finish,
-        [theory_1,theory_2,theory_3,theory_4],
-        initial_chain
-      ).any? {|x| x.length > 1 }
-     )    
-     
-  end
-  
-  def test_unify_chain_with_a_very_simple_problem
-    
-    runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))
-    test_cases = [
-      {:params=>['sparky'], :output=>6},
-      {:params=>['kel'], :output=>3}
-    ]
-    finish = Parser.run("if(runtime_method.all_pass?(test_cases))\nreturn true\nend")
-    
-    theory_4 = Theory.load_theory(4)
-    theory_5 = Theory.load_theory(5)
-    
-    # Update the theries so their variables don't match to start
-    theory_4 = theory_4.map_to(Mapping.new({1=>TheoryVariable.new(8),2=>TheoryVariable.new(9),3=>TheoryVariable.new(10)}))
-    theory_5 = theory_5.map_to(Mapping.new({1=>TheoryVariable.new(109),2=>TheoryVariable.new(85),3=>TheoryVariable.new(23)}))
-    
-    assert_equal(
-      Array,
-      TheoryConnector.new([]).unify_chain([theory_4,theory_5]).class
-    )
-    assert_equal(
-      1,
-      TheoryConnector.new([]).unify_chain([theory_4,theory_5].reverse).length
-    )
-    TheoryConnector.new([]).unify_chain([theory_4,theory_5].reverse).each do |chain|
-      chain.each do |theory|
-      end
-    end
-    TheoryConnector.new([]).unify_chain([theory_4,theory_5].reverse).each do |chain|
-      assert_equal(
-        2,
-        chain.length
-      )
-    end
-    TheoryConnector.new([]).unify_chain([theory_4,theory_5].reverse).each do |chain|
-      assert_equal(
-        3,
-        chain.uniq_theory_variable_ids.length
-      )
-    end    
-    
-  end
-  
-  
-  def test_chain_with_chop_chop
-    
-    theory_1 = Theory.load_theory(16)
-    theory_2 = Theory.load_theory(17)
-    theory_3 = Theory.load_theory(18)    
-    #finish = Parser.run("if(runtime_method.pass?(test_cases[0]))\nreturn true\nend")
-    # [:params = [‘Belfast’], ‘result’ = ‘B’]
-    test_case_1 = CTestCase.new 
-    test_case_1[:params] = ['Belfast']
-    test_case_1[:output] = 'B'
-    test_cases = [
-      test_case_1
-    ] 
-    tc = Parser.run('test_cases')
-    tc_index_0 = IntrinsicLiteral.new(0)
-    real_method = Parser.run('runtime_method')
-    
-    finish = OpenStatement.new(
-      Statement.new(If.new,Container.new(InstanceCallContainer.new(real_method,Pass.new,ArrayAccess.new(tc,tc_index_0))))
-    )
-    finish << Statement.new(Return.new,True.new)
-    potential_values = MappingValues.new([
-        tc,
-        real_method,
-        tc_index_0,
-        IntrinsicLiteral.new(0),
-        Parser.run('last_runtime_method')
-    ])         
-    runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))
-    
-    connector = TheoryConnector.new(potential_values)
-    assert_equal(
-      2,
-      connector.chain(runtime_method,test_cases,finish,[theory_1,theory_2,theory_3]).length
-    )
-    
-  end
-  
-end

data/test/unit/theory/tc_theory_dependent.rb

@@ -1,153 +0,0 @@
-$LOAD_PATH << File.expand_path('../../../../lib',__FILE__)
-
-require 'required'
-require 'test/unit'
-
-class TestTheoryDependent < Test::Unit::TestCase
-  
-  def setup
-    # TODO  Need to include restriction so that theory dependents are always converted to if statements
-    # @dependent_one = TheoryDependent.new("var1.length = var2.length") - > WRONG!
-    @dependent_one = TheoryDependent.new(StringToTheory.run("if(var1.length = var2.length)\nend"))
-    @dependent_two = TheoryDependent.new(StringToTheory.run("if(var1.value.length = var2.length)\nend"))
-  end
-  
-  def teardown
-    System.reset
-    RuntimeMethod.reset_global_id    
-  end
-  
-  def test_intialize
-    assert_nothing_raised(){TheoryDependent.new(StringToTheory.run("if(var6 = 7)\nend"))}
-    assert_nothing_raised(){TheoryDependent.new(StringToTheory.run("if(var6 == 7)\nend"))}
-  end 
-  
-  def test_intialize_kind_of_statements
-    assert_nothing_raised(){TheoryDependent.new(StringToTheory.run("if(var1.kind_of?(RuntimeMethod))\nreturn true\nend"))}
-    assert_equal(
-      true,
-      TheoryDependent.new(StringToTheory.run("if(var1.kind_of?(RuntimeMethod))\nreturn true\nend")).describe.include?('return true')
-    )
-  end
-  
-  def test_intialize_with_addition_and_comparison
-    assert_nothing_raised(){
-      TheoryDependent.new(StringToTheory.run("if((var1 + var2) == var3)\nend"))
-    }
-    assert_equal(
-      3,
-      TheoryDependent.new(StringToTheory.run("if((var1 + var2) == var3)\nend")).theory_variables.length
-    )
-  end
-  
-  def test_intialize_with_block_statements
-    assert_nothing_raised(){
-      TheoryDependent.new(StringToTheory.run("if(var1.any? { |x| x.include? var2.statement_id })\nreturn true\nend"))
-    }
-    assert_equal(
-      2,
-      TheoryDependent.new(StringToTheory.run("if(var1.any? { |x| x.include? var2.statement_id })\nreturn true\nend")).theory_variables.length
-    )    
-  end    
-  
-  def test_intialize_with_if_statement_example
-    assert_nothing_raised(){
-      TheoryDependent.new(
-        StringToTheory.run("if((var1.history(var2[var4][:params]).any?{ |x| x.statement_id == var8.statement_id} ) == false)\nend")
-      )
-    }
-    assert_equal(
-      4,    
-      TheoryDependent.new(
-        StringToTheory.run("if((var1.history(var2[var4][:params]).any?{ |x| x.statement_id == var8.statement_id} ) == false)\nend")
-      ).theory_variables.length      
-    )
-  end
-  
-  def test_theory_variables
-    assert_equal(2,@dependent_one.theory_variables.length)
-    assert_equal(2,@dependent_two.theory_variables.length)
-  end
-  
-  def test_copy
-    a = StringToTheory.run("if(var1.length = var2.length)\nend")
-    
-  end
-  
-  def test_rewrite_with
-    assert_raises(StandardError) {@dependent_one.rewrite_with([])}
-    assert_equal(
-      "if(runtime_method.params[0].length = test_cases[0][:output].length)\nend",
-      @dependent_one.rewrite_with([
-        InstanceCallContainer.new(IntrinsicRuntimeMethod.new,ArrayAccess.new(Params.new,0)),
-        HashAccess.new(
-          ArrayAccess.new(
-            IntrinsicTestCases.new,
-            0
-          ),
-          Literal.new(:output)
-        )
-      ]).write
-    )
-  end
-  
-  def test_rewrite_with_using_a_long_replacement
-    assert_equal(
-      "if(runtime_method.params[0].value.length = test_cases[0][:output].length)\nend",
-      @dependent_one.rewrite_with([
-        Parser.run('runtime_method.params[0].value'),
-        Parser.run('test_cases[0][:output]')
-      ]).write
-    )
-  end
-  
-  def test_rewrite_with_too_few_replacements
-    assert_raises(StandardError){
-      @dependent_one.rewrite_with([
-        Parser.run('runtime_method.params[0].value')
-      ])
-    }
-  end  
-  
-  def test_rewrite_permutations
-    base_value_desc = [
-      Parser.run('runtime_method[:params][0]'),
-      Parser.run('test_cases[0][:params][0]'),
-      Parser.run('test_cases[0][:output]'),
-      Parser.run('test_cases[0][:params][0]'), 
-      Parser.run('test_cases[1][:output]')     
-    ] 
-    assert_equal(20,@dependent_one.rewrite_permutations(base_value_desc).length)
-    assert_equal(OpenStatement,@dependent_one.rewrite_permutations(base_value_desc).first.class)
-  end
-  
-  def test_map_to_1
-    dependent_one = TheoryDependent.new(StringToTheory.run("if(var2[var3].kind_of?(CTestCase))\nreturn true\nend"))
-    mapping = {2=>IntrinsicTestCases.new,3=>Literal.new(0)}
-    assert_equal(
-      "if(<test_cases>[0].kind_of?(CTestCase))\n  return true\nend\n",
-      dependent_one.map_to(mapping).describe
-    )
-  end
-  
-  def test_map_to_2
-    dependent_two = TheoryDependent.new(StringToTheory.run("if(var6.kind_of?(Fixnum))\nreturn true\nend"))
-    mapping = {6 => 0.to_literal}
-    assert_equal(
-      "if(0.kind_of?(Fixnum))\n  return true\nend\n",
-      dependent_two.map_to(mapping).describe
-    )
-  end  
-  
-  def test_map_to_3
-    dependent_three = TheoryDependent.new(
-      StringToTheory.run("if((var2[var3][:params][var6] == var2[var4][:params][var6])==false)\nreturn true\nend")
-    )
-    mapping = {2=>IntrinsicTestCases.new,3=>Literal.new(0),6=>0.to_literal,4=>1.to_literal}
-    assert_equal(
-      "if((<test_cases>[0][:params][0] == <test_cases>[1][:params][0]) == false)\n  return true\nend\n",
-      dependent_three.map_to(mapping).describe
-    )
-  end
-
-end