cauldron 0.1.0

data/test/unit/tc_chain_mapping.rb

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

@@ -0,0 +1,169 @@
+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(IfContainer.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

@@ -0,0 +1,40 @@
+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_instance_call_structure.rb

@@ -0,0 +1,35 @@
+require 'required'
+require 'test/unit'
+
+class TestInstanceCallStructure < Test::Unit::TestCase
+  
+  def setup
+    
+    # Simple string example
+    @lechuck_variable = StringVariable.new('LeChuck')
+    
+    # Create an a simple chop method
+    @chop_le_chuck = InstanceCallStructure.new(StringVariable,Chop.new)
+    
+  end
+  
+  def teardown
+System.reset
+    RuntimeMethod.reset_global_id
+  end  
+
+  def test_instance_calls
+    
+    # Assert that one instance call is created correctly
+    assert_equal(1,@chop_le_chuck.instance_calls([@lechuck_variable]).length)
+    assert(@chop_le_chuck.instance_calls([@lechuck_variable]).first.kind_of?(InstanceCallContainer))
+    
+    # Confirm instance call hasn't any parameters
+    assert_equal(0,@chop_le_chuck.instance_calls([@lechuck_variable]).first.length)    
+    
+    # Assert the no results can be retrieved
+    assert_equal(0,@chop_le_chuck.instance_calls([]).length)        
+            
+  end
+
+end

data/test/unit/tc_method_usage.rb

@@ -0,0 +1,35 @@
+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('flipping'.to_requirement)
+    @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

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