cauldron 0.1.3 → 0.1.5

data/test/unit/tc_chain_mapping.rb

@@ -1,62 +0,0 @@
-require 'required'
-require 'test/unit'
-
-class TestInstanceCallStructure < Test::Unit::TestCase
-  
-  def setup
-    
-  end
-  
-  def teardown
-    System.reset
-    RuntimeMethod.reset_global_id
-  end  
-
-  def test_find_global_with_simple_mapping
-    
-    starting_mapping = { 
-      0 => {:head=>8,0=>0,1=>2}
-    }
-    chain_mapping = ChainMapping.new(starting_mapping)
-    assert_equal(0,chain_mapping.find_global(:head,8))
-    assert_equal(0,chain_mapping.find_global(1,2))
-    assert_equal(0,chain_mapping.find_global(0,0))
-    assert_equal(nil,chain_mapping.find_global(0,3))
-              
-  end
-  
-  def test_find_global_with_medium_mapping
-    starting_mapping = { 
-      0 => {:head=>0,0=>0,1=>4},
-      3 => {:head=>3,0=>1,1=>5},
-      5 => {:head=>5,0=>2,1=>6,:tail=>7},
-      6 => {:head=>6,0=>4,1=>8},
-    }
-    chain_mapping = ChainMapping.new(starting_mapping)
-    assert_equal(0,chain_mapping.find_global(:head,0))
-    assert_equal(5,chain_mapping.find_global(:head,5))
-    assert_equal(5,chain_mapping.find_global(0,2))
-    assert_equal(6,chain_mapping.find_global(1,8))
-    assert_equal(nil,chain_mapping.find_global(1,9))
-    assert_equal(nil,chain_mapping.find_global(4,9))    
-  end
-  
-  def test_add_mapping
-    starting_mapping = { 
-      0 => {:head=>0,4=>0,1=>4},
-      3 => {:head=>3,4=>1,1=>5},
-      5 => {:head=>5,4=>2,1=>6,:tail=>7},
-      6 => {:head=>6,4=>4,1=>8},
-    }
-    chain_mapping = ChainMapping.new(starting_mapping)
-    assert_nothing_raised(){chain_mapping.add_mapping(3,5,7)}
-    assert_equal(3,chain_mapping.find_global(5,7))
-    assert_equal(3,chain_mapping.find_global(4,1))
-    assert_equal(nil,chain_mapping.find_global(5,8))
-    
-    # Test adding a new global id
-    chain_mapping.add_mapping(7,5,9)
-    assert_equal(7,chain_mapping.find_global(5,9))
-  end
-
-end

data/test/unit/tc_chain_with_case_1.rb

