cauldron 0.1.0

data/test/unit/core/variable/tc_variable_reference.rb

@@ -0,0 +1,28 @@
+require 'required'
+require 'test/unit'
+
+class TestVariableReference < Test::Unit::TestCase
+  
+#  var_12 = Statement.new(Unknown.new,Equal.new,8.to_declaration) 
+#  var_13 = 8 
+#  var_559 = RuntimeMethod.new(var_11) 
+#  var_570 = var_12.declared_variable 
+
+  def setup
+    
+  end
+  
+  def teardown
+System.reset
+    RuntimeMethod.reset_global_id
+  end 
+  
+  # Scenario
+  
+  def test_variable_reference_is_maintained
+    
+
+    
+  end
+  
+end

data/test/unit/ruby_code/tc_array.rb

@@ -0,0 +1,64 @@
+require 'required'
+require 'test/unit'
+
+class TestArray < Test::Unit::TestCase
+  
+  def setup
+    @teams = ['Manchester United','Arsenal']
+    @animals = ['spider','bear','rat']        
+  end
+  
+  def teardown
+    System.reset
+  end  
+  
+  def test_to_literal
+    assert(@teams.to_literal.kind_of?(Literal))
+    assert_equal(@teams.length,@teams.to_literal.value.length)    
+    assert_equal(@teams.first,@teams.to_literal.value.first.value)
+    assert(@teams.to_literal.value.last.kind_of?(Literal))    
+  end
+  
+  def test_to_declaration
+    assert_equal(true,@animals.to_declaration.kind_of?(LiteralDeclaration))
+    #assert_equal('["spider", "bear", "rat"]',@animals.to_declaration.write)
+  end
+  
+  def test_contains?
+    
+    # Check that contains? searches go through each of the elements
+    results = [[].to_var,7.to_var]
+    assert(results.contains? {|x| x.kind_of?(ArrayVariable)})
+    assert(results.contains? {|x| x.kind_of?(FixnumVariable)})
+    assert_equal(false,results.contains? {|x| x.kind_of?(StringVariable)})    
+    
+  end
+  
+  def test_in_tandem
+    
+    letters = ('A'..'C').to_a
+    numbers = (1..3).to_a
+    container = []
+    letters.zip(numbers) do |x,y|
+      container.push(x+y.to_s)
+    end
+    assert_equal('A1',container.first)
+    assert_equal('B2',container[1])
+    assert_equal('C3',container.last)
+    
+  end
+  
+  def test_to_var
+    assert_equal(5,['A','B','C'].to_var(5,10).variable_id)  
+    assert_equal(10,['A','B','C'].to_var(5,10).uniq_id)      
+  end
+  
+  def test_select_all_with_simple_structure
+     assert_equal(5,['A',['B','C'],'D'].select_all {|x| true }.length)
+  end
+ 
+  def test_select_all_with_class_match
+    assert_equal(4,['A',['B','C'],'D'].select_all {|x| x.kind_of?(String) }.length)
+  end
+  
+end

data/test/unit/ruby_code/tc_fixnum.rb

@@ -0,0 +1,18 @@
+require 'required'
+require 'test/unit'
+
+class TestFixnum < Test::Unit::TestCase
+  
+  def setup
+  end
+  
+  def teardown
+    System.reset
+  end  
+  
+  def test_to_var
+    assert_equal(8,6.to_var(8,9).variable_id)
+    assert_equal(9,6.to_var(8,9).uniq_id)    
+  end
+      
+end

data/test/unit/ruby_code/tc_hash.rb

