cauldron 0.1.3 → 0.1.5

data/test/unit/theory/tc_theory_implementation.rb

@@ -1,137 +0,0 @@
-$LOAD_PATH << File.expand_path('../../../../lib',__FILE__)
-
-require 'cauldron'
-
-
-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

@@ -1,112 +0,0 @@
-$LOAD_PATH << File.expand_path('../../../../lib',__FILE__)
-
-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  return true\nend\n",
-      TheoryResult.new(
-        StringToTheory.run("if(var1.length == var2)\n  return 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 = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))"+"\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  return 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  return true\nend",
-      result.map_to(mapping).write    
-    )
-  end
-   
-end

data/test/unit/theory/tc_theory_variable.rb

@@ -1,45 +0,0 @@
-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

@@ -1,101 +0,0 @@
-$LOAD_PATH << File.expand_path('../../../../lib',__FILE__)
-
-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

@@ -1,110 +0,0 @@
-$LOAD_PATH << File.expand_path('../../../../lib',__FILE__)
-
-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  return 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