cauldron 0.1.0

data/test/unit/theory/tc_theory_implementation.rb

@@ -0,0 +1,133 @@
+require 'required'
+require 'test/unit'
+ 
+class TestTheoryImplementation < Test::Unit::TestCase
+  include ContainsTheories  
+  
+  def setup
+    super
+    
+    demo_1_test_case_1 = CTestCase.new 
+    demo_1_test_case_1[:params] = ['sparky']
+    demo_1_test_case_1[:output] = 'sparky'
+    demo_1_test_case_2 = CTestCase.new
+    demo_1_test_case_2[:params] = ['kel']
+    demo_1_test_case_2[:output] = 'kel'
+    @case_1_test_cases = [
+      demo_1_test_case_1,demo_1_test_case_2
+    ]    
+    @case_1_runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))
+    
+  end
+  
+  def teardown
+    System.reset
+    RuntimeMethod.reset_global_id        
+  end
+  
+  def test_leads_to
+    
+    # TODO  I need a better way to rebuild the implementations - I need to be able to save the declaration probably
+    #       It could grep the desc.txt for those in the theory - I need to be able to rebuild them.
+   implementation_0 = load_theory_implementation(0)
+    finish = Parser.run("if(runtime_method.all_pass?(test_cases))\nreturn true\nend")
+    assert_equal(
+      true,
+      implementation_0.leads_to?(finish)
+    )
+  end
+  
+  def test_copy
+    implementation_0 = load_theory_implementation(0)
+    assert_equal(
+      implementation_0.describe,
+      implementation_0.copy.describe
+    )
+  end
+    
+  # Test the creation of a very simple theory action that just adds a 
+  # return statement to the runtime method.
+  #
+  def test_theory_three_implementations
+    # TODO  Need to raise error if number of values available doesn't meet
+    #       the theory.  This just doesn't return an permutations if you only
+    #       supply.
+    # TODO  Also need a quick check that all the theories are included in the test suite 
+    values = [
+      Parser.run('runtime_method'),
+      Parser.run('test_cases'),
+      Parser.run('0')
+    ]
+    assert_nothing_raised(){@theory_3.rewrite_permutations(values)}
+    assert_equal(6,@theory_3.rewrite_permutations(values).length)
+    
+    #first_imlementation = @theory_3.rewrite_permutations(values).first
+    #  if: 
+    #    if(runtime_method.params[0].value.length == test_cases[0][:output])
+    #    end
+    #  action: 
+    #    <runtime_method>.add_statement_at(Statement.new(Return.new(), InstanceCallContainer.new(runtime_method.params[0], StringLength.new())),0)
+    #  result: 
+    #    runtime_method.all_pass?(test_cases) = true
+    runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))
+    test_cases = [
+      {:params=>['sparky'], :output=>6}
+    ]
+    first_imlementation = @theory_3.rewrite_permutations(values).first
+    assert_equal(true,first_imlementation.meets_dependencies?(runtime_method.copy,test_cases))
+    
+    test_cases = [
+      {:params=>['pip'], :output=>3}
+    ]
+    first_imlementation = @theory_3.rewrite_permutations(values).first
+    assert_equal(true,first_imlementation.meets_dependencies?(runtime_method.copy,test_cases))
+     
+    # NOTE: Although the theory is strickly speaking wrong here because it only uses the 
+    #       first paramter - this fine here though because this method only checks the 
+    #       dependencies are met. 
+    test_cases = [
+      {:params=>['sparky'], :output=>6},
+      {:params=>['pip'], :output=>3},
+    ]    
+    first_imlementation = @theory_3.rewrite_permutations(values).first
+    assert_equal(true,first_imlementation.meets_dependencies?(runtime_method.copy,test_cases))
+      
+  end
+  
+  def test_meets_dependencies__with_theory_17
+#     #TODO  Uncomment this - it is a valid test    
+#    theory = Theory.load_theory(17)
+#    
+#    # Create the runtime method and test cases that should pass the theories dependents
+#    test_case_1 = CTestCase.new 
+#    test_case_1[:params] = ['waz']
+#    test_case_1[:output] = 'B'
+#    test_cases = [
+#      test_case_1
+#    ]
+#    runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))
+#    
+#    # Create the mapping for the theory
+#    m = Mapping.new(
+#      {
+#        1=>IntrinsicRuntimeMethod.new,
+#        2=>IntrinsicLiteral.new(0),
+#        3=>IntrinsicTestCases.new,
+#        4=>IntrinsicLiteral.new(0),
+#        5=>Parser.run('last_runtime_method')
+#      }
+#    )
+#    
+#    # Add the statement to the runtime method to make the dependent correct
+#    s = BlockStatement.new(Statement.new(InstanceCallContainer.new(Container.new(InstanceCallContainer.new(runtime_method.params[0], StringLength.new), Subtract.new, 1), Times.new)))
+#    runtime_method.push(s)
+#    
+#    implementation = theory.map_to(m)
+#    pp runtime_method.history2(test_cases[0][:params])
+#    assert_equal(
+#      true,
+#      implementation.meets_dependencies?(runtime_method,test_cases)
+#    )      
+  end
+  
+end