@@ -0,0 +1,41 @@
+require 'required'
+require 'test/unit'
+
+class TestHash < Test::Unit::TestCase
+  
+  def setup
+    @hash_a = {:mass_effect,'awesome' }
+  end
+  
+  def teardown
+System.reset
+    RuntimeMethod.reset_global_id
+  end  
+  
+  def test_copy
+    assert_nothing_raised(){@hash_a.copy}
+    assert(@hash_a.copy.kind_of?(Hash))
+    assert_equal(@hash_a.write,@hash_a.copy.write)
+    assert_not_equal(@hash_a.copy.shift.object_id,@hash_a.copy.shift.object_id)
+  end
+  
+  def test_copy_with_mapping_hash    
+    mapping = {
+      5 => Parser.run('test_cases'),
+      6 => Parser.run('0'),
+      1 => Parser.run('last_runtime_method'),
+      2 => Parser.run('runtime_method'),
+      3 => Parser.run('1'),
+      4 => Parser.run('0')
+    }
+    assert_equal(
+      6,
+      mapping.copy.length
+    )
+    copied = mapping.copy
+    copied[6] = 'Warren'
+    assert_not_equal(copied[6].object_id,mapping[6].object_id)
+    assert_equal(copied.length,mapping.length)
+  end
+      
+end

data/test/unit/ruby_code/tc_string.rb

@@ -0,0 +1,38 @@
+require 'required'
+require 'test/unit'
+
+class TestString < Test::Unit::TestCase
+  
+  def setup
+    
+  end
+  
+  def teardown
+    System.reset
+  end  
+  
+  def test_write
+    assert_equal('\'three headed monkey\'','three headed monkey'.write)
+    assert_equal("'three headed monkey'",'three headed monkey'.write)    
+    assert_equal("'\\'vodoo\\' lady'","'vodoo' lady".write)    
+  end
+
+  def test_to_literal
+    x = 'test'
+    assert(x.to_literal.kind_of?(Literal))
+    assert_equal(x,x.to_literal.value)
+  end
+
+  def test_to_declared_variable_statement
+    x = 'test'
+    declared_variable_statement = x.to_declared_variable_statement
+    assert_equal("var_0 = 'test'",declared_variable_statement.write)
+    assert_equal(0,declared_variable_statement.declared_variable_id)
+  end
+  
+  def test_to_var
+    assert_equal(4,'test'.to_var(4,7).variable_id)
+    assert_equal(7,'test'.to_var(4,7).uniq_id)
+  end  
+      
+end

data/test/unit/tc_chain.rb