@@ -1,169 +0,0 @@
-require 'required'
-require 'test/unit'
-
-# These are the simple tests for chin that generates the following runtime 
-# method.
-#
-# def method_1(var1)
-#   if var1 == 'something'
-#     return 'exist'
-#   end
-#   return 'does not exists'
-# end
-#
-class TestChainWithCase1 < Test::Unit::TestCase
-  
-  # NOTE: This is the chain without the last runtime included - this will be in a different test case
-  def setup
-    
-    # Create te head for the theory
-    head_result_one = TheoryResult.new(StringToTheory.run("if(var2[var3].kind_of?(CTestCase))\nreturn true\nend"))
-    head_result_two = TheoryResult.new(
-      StringToTheory.run("if((var2[var3][:params][var6] == var2[var4][:params][var6])==false)\nreturn true\nend")
-    )
-    @head = Theory.new([],nil,[head_result_one,head_result_two])
-    @head_values =  { 2=>IntrinsicTestCases.new,
-                      3=>IntrinsicLiteral.new(0),
-                      4=>IntrinsicLiteral.new(1),
-                      6=>IntrinsicLiteral.new(0)
-                    }
-    
-    # Create the four links that needed added to complete the solution
-    # ========================== theory 1 ===========================
-    t1_dependent_one = TheoryDependent.new(StringToTheory.run("if(var2[var3].kind_of?(CTestCase))\nreturn true\nend"))
-    t1_dependent_two = TheoryDependent.new(
-      StringToTheory.run("if((var2[var3][:params][var6] == var2[var4][:params][var6])==false)\nreturn true\nend")
-    )
-    t1_action = TheoryAction.new(
-      TheoryStatement.new(StringToTheory.run(
-        'OpenStatement.new(Statement.new(If.new,Container.new(var1.params[var6],Equivalent.new,var2[var3][:params][var6])))'
-      )),
-      StringToTheory.run('var1.statement_id')
-    )
-    t1_result_one = TheoryResult.new(StringToTheory.run(
-      "if(var1.history2(var2[var3][:params]).any? { |x| x['statement_id'] == var1.last.statement_id })\nreturn true\nend"
-    ))
-    t1_result_two = TheoryResult.new(StringToTheory.run(
-      "if((var1.history2(var2[var4][:params]).any? { |x| x['statement_id'] == var1.last.statement_id })==false)\nreturn true\nend"
-    ))    
-    @theory_one = Theory.new(
-      [t1_dependent_one,t1_dependent_two],
-      t1_action,
-      [t1_result_one,t1_result_two]
-    )
-    @theory_one_values =  { 1=>IntrinsicRuntimeMethod.new,
-                            2=>IntrinsicTestCases.new,
-                            3=>IntrinsicLiteral.new(0),
-                            4=>IntrinsicLiteral.new(1),
-                            6=>IntrinsicLiteral.new(0)
-                          }    
-    
-    # =================== Theory 2 ======================
-    t2_dependent_one = TheoryDependent.new(StringToTheory.run(
-      "if(var1.history2(var2[var3][:params]).any? { |x| x['statement_id'] == var1.last.statement_id })\nreturn true\nend"
-    ))
-    t2_dependent_two = TheoryDependent.new(StringToTheory.run(
-      "if((var1.history2(var2[var4][:params]).any? { |x| x['statement_id'] == var1.last.statement_id })==false)\nreturn true\nend"
-    ))
-    t2_action = TheoryAction.new(
-      TheoryStatement.new(StringToTheory.run('Statement.new(Return.new,var2[var3][:output])')),
-      StringToTheory.run('var1.last.statement_id')
-    )    
-    t2_result_one = TheoryResult.new(StringToTheory.run(
-      "if(var1.pass?(var2[var3]))\nreturn true\nend"
-    ))
-    t2_result_two = TheoryResult.new(StringToTheory.run(
-      "if(var1.pass?(var2[var4])==false)\nreturn true\nend"
-    ))    
-    @theory_two = Theory.new(
-      [t2_dependent_one,t2_dependent_two],
-      t2_action,
-      [t2_result_one,t2_result_two]
-    )    
-    @theory_two_values =  { 1=>IntrinsicRuntimeMethod.new,
-                            2=>IntrinsicTestCases.new,
-                            3=>IntrinsicLiteral.new(0),
-                            4=>IntrinsicLiteral.new(1),
-                            6=>IntrinsicLiteral.new(0)
-                          }        
-    
-    # =================== Theory 3 ======================
-    t3_dependent_one = TheoryDependent.new(StringToTheory.run(
-      "if(var1.pass?(var2[var3]))\nreturn true\nend"
-    ))
-    t3_dependent_two = TheoryDependent.new(StringToTheory.run(
-      "if(var1.pass?(var2[var4]) == false)\nreturn true\nend"
-    ))
-    t3_action = TheoryAction.new(
-      TheoryStatement.new(StringToTheory.run('Statement.new(Return.new,var2[var4][:output])')),
-      StringToTheory.run('var1.statement_id')
-    )
-    t3_result_one = TheoryResult.new(StringToTheory.run(
-      "if(var1.pass?(var2[var4]))\nreturn true\nend"
-    ))    
-    @theory_three = Theory.new(
-      [t3_dependent_one,t3_dependent_two],
-      t3_action,
-      [t3_result_one]
-    )    
-    @theory_three_values =  { 1=>IntrinsicRuntimeMethod.new,
-                            2=>IntrinsicTestCases.new,
-                            3=>IntrinsicLiteral.new(0),
-                            4=>IntrinsicLiteral.new(1)
-                          }      
-    
-    # ================== Theory 4 =======================
-    # NOTE: This one needs to get it's dependents from theory 3 and 2
-    t4_dependent_one = TheoryDependent.new(StringToTheory.run(
-      "if(var1.pass?(var2[var3]))\nreturn true\nend"
-    ))
-    t4_dependent_two = TheoryDependent.new(StringToTheory.run(
-      "if(var1.pass?(var2[var4]))\nreturn true\nend"
-    ))    
-    
-    t4_result_one = TheoryResult.new(StringToTheory.run(
-      "if(var1.all_pass?(var2))\nreturn true\nend"
-    ))        
-    @theory_four = Theory.new(
-      [t4_dependent_one,t4_dependent_two],
-      nil,
-      [t4_result_one]
-    )    
-    
-  end
-
-  def teardown
-    System.reset
-    RuntimeMethod.reset_global_id        
-  end  
-  
-  def test_implement
-    
-    # Start by creating a complete chain with the values
-    chain = Chain.new
-    
-    # Add the head link to the chain
-    chain_results = chain.add_link(@head,@head_values)
-    assert_equal(1,chain_results.length)
-    
-    # Add the next link to the chain
-    chain_results = chain_results[0].add_link(@theory_one,@theory_one_values)
-    assert_equal(1,chain_results.length)
-    
-    # Add the second link to the chain
-    chain_results = chain_results[0].add_link(@theory_two,@theory_two_values)
-    assert_equal(1,chain_results.length)
-    
-    # Add the third link to the chain
-    chain_results = chain_results[0].add_link(@theory_three,@theory_three_values)
-    assert_equal(1,chain_results.length)   
-    
-    # Add the fourth link to the chain
-    chain_results = chain_results[0].add_link(@theory_four,@theory_four_values)
-    assert_equal(true,chain_results.any? {|x| x.complete?})
-    
-  end
-
-
-end
-  