data/test/unit/theory/tc_theory_result.rb

@@ -0,0 +1,111 @@
+require 'required'
+require 'test/unit'
+
+class TestTheoryResult < Test::Unit::TestCase
+  include ContainsTheories
+  
+  def setup
+    
+  end
+  
+  def teardown
+    System.reset
+    RuntimeMethod.reset_global_id    
+  end
+  
+  def test_intialize_1
+#    assert_equal(
+#      "if(<runtime_method>.all_pass?(<test_cases>))\nreturn true\nend",
+#      TheoryResult.new(Parser.run("if(runtime_method.all_pass?(test_cases))\nreturn true\nend")).describe
+#    )
+  end
+  
+  def test_intialize_3
+     assert_equal(
+      "if(#{TheoryVariable.variable_colour(1)}var1#{TheoryVariable::NORMAL}.length == #{TheoryVariable.variable_colour(2)}var2#{TheoryVariable::NORMAL})\n\treturn true\nend\n",
+      TheoryResult.new(
+        StringToTheory.run("if(var1.length == var2)\n\treturn true\nend")
+      ).describe
+     )
+  end
+  
+  def test_validates_2
+
+    implementation = load_theory_implementation(2)
+    
+    # TODO  Should have the runtime method as a fixture so this evaluation isn't necessary
+    runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))
+    test_cases = [
+      {:params=>['sparky'], :output=>'sparky'.length},
+      {:params=>['pip'], :output=>'pip'.length},
+      {:params=>['roweIAGE'], :output=>'roweIAGE'.length},
+    ]    
+    evaluation_code = ''
+    evaluation_code += "test_cases = #{test_cases.write}"+"\n"
+    evaluation_code += "runtime_method = #{runtime_method.to_declaration.write}"+"\n"
+    evaluation_code += 'runtime_method.add_statement_at(Statement.new(Return.new, runtime_method.params[0]),runtime_method.statement_id)'+"\n"
+    
+    evaluation_code += 'return runtime_method'+"\n"        
+    result = CodeEvaluation.new.evaluate_code(evaluation_code)  
+    assert(true,implementation.results.all? {|x| x.validates?(result,test_cases)})
+    
+  end
+  
+  def test_same_structure_1
+    # TODO  Fixtures should include implemented TheoryResult and TheoryResults - I don't like using first
+    implementation = load_theory_implementation(1)
+    theory = Theory.load_theory(1)
+    
+    implemented_result = load_implementation_result(0)
+    theory_result = theory.results.first
+    
+    assert_equal(
+      true,
+      theory_result.same_structure?(implemented_result.statement)
+    )
+  end
+     
+  def test_same_structure_4
+    # TODO  Fixtures should include implemented TheoryResult and TheoryResults - I don't like using first
+    theory = Theory.load_theory(4)
+    
+    implemented_result = load_implementation_result(0)
+    theory_result = theory.results.first
+    assert_equal(
+      false,
+      theory_result.same_structure?(implemented_result.statement)
+    )    
+  end
+  
+  def test_map_to_with_case_1_theory_1
+    result_one = TheoryResult.new(StringToTheory.run(
+      "if(var1.history(var2[var3][:params]).any? { |x| x.statement_id == var1.last.statement_id })\nreturn true\nend"
+    ))
+    mapping = {
+      1=>IntrinsicRuntimeMethod.new,
+      2=>IntrinsicTestCases.new,
+      3=>Literal.new(0),
+      4=>1.to_literal,
+      6=>0.to_literal
+    }
+    assert_equal(
+      "if(<runtime_method>.history(<test_cases>[0][:params]).any?{ |x| x.statement_id == <runtime_method>.last.statement_id} )\n\treturn true\nend\n",
+      result_one.map_to(mapping).describe
+    )
+  end
+  
+  def test_map_to_with_example_1
+    result = TheoryResult.new(
+      StringToTheory.run("if((var1.params[var3].length == var1) == false)\nreturn true\nend")
+    )
+    mapping = {
+      1=>IntrinsicRuntimeMethod.new,
+      3=>IntrinsicLiteral.new(0)
+    }
+    assert_equal(
+      "if((runtime_method.params[0].length == runtime_method) == false)\n\treturn true\nend",
+      result.map_to(mapping).write    
+    )
+  end
+   
+end

data/test/unit/theory/tc_theory_variable.rb

