cauldron 0.1.3 → 0.1.5

data/test/unit/tc_variable_declaration.rb

@@ -1,32 +0,0 @@
-require 'required'
-require 'test/unit'
-
-class TestVariableDeclaration < Test::Unit::TestCase
-  
-  def setup
-    
-    # Create a simple string variable declaration
-    @string_var = VariableDeclaration.new('StringVariable','test'.to_declaration)
-    
-    # Test a array variable declaration
-    @animals = VariableDeclaration.new('ArrayVariable',['bear','cat','dog'].to_declaration)
-    
-  end
-  
-  def teardown
-System.reset
-    RuntimeMethod.reset_global_id
-  end  
-  
-  def test_copy
-    assert(@string_var.copy.kind_of?(VariableDeclaration))
-    assert_not_equal(@string_var.copy.object_id,@string_var.object_id)
-    assert(@animals.copy.kind_of?(VariableDeclaration))
-    assert_equal(@animals.copy.write,@animals.write)
-  end
-  
-  def test_write
-    assert_equal("ArrayVariable.new(['bear', 'cat', 'dog'])",@animals.write)
-  end
-  
-end

data/test/unit/theory/tc_theory_action.rb

@@ -1,108 +0,0 @@
-$LOAD_PATH << File.expand_path('../../../../lib',__FILE__)
-
-require 'cauldron'
-
-
-require 'test/unit'
-
-class TestTheoryAction < Test::Unit::TestCase
-  
-  def setup
-    @theory_action_one = TheoryAction.new(
-      TheoryStatement.new(StringToTheory.run('Statement.new(Return.new,var9)')),
-      StringToTheory.run('var1.statement_id')
-    )
-  end
-  
-  def teardown
-    System.reset
-    RuntimeMethod.reset_global_id        
-  end
-  
-  # Test the creation of a very simple theory action that just adds a 
-  # return statement to the runtime method.
-  #
-  def test_initialize_1
-      assert_nothing_raised(){TheoryAction.new(StringToTheory.run('return var9'),StringToTheory.run('var1.statement_id'))}
-      assert_raises(ArgumentError){TheoryAction.new()}
-      assert_equal(
-        "<runtime_method>.add_statement_at(return #{TheoryVariable.variable_colour(9)}var9#{TheoryVariable::NORMAL},#{TheoryVariable.variable_colour(1)}var1#{TheoryVariable::NORMAL}.statement_id)",
-        TheoryAction.new(StringToTheory.run('return var9'),StringToTheory.run('var1.statement_id')).describe
-      )
-  end
-  
-  def test_initialize_2
-    action_one = TheoryAction.new(
-      TheoryStatement.new(
-        StringToTheory.run('Statement.new(Parser.run("var4 = var1.params[0]"))')
-      ),
-      StringToTheory.run('var1.statement_id')
-    )
-    assert_equal(
-      "<runtime_method>.add_statement_at(Statement.new(Parser.run('var4 = var1.params[0]')),#{TheoryVariable.variable_colour(1)}var1#{TheoryVariable::NORMAL}.statement_id)",
-      action_one.describe  
-    )
-  end    
-  
-  def test_initialize_3
-    action = TheoryAction.new(
-      TheoryStatement.new(StringToTheory.run('Statement.new(Unknown.new,var1,Addition.new,var2)')),
-      StringToTheory.run('var1.statement_id')
-    )
-    assert_equal(
-      "<runtime_method>.add_statement_at(Statement.new(Unknown.new, #{TheoryVariable.variable_colour(1)}var1#{TheoryVariable::NORMAL}, Addition.new, #{TheoryVariable.variable_colour(2)}var2#{TheoryVariable::NORMAL}),#{TheoryVariable.variable_colour(1)}var1#{TheoryVariable::NORMAL}.statement_id)",
-      action.describe  
-    )
-  end
-  
-  def test_theory_variables
-    assert_equal(1,@theory_action_one.theory_variables.length)
-  end
-  
-  def test_map_to_with_simple_action
-    assert_equal(
-      "<runtime_method>.add_statement_at(Statement.new(Return.new, <test_cases>[0][:output]),#{TheoryVariable.variable_colour(1)}var1#{TheoryVariable::NORMAL}.statement_id)",
-      @theory_action_one.map_to({9=>Parser.run('test_cases[0][:output]')}).describe
-    )
-  end
-  
-  def test_map_to_with_complex_action
-    action = TheoryAction.new(
-      TheoryStatement.new(StringToTheory.run(
-        'OpenStatement.new(If.new,Container.new(var1.params[var3],Equivalent.new,var2[var4][:params][var5]))')
-      ),
-      StringToTheory.run('var1.statement_id')
-    )    
-    # #<Mapping:0xb7027288
-     # @hash=
-      # {5=>#<TheoryVariable:0xb7027148 @theory_variable_id=2>,
-       # 1=>#<TheoryVariable:0xb7027198 @theory_variable_id=1>,
-       # 2=>#<TheoryVariable:0xb70270f8 @theory_variable_id=3>,
-       # 3=>#<TheoryVariable:0xb70271fc @theory_variable_id=0>,
-       # 4=>#<TheoryVariable:0xb70270a8 @theory_variable_id=4>}>
-    m = Mapping.new({
-      1=>TheoryVariable.new(1),
-      2=>TheoryVariable.new(3),
-      3=>TheoryVariable.new(0),
-      4=>TheoryVariable.new(4),
-      5=>TheoryVariable.new(2)
-    })
-    assert_equal(
-      action.map_to(m).write,
-      "runtime_method.add_statement_at(OpenStatement.new(If.new, Container.new(var1.params[var0], Equivalent.new, var3[var4][:params][var2])),var1.statement_id)" 
-    )
-    
-  end
-  
-  def test_map_to_case_1_theory_1_action
-    action = TheoryAction.new(
-      TheoryStatement.new(StringToTheory.run(
-          'Statement.new(If.new,Container.new(var2[var3][:params][var6],Equivalent.new,var2[var3][:output]))'
-        )
-      ),
-      StringToTheory.run('var1.statement_id')
-    )
-    mapping = {2=>IntrinsicTestCases.new,3=>Literal.new(0),6=>0.to_literal}
-  end    
-  
-end