data/test/unit/tc_instance_call.rb

@@ -1,40 +0,0 @@
-require 'required'
-require 'test/unit'
-
-class TestInstanceCallContainer < Test::Unit::TestCase
-  
-  def setup
-  
-    # Create some example instance calls
-    @var_a = 'Stan'.to_var
-    @chop_instance_call_a = InstanceCallContainer.new(@var_a,Chop.new)
-    @length_instance_call_a = InstanceCallContainer.new(@var_a,StringLength.new)
-
-  end
-  
-  def teardown
-    System.reset
-    RuntimeMethod.reset_global_id
-  end  
-  
-  def test_literalise
-    
-#    # Tests ability to literalise simple 'stan'.chop
-#    assert('sta',@chop_instance_call_a.literalise)      
-#    
-#    # Test simple length call on 'stan'
-#    assert('stan'.length,@length_instance_call_a.literalise)      
-      
-  end
-  
-  def test_to_declaration
-    
-    # Check that the correct data type is returned
-    assert_kind_of(VariableDeclaration,@chop_instance_call_a.to_declaration)  
-    assert_equal("InstanceCallContainer.new(StringVariable.new('Stan'), Chop.new())",@chop_instance_call_a.to_declaration.write)
-
-    # TODO  Test a to_declaration call for a InstanceCallContainer with parameters
-    
-  end
-  
-end

data/test/unit/tc_method_usage.rb

@@ -1,35 +0,0 @@
-require 'required'
-require 'test/unit'
-
-class TestMethodUsage < Test::Unit::TestCase
-  
-  def setup
-  
-    # Create a basic method usage example
-    @empty_method_usage = MethodUsage.new
-    
-    # Requires a string variable
-    @method_var_a = MethodParameter.new
-    @string_paramater_case = MethodUsage.new(@method_var_a)
-
-  end
-  
-  def teardown
-    System.reset
-  end  
-  
-  def test_initialize
-    assert_raises(StandardError){MethodUsage.new('bad_boy')}
-  end
-  
-  # 
-  def test_to_var
-    assert(@empty_method_usage.to_var.kind_of?(MethodUsageVariable))
-    assert(@string_paramater_case.to_var.kind_of?(MethodUsageVariable))
-    assert_equal(1,@string_paramater_case.to_var.length)
-    assert_nothing_raised(){@string_paramater_case.to_var}
-    assert_equal(89,@empty_method_usage.to_var(89).variable_id)
-    assert_equal(99,@empty_method_usage.to_var(89,99).uniq_id)    
-  end
-  
-end

data/test/unit/tc_pot.rb