@@ -0,0 +1,45 @@
+require 'required'
+require 'test/unit'
+
+class TestTheoryVariable < Test::Unit::TestCase
+  
+  def setup
+    
+  end
+  
+  def teardown
+    System.reset
+    RuntimeMethod.reset_global_id        
+  end
+  
+  def test_initialize
+    assert_nothing_raised(){TheoryVariable.new(8)}
+    assert_raise(ArgumentError) {TheoryVariable.new}
+  end
+  
+  def test_write
+    assert_equal(
+      TheoryVariable.new(7).describe,
+      "#{TheoryVariable.variable_colour(7)}var7#{TheoryVariable::NORMAL}"
+    )
+    assert_not_equal(
+      TheoryVariable.new(14).write,
+      "#{TheoryVariable.variable_colour(7)}var7#{TheoryVariable::NORMAL}"
+    )
+  end  
+  
+  def test_to_declaration
+    assert_equal(TheoryVariable.new(9).to_declaration.write,'TheoryVariable.new(9)')
+    assert_not_equal(TheoryVariable.new(10).to_declaration.write,'TheoryVariable.new(9)')
+  end
+  
+  def test_subtacting_arrays
+    var8 = TheoryVariable.new(8)
+    var7 = TheoryVariable.new(7)
+    varX = TheoryVariable.new(8)
+    assert_equal(varX.theory_variable_id,var8.theory_variable_id)
+    assert_equal(var7.theory_variable_id,7)
+    assert_equal(1, ([var8,var7]-[varX]).length)
+  end
+  
+end

data/test/unit/util/tc_method_validation.rb

@@ -0,0 +1,98 @@
+require 'required'
+require 'test/unit'
+
+class TestMethodValidation < Test::Unit::TestCase
+  
+  def setup
+  end
+  
+  def teardown
+    System.reset
+    RuntimeMethod.reset_global_id
+  end  
+
+  def test_self_generate
+    
+    # Check that a simple method to check the class of a runtime method instance can be created
+    validation_test_1 = MethodValidation.generate_attribute_test('.class.to_s == "RuntimeMethod"' )
+    assert(validation_test_1.kind_of?(RuntimeMethod))   
+    assert_equal(
+      true,
+      MethodValidation.new.use_runtime_method(
+        validation_test_1,ParametersContainer.new(RuntimeMethod.new(MethodUsage.new).to_declaration)
+      )
+    )
+    
+    # Create the method that should be evaluated correctly
+    test_2_method = RuntimeMethod.new(MethodUsage.new)
+    test_2_method.push Statement.new(Return.new,'Lilly'.to_literal)
+
+    # Test that a runtime method returns 'Lilly'
+    validation_test_2 = MethodValidation.generate_response_test(" == 'Lilly'",[])
+    assert(validation_test_2.kind_of?(RuntimeMethod))
+    assert_equal(
+      true,
+      MethodValidation.new.use_runtime_method_2(validation_test_2,test_2_method)
+    )
+    validation_test_3 = MethodValidation.generate_response_test(" != 'Lilly'",[])
+    assert_equal(
+      false,
+      MethodValidation.new.use_runtime_method_2(validation_test_3,test_2_method)
+    )    
+#    
+#    # Test that a runtime method returns the value it is passed
+#    test_3_param_1 = MethodParameter.new
+#    test_3_method = RuntimeMethod.new(MethodUsage.new(test_3_param_1))
+#    test_3_method.push(Statement.new(Return.new,test_3_param_1))
+#    test_3_validation = MethodValidation.generate(
+#      {:condition=>' == "Pip"',:target=>'response',:params=>['Pip'.to_literal],:runtime_method=>test_3_method})
+#    assert_equal(
+#      'Pip',
+#      MethodValidation.new.use_runtime_method(
+#        test_3_validation,ParametersContainer.new(test_3_method.to_declaration)        
+#      )
+#    )
+    
+    
+  end
+  
+  
+  def test_use_runtime_method      
+    
+    # Test that the following runtime method returns true
+    # def method_0
+    #   return true
+    # end
+    method_0 = RuntimeMethod.new(MethodUsage.new)
+    method_0.push Statement.new(Return.new,True.new)
+    assert_equal(true,MethodValidation.new.use_runtime_method(method_0))
+    
+    # Test that the following runtime method returns 'Kelly'
+    # def method_1
+    #   return 'Kelly'
+    # end
+    method_1 = RuntimeMethod.new(MethodUsage.new)
+    method_1.push Statement.new(Return.new,'Kelly'.to_literal)
+    assert_equal('Kelly',MethodValidation.new.use_runtime_method(method_1))
+    assert_not_equal('kelly',MethodValidation.new.use_runtime_method(method_1))    
+    
+    # Test that this method returns the string passed to it
+    # def method_2(param_1)
+    #   return param_1
+    # end
+    method_2_param_1 = MethodParameter.new
+    method_2 = RuntimeMethod.new(MethodUsage.new(method_2_param_1))
+    method_2.push Statement.new(Return.new,method_2_param_1)
+    assert_equal('Marc',MethodValidation.new.use_runtime_method(method_2,ParametersContainer.new('Marc'.to_literal)))
+    
+    # Test that this method adds both of the numbers and returns it
+    method_3_param_1, method_3_param_2 = MethodParameter.new, MethodParameter.new
+    method_3 = RuntimeMethod.new(MethodUsage.new(method_3_param_1,method_3_param_2))
+    method_3_unknown_1 = Unknown.new
+    method_3.push Statement.new(method_3_unknown_1,Equal.new,method_3_param_1,Addition.new,method_3_param_2)
+    assert_equal(8,MethodValidation.new.use_runtime_method(method_3,ParametersContainer.new(2.to_literal,6.to_literal)))
+    assert_not_equal(9,MethodValidation.new.use_runtime_method(method_3,ParametersContainer.new(2.to_literal,6.to_literal)))    
+    
+  end  
+      
+end