@@ -0,0 +1,434 @@
+require 'required'
+require 'test/unit'
+
+class TestChain < Test::Unit::TestCase
+  include ContainsTheories  
+  
+  def setup
+    
+  end
+  
+  def teardown
+    System.reset
+    RuntimeMethod.reset_global_id
+  end  
+  
+  # Create the most simple of chains that only has a head and a tail and completes
+  def test_initialize_1
+    
+    # Create the single requirement
+    result_one = TheoryResult.new(StringToTheory.run("if(var1.all_pass?(var2))\nreturn true\nend"))
+    head = Theory.new([],nil,[result_one])    
+    
+    # Check initial declaration 
+    assert_nothing_raised(){Chain.new()}
+    
+    # Add the head to the chain - completing it
+    chain = Chain.new()
+    assert_nothing_raised(){chain.add_link(head)}
+    chain_results = chain.add_link(head)
+    assert_equal(true,chain_results.any? {|x|x.complete?})
+    
+    # Implement the chain
+    assert_equal(1,chain_results.length)
+    complete_chain = chain_results.first
+    assert_nothing_raised() {complete_chain.implement}
+    
+  end
+  
+  # Test a very simple chain that shares all the save variable ids(negating the mapping) but is made up
+  # of a head, link and tail.
+  def test_initialize_2
+    
+    # Create the head for the chain
+    head_result = TheoryResult.new(StringToTheory.run("if(var2[var3][:output]==var2[var3][:params][var4])\nreturn true\nend"))
+    head = Theory.new([],nil,[head_result]) 
+      
+    # Create linking method
+    link_one_dependent_one = TheoryDependent.new(StringToTheory.run("if(var2[var3][:output]==var2[var3][:params][var4])\nreturn true\nend"))
+    link_one_action = TheoryAction.new(
+      TheoryStatement.new(StringToTheory.run('Statement.new(Return.new,var2[var3][:output])')),
+      StringToTheory.run('var1.statement_id')
+    )
+    link_one_result = TheoryResult.new(StringToTheory.run("if(var1.all_pass?(var2))\nreturn true\nend"))
+    link_one = Theory.new([link_one_dependent_one],link_one_action,[link_one_result])
+    
+    # Create the initial chain and confirm it isn't complete (the head can't connect to tail)
+    chain = Chain.new
+    assert_equal(false,chain.complete?)
+    
+    assert_nothing_raised(){chain.add_link(head)}
+    chain_results = chain.add_link(head)
+    
+    # Add the next chain in the link
+    extended_results = []
+    chain_results.each do |c|
+      extended_results += c.add_link(link_one)
+    end
+    chain_results = extended_results    
+    
+    assert_equal(true,chain_results.all? {|x| x.kind_of?(Chain)})
+    assert_equal(true,chain_results.all? {|x| x.complete? })
+    assert_equal(true,chain_results.all? {|x| x.broken_link_count == 0})
+    
+  end
+  
+  # Test that this very simple chain can be unified
+  # 
+  def test_unifiy_chain_1
+    head = Theory.new([],nil,[])    
+    
+    link_one_action = TheoryAction.new(
+      TheoryStatement.new(StringToTheory.run('Statement.new(Return.new,var2[var3][:output])')),
+      StringToTheory.run('var1.statement_id')
+    )
+    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).first
+    
+    global_ids = chain.chain_mapping.mapping.collect {|key,value| key}
+    
+    assert_equal(
+      true,
+      global_ids.all? do |x|
+        chain.unify_chain.write.include?('var'+x.to_s)
+      end
+    )
+    
+  end
+  
+  # Test that an extremely basic chain can be implemented.  The chain 
+  # basically involves adding one return statement to a runtime method.
+  #
+  def test_implement_1
+    
+    head = Theory.new([],nil,[])    
+    
+    link_one_action = TheoryAction.new(
+      TheoryStatement.new(StringToTheory.run('Statement.new(Return.new,var2[var3][:output])')),
+      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
+    
+    # Attempt to implement the chain
+    assert_nothing_raised() {chain.implement}
+    implemented_chain = chain.implement
+    assert_equal(false,implemented_chain.write.include?('var'))
+    
+  end
+  
+  # Checks that a implemented theory can be created with the very basic
+  # chain.
+  #
+  def test_theory_progression_with_case_1
+    
+    # ----------------- SETUP -----------------
+    # 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
+    ]    
+    
+    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
+    runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))
+    
+    # ---------------- Attempt to create the three theory snapshots -------------
+    assert_nothing_raised() {chain.theory_progression(runtime_method,demo_1_test_cases)}
+    assert_equal(3,chain.theory_progression(runtime_method,demo_1_test_cases).length)
+    assert_equal(true,chain.theory_progression(runtime_method,demo_1_test_cases).all?{|x| x.kind_of?(TheoryImplementation)})
+    
+  end
+  
+  # Test implementation with the simple example that just returns the passed
+  # value.
+  def test_implement_2
+    
+    # Create the head for the chain
+    head_result = TheoryResult.new(StringToTheory.run("if(var2[var3][:output]==var2[var3][:params][var4])\nreturn true\nend"))
+    head = Theory.new([],nil,[head_result]) 
+      
+    # Create linking method
+    link_one_dependent_one = TheoryDependent.new(StringToTheory.run("if(var2[var3][:output]==var2[var3][:params][var4])\nreturn true\nend"))
+    link_one_action = TheoryAction.new(
+      TheoryStatement.new(StringToTheory.run('Statement.new(Return.new,var2[var3][:output])')),
+      StringToTheory.run('var1.statement_id')
+    )
+    link_one_result = TheoryResult.new(StringToTheory.run("if(var1.all_pass?(var2))\nreturn true\nend"))
+    link_one = Theory.new([link_one_dependent_one],link_one_action,[link_one_result])
+    
+    # Create the values for the head
+    head_values = {2=>IntrinsicTestCases.new,3=>IntrinsicLiteral.new(0),4=>IntrinsicLiteral.new(0)}
+    link_one_values = { 1=>IntrinsicRuntimeMethod.new,
+                        2=>IntrinsicTestCases.new,
+                        3=>IntrinsicLiteral.new(0),
+                        4=>IntrinsicLiteral.new(0)
+                      }
+    
+    # Create the initial chain and confirm it isn't complete (the head can't connect to tail)
+    chain = Chain.new
+    assert_equal(false,chain.complete?)
+    
+    assert_nothing_raised(){chain.add_link(head)}
+    chain_results = chain.add_link(head,head_values)
+    
+    # Add the next chain in the link
+    extended_results = []
+    chain_results.each do |c|
+      extended_results += c.add_link(link_one,link_one_values)
+    end
+    chain_results = extended_results    
+    assert_equal(1,chain_results.length)
+    
+    # Now attempt to implement it
+    complete_chain = chain_results.first
+    assert_equal(true,complete_chain.complete?)
+    assert_nothing_raised(){complete_chain.implement}
+    
+  end
+  
+  # Add the theories needded to create a simple 'if' runtime method
+  #
+  # def method_1(var1)
+  #   if var1 == 'something'
+  #     return 'exist'
+  #   end
+  #   return 'does not exists'
+  # end
+  #
+  def test_add_link_to_3
+    
+    theory_1 = Theory.load_theory(20) 
+    theory_2 = Theory.load_theory(14)
+    theory_3 = Theory.load_theory(15)
+    theory_4 = Theory.load_theory(12)
+    
+    # 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]) 
+    
+    # Create the initial chain
+    chain = Chain.new
+    
+    # Add the head link to the chain
+    chain_results = chain.add_link(head)
+
+    # Add the next link to the chain
+    extended_results = []
+    chain_results.each do |c|
+      extended_results += c.add_link(theory_1)
+    end
+    chain_results = extended_results
+
+    assert_equal(1,chain_results.length)
+    assert_equal(false,chain_results.all? {|x| x.complete? })
+    
+    # Add the next link to the chain
+    extended_results = []
+    chain_results.each do |c|
+      extended_results += c.add_link(theory_2)
+    end
+    chain_results = extended_results
+
+    # Add the next link to the chain
+    extended_results = []
+    chain_results.each do |c|
+      extended_results += c.add_link(theory_3)
+    end
+    chain_results = extended_results    
+
+    # Add the next link to the chain
+    extended_results = []
+    chain_results.each do |c|
+      extended_results += c.add_link(theory_4)
+    end
+    chain_results = extended_results        
+    
+    # Check the results - at least one the chains should be complete now
+    assert_equal(true,chain_results.all? {|x| x.kind_of?(Chain)})      
+    #assert_equal(true,chain_results.any? {|x| x.complete?})
+    #assert_equal(1,chain_results.select {|x| x.complete?}.length)
+    
+    # Implement the completed chain
+    #complete_chain = chain_results.select {|x| x.complete?}.first
+    #assert_equal(6,complete_chain.unify_chain.theory_variables.length)
+    
+  end
+  
+  def test_variables_creation_with_case_1
+    
+    # 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
+    ]    
+    
+    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
+    runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))    
+    
+    assert_equal(3,chain.variables_creation.length)
+    
+  end
+  
+#  # Add the theories needded to create a simple 'if' runtime method
+#  #
+#  # def method_1(var1)
+#  #   if var1 == 'something'
+#  #     return 'exist'
+#  #   end
+#  #   return 'does not exists'
+#  # end
+#  #
+#  # but also include the values of each of the values.
+#  #
+#  def test_add_link_to_3_with_values
+#    
+#    theory_1 = Theory.load_theory(20) 
+#    theory_2 = Theory.load_theory(14)
+#    theory_3 = Theory.load_theory(15)
+#    theory_4 = Theory.load_theory(12)
+#    
+#    # 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])     
+#    
+#  end
+  
+#  def test_solvable_passing_no_theories
+#    
+#    # Create the initial starting chain from pre-existing chain
+#    directory_path = $LOC+File.join('test','fixtures','chains','3')
+#    raise StandardError.new("chain 3 does not exist") unless(File.exists?(directory_path))
+#    dump_file = File.open(File.join(directory_path,'dump'),'r')    
+#    initial_chain = Marshal.load(dump_file)       
+#    
+#    finish = Parser.run("if(runtime_method.all_pass?(test_cases))\nreturn true\nend")
+#    
+#    assert_equal(false,initial_chain.solvable?(finish,[]))
+#    
+#  end
+  
+#  def test_solvable_with_one_theory_that_solves_it
+#    
+#    # Create the initial starting chain from pre-existing chain
+#    directory_path = $LOC+File.join('test','fixtures','chains','1')
+#    raise StandardError.new("chain 1 does not exist") unless(File.exists?(directory_path))
+#    dump_file = File.open(File.join(directory_path,'dump'),'r')    
+#    initial_chain = Marshal.load(dump_file)
+#    
+#    theory_19 = Theory.load_theory(19)
+#    
+#    finish = Parser.run("if(runtime_method.all_pass?(test_cases))\nreturn true\nend")
+#    assert_equal(true,initial_chain.solvable?(finish,[theory_19]))
+#    
+#  end
+  
+#  def test_solvable_with_case_1
+#    # TODO  This works but takes longer than I would expect.
+#    
+#    # Create the initial starting chain from pre-existing chain
+#    directory_path = $LOC+File.join('test','fixtures','chains','3')
+#    raise StandardError.new("chain 3 does not exist") unless(File.exists?(directory_path))
+#    dump_file = File.open(File.join(directory_path,'dump'),'r')    
+#    initial_chain = Marshal.load(dump_file)  
+#    
+#    theory_1 = Theory.load_theory(20) 
+#    theory_2 = Theory.load_theory(14)
+#    theory_3 = Theory.load_theory(15)
+#    theory_4 = Theory.load_theory(12)
+#
+#    finish = Parser.run("if(runtime_method.all_pass?(test_cases))\nreturn true\nend")
+#    assert_equal(true,initial_chain.solvable?(finish,[theory_1,theory_2,theory_3,theory_4]))
+#    
+#  end
+#  
+#  def test_solvable_with_case_1_and_missing_theory
+#
+#    # Create the initial starting chain from pre-existing chain
+#    directory_path = $LOC+File.join('test','fixtures','chains','3')
+#    raise StandardError.new("chain 3 does not exist") unless(File.exists?(directory_path))
+#    dump_file = File.open(File.join(directory_path,'dump'),'r')    
+#    initial_chain = Marshal.load(dump_file)  
+#    
+#    theory_1 = Theory.load_theory(20)  
+#    theory_2 = Theory.load_theory(14)
+#    theory_3 = Theory.load_theory(15)
+#    theory_4 = Theory.load_theory(12)
+#    
+#    finish = Parser.run("if(runtime_method.all_pass?(test_cases))\nreturn true\nend")
+#    assert_equal(false,initial_chain.solvable?(finish,[theory_1,theory_2,theory_3]))
+#    assert_equal(false,initial_chain.solvable?(finish,[theory_1,theory_2,theory_4]))
+#    assert_equal(false,initial_chain.solvable?(finish,[theory_1,theory_3,theory_4]))
+#    assert_equal(false,initial_chain.solvable?(finish,[theory_2,theory_3,theory_4]))
+#    
+#  end
+
+end