@@ -1,124 +0,0 @@
-require 'required'
-require 'test/unit'
-
-class TestInstanceCallStructure < Test::Unit::TestCase
-  
-  def setup
-    @cauldron = Cauldron::Pot.new()
-    
-    # Create demonstration #1
-    # (just return the first parameter)
-    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'
-    @demo_1_test_cases = [
-      demo_1_test_case_1,demo_1_test_case_2
-    ]
-    
-    # Create demonstration #2
-    demo_2_test_case_1 = CTestCase.new 
-    demo_2_test_case_1[:params] = ['something']
-    demo_2_test_case_1[:output] = 'exists'
-    demo_2_test_case_2 = CTestCase.new
-    demo_2_test_case_2[:params] = ['my willpower']
-    demo_2_test_case_2[:output] = 'does not exist'
-    demo_2_test_cases = [
-      demo_2_test_case_1,demo_2_test_case_2
-    ] 
-    
-    # Create demo #1 chain
-    #   Create the head for the chain
-    head = Theory.new([],nil,[])    
-    
-    link_one_action = TheoryAction.new(
-      TheoryStatement.new(StringToTheory.run('Statement.new(Return.new,var2.params[var3])')),
-      StringToTheory.run('var1.statement_id')
-    )
-    # NOTE: I need to add one result so the theory can be flagged as complete - I might not need it 
-    #       to be complete -
-    link_one_result = TheoryResult.new(StringToTheory.run("if(var1.all_pass?(var2))\nreturn true\nend"))
-    link_one = Theory.new([],link_one_action,[link_one_result])
-    chain = Chain.new
-    chain = chain.add_link(head).first
-    chain = chain.add_link(
-      link_one,
-      {
-        1=>IntrinsicRuntimeMethod.new,
-        2=>IntrinsicTestCases.new,
-        3=>IntrinsicLiteral.new(0)
-      }
-    ).first
-    
-    # Now implement the chain
-    implemented_chain = chain.implement
-    
-    # TODO  It should generate the values too.(TheoryGenerator)
-    @demo_1 = {
-      :initial_method=>RuntimeMethod.new(MethodUsage.new(MethodParameter.new)),
-      :test_cases=>@demo_1_test_cases,
-      :chain=>chain,
-      :values=>{}
-    }
-#    action = TheoryAction.new(
-#      TheoryStatement.new(StringToTheory.run('Statement.new(Return.new,var2[var4][:output])')),
-#      StringToTheory.run('var5.statement_id')
-#    )          
-    
-  end
-  
-  def teardown
-    System.reset
-    RuntimeMethod.reset_global_id
-  end  
-
-  def test_with_simple_test_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
-    ]    
-     
-    #assert_nothing_raised() {@cauldron.brew(test_cases)}           
-  end
-
-  # Checks that a theory is created for a very simple 
-  # example that just requires adding a single statement
-  # to a runtime method.
-  #
-  def test_simmer_with_very_basic_theory
-    
-    @cauldron.clear
-    # TEMP Notes
-    # 1.  Confirm that the chain solves the problem
-    # 2.  Generate a master theory for each of the steps
-    # 3.  Add each of simple theories to the bank.
-    # 4.  Need to clear the cauldron after each generation(for testing) 
-    assert_nothing_raised(){@cauldron.simmer(@demo_1)}
-    
-  end
-  
-  def test_brew_with_case_1
-    
-    # => TODO Should clear, then simmer first
-    assert_nothing_raised(){@cauldron.brew(@demo_1_test_cases)}
-    
-    assert_equal(true,@cauldron.brew(@demo_1_test_cases).kind_of?(RuntimeMethod))
-  end
-  
-  def test_demo_works_with_demo_1
-    assert_equal(true,@cauldron.demo_works?(@demo_1))
-  end
-  
-  def test_clear
-    assert_nothing_raised(){@cauldron.clear}
-  end
-
-end

data/test/unit/tc_runtime_tracking_method.rb

@@ -1,40 +0,0 @@
-require 'required'
-require 'test/unit'
-
-class TestRuntimeTrackingMethod < Test::Unit::TestCase
-  
-  def setup
-    
-    @tracking_variable = ArrayVariable.new([])
-    @tracking_variable.instance_variable = true    
-    @runtime_tracking_method = RuntimeTrackingMethod.new(@tracking_variable)
-    
-  end
-  
-  def teardown
-    System.reset 
-    RuntimeMethod.reset_global_id
-  end  
-
-  def test_write
-    
-    # Check that evaluated method doesn't generate an error
-    #MethodUsage.new(@line,@action,@variables,@local_variables,@statement_id)
-    assert_nothing_raised(){
-      MethodEvaluation.new.evaluate_method(
-        @runtime_tracking_method,ParametersContainer.new(
-          0.to_literal,
-          12.to_literal,
-          [].to_literal,
-          'var=test'.to_literal
-       ))
-     }    
-
-  end
-
-  def test_copy
-    assert_nothing_raised(){@runtime_tracking_method.copy}
-    assert_equal(@runtime_tracking_method.write,@runtime_tracking_method.copy.write)
-  end
-  
-end