data/test/unit/theory/tc_theory_action_implementation.rb

@@ -1,23 +0,0 @@
-require 'required'
-require 'test/unit'
-
-class TestTheoryActionImplementation < Test::Unit::TestCase
-  include ContainsTheories  
-  
-  def setup
-  end
-
-  def teardown
-    System.reset
-    RuntimeMethod.reset_global_id        
-  end
-  
-  def test_copy
-    implementation_0 = load_theory_implementation(0)
-    assert_equal(
-      implementation_0.action.describe,
-      implementation_0.action.copy.describe
-    )
-  end
-  
-end

data/test/unit/theory/tc_theory_chain_validator.rb

@@ -1,340 +0,0 @@
-require 'required'
-require 'test/unit'
-
-class TestTheoryChainValidator < Test::Unit::TestCase
-  include ContainsTheories
-  
-  def setup
-    super 
-    # TODO  Note DRY - should match that used TestTheoryConnector
-    @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_build_with_a_very_simple_problem
-    
-    # Create the simple runtime method to be populated
-    runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))
-    test_cases = [
-      {:params=>['sparky'], :output=>'sparky'}
-    ]
-    finish = Parser.run("if(runtime_method.all_pass?(test_cases))\nreturn true\nend")
-    assert_nothing_raised(){
-      TheoryChainValidator.new.build(
-        runtime_method,
-        test_cases,
-        @connector.chain(runtime_method,test_cases,finish,[@theory_1]),
-        @potential_values
-      )
-    }
-    assert_equal(
-      true,
-      TheoryChainValidator.new.build(
-        runtime_method,
-        test_cases,
-        @connector.chain(runtime_method,test_cases,finish,[@theory_1]),
-        @potential_values
-      ).kind_of?(RuntimeMethod)
-    )    
-  end  
-  
-  def test_build_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=>6}
-    ]
-    finish = Parser.run("if(runtime_method.all_pass?(test_cases))\nreturn true\nend")      
-    assert_nothing_raised(){
-      TheoryChainValidator.new.build(
-        runtime_method,
-        test_cases,
-        @connector.chain(runtime_method,test_cases,finish,[@theory_3]),
-        @potential_values
-      )
-    }    
-    assert_equal(
-      true,
-      TheoryChainValidator.new.build(
-        runtime_method,
-        test_cases,
-        @connector.chain(runtime_method,test_cases,finish,[@theory_3]),
-        @potential_values).kind_of?(RuntimeMethod)
-      )
-    
-  end
-  
-  def test_build_with_more_than_one_test_case
-    
-    # Create the simple runtime method to be populated
-    runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))
-    test_cases = [
-      {:params=>['sparky'], :output=>'sparky'},
-      {:params=>['pip'], :output=>'pip'},
-      {:params=>['roweIAGE'], :output=>'roweIAGE'},
-    ]
-    finish = Parser.run("if(runtime_method.all_pass?(test_cases))\nreturn true\nend") 
-    
-    assert_nothing_raised(){
-      TheoryChainValidator.new.build(
-        runtime_method,
-        test_cases,
-        @connector.chain(runtime_method,test_cases,finish,[@theory_1]),
-        @potential_values
-      )
-    }    
-    assert_equal(
-      true,
-      TheoryChainValidator.new.build(
-        runtime_method,
-        test_cases,
-        @connector.chain(runtime_method,test_cases,finish,[@theory_1]),
-        @potential_values
-      ).kind_of?(RuntimeMethod)
-    )    
-    
-  end
-  
-  def test_build_with_more_than_one_theory
-    
-    # Create the simple runtime method to be populated
-    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},
-    ]
-    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)
-    
-    potential_values = [
-        Parser.run('0'),
-        Parser.run('test_cases'),
-        Parser.run('runtime_method')
-    ] 
-    connector = TheoryConnector.new(potential_values)
-    
-    
-    chains = connector.chain(runtime_method,test_cases,finish,[theory_7,theory_5])
-    assert_equal(1,chains.length)
-
-    assert_equal(
-      true,
-      TheoryChainValidator.new.build(
-        runtime_method,
-        test_cases,
-        chains,
-        potential_values
-      ).kind_of?(RuntimeMethod)
-    )    
-    # TODO  Should include specfic implementation chain that works and one that doesn't
-    #       for better testing.
-    
-  end    
-  
-  def test_build_with_two_params
-
-    # Create the simple runtime method to be populated
-    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))\nreturn true\nend")    
-    theory_8 = Theory.load_theory(8)
-    
-    # TODO  I'll need to start generating the potential values based on the particular test cases
-    potential_values = [
-        Parser.run('0'),
-        Parser.run('1'),
-        Parser.run('test_cases'),
-        Parser.run('runtime_method')
-    ]     
-    
-    connector = TheoryConnector.new(potential_values)
-    chains = connector.chain(runtime_method,test_cases,finish,[theory_8])
-    assert_equal(
-      true,
-      TheoryChainValidator.new.build(
-        runtime_method,
-        test_cases,
-        chains,
-        potential_values
-      ).kind_of?(RuntimeMethod)
-    )
-    # Action Needed: 
-    #
-    #    runtime_method.add_statement_at(
-    #      Statement.new(Unknown.new,Equal.new,runtime_method.params[0],Addition.new,runtime_method.params[1]),
-    #      0
-    #    ) 
-    #   or
-
-    # Action statement needs to write - theory Statement
-    # Statement.new(Unknow.new,var1,Addition.new,var2)
-    #
-    # or
-    #
-    # StringToTheory.run('Statement.new(Unknown.new,var1,Addition.new,var2)')
-    # where var1 and var2 are theory variables that are substituted
-    
-    # So the statement
-    #   a = StringToTheory.run('Parser.run("var = var1 + var2")')
-    #   where var1 and var2 are the theory variables
-    #
-    #   they get substituted say var1 = runtime_method.params[0] and var2 = runtime_method.params[2]
-
-    #   So the implementation is 
-    #
-    #   'Parser.run("var = runtime_method.params[0] + runtime_method.params[2]")'
-    # TODO  For clarity I should distingish in syntax between theory variables and
-    #       regular variables e.g. x1 and y1. 
-
-    
-  end
-  
-  def test_build_with_case_1
-    theory_1 = Theory.load_theory(13) 
-    theory_2 = Theory.load_theory(14)
-    theory_3 = Theory.load_theory(15)
-    theory_4 = Theory.load_theory(12)
-    
-    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
-    ]
-    
-    tc = Parser.run('test_cases')
-    tc_index_0 = IntrinsicLiteral.new(0)
-    tc_index_1 = IntrinsicLiteral.new(1)
-    param_0 = IntrinsicLiteral.new(0)
-    real_method = Parser.run('runtime_method') 
-    last_real_method = Parser.run('last_runtime_method')    
-    
-    finish = OpenStatement.new(
-      Statement.new(If.new,Container.new(InstanceCallContainer.new(real_method,AllPass.new,tc)))
-    )
-    finish << Statement.new(Return.new,True.new)
-    potential_values = MappingValues.new([tc,tc_index_0,tc_index_1,param_0,real_method,last_real_method])  
-
-    connector = TheoryConnector.new(potential_values)
-    chains = connector.chain(runtime_method,test_cases,finish,[theory_1,theory_2,theory_3,theory_4])
-    
-    assert_equal(
-      true,
-      TheoryChainValidator.new.build(
-        runtime_method,
-        test_cases,
-        chains,
-        potential_values
-      ).kind_of?(RuntimeMethod)
-    ) 
-  end  
-  
-  def test_build_method_from_chain
-    theory_1 = Theory.load_theory(16)
-    theory_2 = Theory.load_theory(17)
-    theory_3 = Theory.load_theory(18)
-    
-    # [: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)
-    chains = connector.chain(runtime_method,test_cases,finish,[theory_1,theory_2,theory_3])
-    chains.each do |x|
-      assert_nothing_raised(){TheoryChainValidator.new.build_method_from_chain(x,runtime_method,test_cases)}
-    end
-    
-    assert_equal(
-      true,
-      TheoryChainValidator.new.build_method_from_chain(chains[1],runtime_method,test_cases).kind_of?(RuntimeMethod)
-    )
-    
-  end
-  
-  def test_build_with_chop_chop
-
-#     TODO  Uncomment this  - it should be available
-    
-#    theory_1 = Theory.load_theory(16)
-#    theory_2 = Theory.load_theory(17)
-#    theory_3 = Theory.load_theory(18)    
-#    
-#    # [: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)
-#    chains = connector.chain(runtime_method,test_cases,finish,[theory_1,theory_2,theory_3])
-#    assert_equal(
-#      true,
-#      TheoryChainValidator.new.build(
-#        runtime_method,
-#        test_cases,
-#        chains,
-#        potential_values
-#      ).kind_of?(RuntimeMethod)
-#    )     
-    
-  end  
-  
-  
-end