data/test/unit/util/tc_parser.rb

@@ -0,0 +1,108 @@
+require 'required'
+require 'test/unit'
+
+class TestParser < Test::Unit::TestCase
+  
+  def setup
+    
+  end
+  
+  def teardown
+    
+  end
+  
+  def test_run_with_literal_number_conversion
+    assert_equal('9',Parser.run('9').write)
+    assert_not_equal('9',Parser.run('10').write)
+  end
+  
+  def test_run_with_literal_string_conversion
+    assert_equal("'test'",Parser.run("'test'").write)
+    assert_equal("'10 million fireflies'",Parser.run("'10 million fireflies'").write)
+  end
+  
+  def test_run_with_single_variable
+    assert_equal('var_8',Parser.run('var8').write)
+  end
+  
+  def test_run_with_a_instance_method_call
+    assert_equal('var_8.length',Parser.run('var8.length').write)
+    assert(Parser.run('var8.length').kind_of?(InstanceCallContainer))
+  end
+  
+  def test_run_with_a_literal_method_call
+    assert_equal("'new vegas'.length",Parser.run("'new vegas'.length").write)
+  end
+  
+  def test_run_with_intrinsic_runtime_method
+    assert_equal('runtime_method.params',Parser.run('runtime_method.params').write)
+    assert_equal('runtime_method.params[0]',Parser.run('runtime_method.params[0]').write)
+    assert_equal('test_cases[0]',Parser.run('test_cases[0]').write)
+    assert_equal('test_cases[0][:output]',Parser.run('test_cases[0][:output]').write)
+    assert_equal('test_cases[0].params[0]',Parser.run('test_cases[0].params[0]').write)
+    assert_equal('runtime_method.params[0].value',Parser.run('runtime_method.params[0].value').write)
+  end
+  
+  def test_run_with_array_elements
+    assert_equal('var_6[8]',Parser.run('var6[8]').write)    
+  end
+  
+  def test_run_with_return_statement
+    assert_equal('return true',Parser.run('return true').write)
+    assert_equal('Statement',Parser.run('return true').class.to_s)
+  end
+  
+  def test_run_with_theory_result_1
+    assert_equal(
+      'runtime_method.all_pass?(test_cases)',
+      Parser.run('runtime_method.all_pass?(test_cases)').write
+    )      
+  end
+  
+  def test_run_with_next
+    assert_equal(
+      'next',
+      Parser.run('next').write
+    )
+  end
+  
+  def test_run_with_push
+    assert_equal(
+     'var_1.push(8)',
+      Parser.run('var1.push(8)').write
+    )    
+  end    
+  
+  def test_run_adding_two_variables
+    assert_equal(
+     'var_1 = var_2 + var_3',
+      Parser.run('var1 = var2 + var3').write
+    )       
+  end 
+  
+  def test_run_with_history_call
+    assert_equal(
+      'var_1.history(var_2)',
+      Parser.run('var1.history(var2)').write
+    )
+  end    
+  
+  def test_run_with_a_populated_if_statement
+    assert_equal(
+      "if(runtime_method.all_pass?(test_cases))\nend",
+      Parser.run("if(runtime_method.all_pass?(test_cases))\nend").write
+    ) 
+    assert_equal(
+      "if(runtime_method.all_pass?(test_cases))\n\treturn true\nend",
+      Parser.run("if(runtime_method.all_pass?(test_cases))\nreturn true\nend").write
+    )
+  end    
+  
+  def test_run_when_adding_a_number_and_fixnum
+    assert_equal(
+      "var_2 = var_5.chop + var_2",
+      Parser.run("var2 = var5.chop + var2").write
+    )
+  end
+  
+end