cauldron 0.1.0

data/test/fixtures/theories/6/desc

@@ -0,0 +1,11 @@
+if: 
+	if(var1.realise2(var2[var3][:params]).params[var3].value.length == var2[var3][:output])
+		return true
+	end
+
+action: 
+	<runtime_method>.add_statement_at(Statement.new(Return.new, var1.params[0]),var1.statement_id)
+result: 
+	if(var1.all_pass?(var2))
+		return true
+	end

data/test/fixtures/theories/7/declaration.txt

@@ -0,0 +1,19 @@
+
+    dependent_one = TheoryDependent.new(
+    	StringToTheory.run(
+    		"if(var1.realise2(var2[var3][:params]).params[var4].value.length == var2[var3][:output])\nreturn true\nend"
+			)
+		)
+    action_one = TheoryAction.new(
+    	TheoryStatement.new(
+    		StringToTheory.run(
+    			'Statement.new(Return.new,InstanceCallContainer.new(var1.params[var4],StringLength.new))'
+				)
+			),
+			StringToTheory.run('var1.statement_id')
+		)
+    result_one = TheoryResult.new(
+    	StringToTheory.run("if(var1.pass?(var2[var3]))\nreturn true\nend")
+		)    
+    Theory.new([dependent_one],action_one,[result_one])
+    

data/test/fixtures/theories/7/desc

@@ -0,0 +1,11 @@
+if: 
+	if(var1.realise2(var2[var3][:params]).params[var4].value.length == var2[var3][:output])
+		return true
+	end
+
+action: 
+	<runtime_method>.add_statement_at(Statement.new(Return.new, InstanceCallContainer.new(var1.params[var4], StringLength.new)),var1.statement_id)
+result: 
+	if(var1.pass?(var2[var3]))
+		return true
+	end

data/test/fixtures/theories/8/declaration.txt

@@ -0,0 +1,21 @@
+
+    dependent_one = TheoryDependent.new(
+    	StringToTheory.run(
+    		"if((var1[var2][:params][var2] + var1[var2][:params][var3]) == var1[var2][:output])\nreturn true\nend"
+			)
+		)
+    action_one = TheoryAction.new(
+      TheoryStatement.new(
+      	StringToTheory.run(
+      		'Statement.new(Unknown.new,Equal.new,var4.params[var2],Addition.new,var4.params[var3])'
+				)
+			),
+			StringToTheory.run('var4.statement_id')
+    )
+    result_one = TheoryResult.new(
+    	StringToTheory.run(
+    		"if(var4.all_pass?(var1))\nreturn true\nend"
+			),true
+		)    
+    Theory.new([dependent_one],action_one,[result_one])
+    

data/test/fixtures/theories/8/desc

@@ -0,0 +1,11 @@
+if: 
+	if(var1[var2][:params][var2] + var1[var2][:params][var3] == var1[var2][:output])
+		return true
+	end
+
+action: 
+	<runtime_method>.add_statement_at(Statement.new(Unknown.new, Equal.new, var4.params[var2], Addition.new, var4.params[var3]),var4.statement_id)
+result: 
+	if(var4.all_pass?(var1))
+		return true
+	end

data/test/fixtures/theories/9/declaration.txt

@@ -0,0 +1,24 @@
+
+    dependent_one = TheoryDependent.new(StringToTheory.run("if(var2[var3].kind_of?(CTestCase))\nreturn true\nend"))
+    dependent_two = TheoryDependent.new(StringToTheory.run("if(var6.kind_of?(Fixnum))\nreturn true\nend"))
+    dependent_three = TheoryDependent.new(
+      StringToTheory.run("if((var2[var3][:params][var6] == var2[var4][:params][var6])==false)\nreturn true\nend")
+    )
+    action = TheoryAction.new(
+      TheoryStatement.new(StringToTheory.run(
+        'IfStatement.new(var2[var3][:params][var6],Equivalent.new,var2[var3][:output])'
+    	)),
+    	StringToTheory.run('var1.statement_id')
+		)
+    result_one = TheoryResult.new(StringToTheory.run(
+      "if(var1.history(var2[var3][:params]).any? { |x| x.statement_id == var1.last.statement_id })\nreturn true\nend"
+    ))
+    result_two = TheoryResult.new(StringToTheory.run(
+      "if((var1.history(var2[var4][:params]).any? { |x| x.statement_id == var1.last.statement_id })==false)\nreturn true\nend"
+    ))    
+    Theory.new(
+      [dependent_one,dependent_two,dependent_three],
+      action,
+      [result_one,result_two]
+    )
+    

data/test/fixtures/theories/9/desc

@@ -0,0 +1,20 @@
+if: 
+	if(var2[var3].kind_of?(CTestCase))
+		return true
+	end
+	if(var6.kind_of?(Fixnum))
+		return true
+	end
+	if((var2[var3][:params][var6] == var2[var4][:params][var6]) == false)
+		return true
+	end
+
+action: 
+	<runtime_method>.add_statement_at(IfStatement.new(var2[var3][:params][var6], Equivalent.new, var2[var3][:output]),var1.statement_id)
+result: 
+	if(var1.history(var2[var3][:params]).any?{ |x| x.statement_id == var1.last.statement_id} )
+		return true
+	end
+	if((var1.history(var2[var4][:params]).any?{ |x| x.statement_id == var1.last.statement_id} ) == false)
+		return true
+	end

data/test/fixtures/theory_implementations/0/declaration.txt

@@ -0,0 +1,11 @@
+
+        theory = Theory.load_theory(1)
+        potential_values = [
+            Parser.run('0'),
+            Parser.run('test_cases'),
+            Parser.run('runtime_method')
+        ]
+        results = theory.rewrite_permutations(potential_values)
+        # NOTE: Rember use grep -A and -B to match particular cases
+        results[5]       
+      

data/test/fixtures/theory_implementations/0/desc.txt

@@ -0,0 +1,9 @@
+if: 
+	if(runtime_method.realise2(test_cases[0][:params]).params[0].value.length == test_cases[0][:output].length)
+	end
+action: 
+	<runtime_method>.add_statement_at(Statement.new(Return.new, runtime_method.params[0]),0)
+result: 
+	if(runtime_method.all_pass?(test_cases))
+end
+	returns true

data/test/fixtures/theory_implementations/0/theory_id

@@ -0,0 +1 @@
+1

data/test/fixtures/theory_implementations/1/desc.txt

@@ -0,0 +1,9 @@
+if: 
+	if(test_cases[0][:params][0] + test_cases[0][:params][1] == test_cases[0][:output])
+	end
+action: 
+	<runtime_method>.add_statement_at(Statement.new(Unknown.new, Equal.new, runtime_method.params[0], Addition.new, runtime_method.params[1]),0)
+result: 
+	if(runtime_method.all_pass?(test_cases))
+end
+	returns true

data/test/fixtures/theory_implementations/1/theory_id

@@ -0,0 +1 @@
+8

data/test/fixtures/theory_implementations/2/desc.txt

@@ -0,0 +1,9 @@
+if: 
+	if(runtime_method.realise2(test_cases[0][:params]).params[0].value.length == test_cases[0][:output])
+	end
+action: 
+	<runtime_method>.add_statement_at(Statement.new(Return.new, test_cases[0][:output]),0)
+result: 
+	if(runtime_method.pass?(test_cases[0]))
+end
+	returns true

data/test/fixtures/theory_implementations/2/theory_id

@@ -0,0 +1 @@
+4

data/test/output/simple_method.txt

@@ -0,0 +1,6 @@
+
+#
+#
+def method_0
+
+end

data/test/output/test_method/first_possible_method.txt

@@ -0,0 +1,6 @@
+
+#
+#
+def method_0
+	var_0 = 8 
+end

data/test/output/test_simple_cases/simple_case_01.txt

@@ -0,0 +1,8 @@
+
+#
+#	@param	var_0		= 8
+#
+def method_0(var_0)
+	var_4 = var_0 
+	return var_4 
+end

data/test/output/test_simple_cases/simple_case_02.txt

@@ -0,0 +1,7 @@
+#
+#	@param	var_0		= 'test'
+#
+def method_0(var_0)
+	var_4 = var_0 
+	return var_4 
+end

data/test/output/test_simple_cases/simple_case_03.txt

@@ -0,0 +1,8 @@
+#
+#	@param	var_0		= 'tests'
+#
+def method_0(var_0)
+	var_5 = var_0.chop 
+	var_4 = var_5 
+	return var_4 
+end

data/test/output/test_simple_cases/simple_case_04.txt

@@ -0,0 +1,8 @@
+#
+#	@param	var_0		= 'tests'
+#
+def method_0(var_0)
+	var_7 = var_0.length 
+	var_4 = var_7 
+	return var_4 
+end

data/test/output/test_simple_cases/simple_case_05.txt

@@ -0,0 +1,8 @@
+#
+#	@param	var_0		= 'tested'
+#
+def method_0(var_0)
+	var_5 = var_0.chop 
+	var_4 = var_5 
+	return var_4 
+end

data/test/output/test_simple_cases/simple_case_06.txt

@@ -0,0 +1,9 @@
+#
+#	@param	var_0		= 'tested'
+#
+def method_0(var_0)
+	var_31 = var_0.chop 
+	var_35 = var_31.chop 
+	var_34 = var_35 
+	return var_34 
+end

data/test/output/test_simple_cases/simple_case_07.txt

@@ -0,0 +1,9 @@
+#
+#	@param	var_0		= 'tested'
+#	@param	var_1		= 'warren'
+#
+def method_0(var_0, var_1)
+	var_7 = var_0.chop 
+	var_6 = var_7 
+	return var_6 
+end

data/test/output/test_simple_cases/simple_case_08.txt

@@ -0,0 +1,9 @@
+#
+#	@param	var_0		= 6
+#	@param	var_1		= 4
+#
+def method_0(var_0, var_1)
+	var_11 = var_0  -  var_1 
+	var_6 = var_11 
+	return var_6 
+end

data/test/tc_contextual_variables.rb

@@ -0,0 +1,87 @@
+# This meant to test that the variables requirements change to reflect
+# the context they are accessed.
+#
+
+require 'required'
+require 'test/unit'
+
+class TestContextualVariable < Test::Unit::TestCase
+  
+  def setup
+    
+  end
+  
+  def teardown
+    System.reset
+    RuntimeMethod.reset_global_id
+  end  
+  
+  # This test checks that variables taken on the appropriate requirements
+  # based on their position within a statement and then method.
+  #
+  # def method_1(param_1)
+  #   var1 = param1.chop
+  #   var2 = var1.length
+  # end
+  # 
+  # where param_1 = 'test'
+  #
+  def test_method_describtion
+    
+    # Create the var1 - this should haven't any requirements individually
+    var1 = Unknown.new()       
+    assert_equal(0,var1.length)
+    
+    # Create the first statement with var1 in it e.g. var2 = var1.chop
+    chop_call = InstanceCallContainer.new(Unknown.new,Chop.new)
+    first_statement = DeclarationStatement.new(var1,Equal.new,chop_call)
+    
+    # Check that the variables inside the first statement don't have any requirements
+    assert_equal(0,first_statement[0].length)
+    assert_equal(0,first_statement[2].subject.length)
+    
+    # Check that the instance call includes a requirement
+    assert_equal(1,chop_call.find_variable(chop_call.variable_id).length)
+    
+    # Check that they have the correct requirements in the context of the statement
+    # TODO  I think the whole Unknown class is redundent
+    assert_equal(2,first_statement.find_variable(chop_call.subject.variable_id).length)
+    
+    # Confirm the length of the variable hasn't changed
+    assert_equal(0,var1.length)
+    
+    # Create the second scope variable
+    var2 = Unknown.new()
+    assert_equal(0,var2.length)
+    assert_not_equal(var1.variable_id,var2.variable_id)
+    
+  end
+  
+  # This test checks the the declared variable in the following statement
+  #
+  # varA = varB-varC
+  #
+  # has the contextual requirement
+  #
+  # self = varB-varC
+  #
+  def test_declared_variables_in_statement_with_multiple_variables
+    
+    # Create the statement 
+    declared_variable = Unknown.new
+    varB = Unknown.new
+    varC = Unknown.new
+    statement = Statement.new(declared_variable,Equal.new,varB,Subtract.new,varC)
+    
+    # Check the number of elmements in the statement
+    assert_equal(5,statement.length)
+    
+    # Retrieve the contextual declared variable
+    contextual_variable = statement.contextual_variable(declared_variable.variable_id)
+    
+    # Confirm a variable was returned
+    assert(contextual_variable.kind_of?(Variable))
+    
+  end
+  
+end

data/test/tc_describe.rb

@@ -0,0 +1,47 @@
+require 'required'
+require 'test/unit'
+
+class TestDescribe < Test::Unit::TestCase
+  
+  def setup
+    
+  end
+  
+  def teardown
+System.reset
+    RuntimeMethod.reset_global_id
+  end  
+
+  # There was a bug occuring requirements were added to a variable via
+  # the describe call.  This shouldn't be the case.
+  #
+  def test_nothing_is_added
+    
+    # Create the method variable for the method (self = 'test')
+    requirement = Requirement.new(This.new,Equal.new,Literal.new('test'))
+    method_variable = MethodParameter.new(requirement)
+    
+#    # Create runtime method with one parameter ('test')
+#    runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))
+#    #runtime_method.parameters = [method_variable]
+#    
+#    # Start by considering the statement varA = varB.chop
+#    varB = Unknown.new
+#    varC = Unknown.new    
+#    consider_statement = DeclarationStatement.new(varC,Equal.new,InstanceCallContainer.new(varB,Chop.new))
+#    #populated_method = runtime_method.consider(consider_statement).shift
+#    
+#    # There should be two variables, one the method variable - what was varB, and the newly declared variable
+#    assert(populated_method.available_variables[0].kind_of?(MethodParameter))    
+#    assert(populated_method.available_variables[1].kind_of?(Variable))
+#    
+#    # The declared variable shouldn't have any actual requirements - I think
+#    assert(populated_method.available_variables[1].empty?)
+#    
+#    # Describe the variable and confirm that the variable still doesn't have any requirements
+#    populated_method.available_variables[1].describe(populated_method)   
+#    assert(populated_method.available_variables[1].empty?)
+    
+  end
+  
+end

data/test/tc_method.rb

@@ -0,0 +1,133 @@
+require 'required'
+require 'test/unit'
+
+class TestMethod < Test::Unit::TestCase
+  
+  def setup
+
+    # Creates the statement to be inlcuded in the method
+    @declaration_statement = DeclarationStatement.new(Unknown.new,Equal.new,Literal.new(8))      
+    
+    # Create the usage for the simple method (it doesn't take any parameters
+    @simple_method_usage = MethodUsage.new()
+    
+    # Create the simple runtime method
+    @simple_method = RuntimeMethod.new(@simple_method_usage)
+    
+    # Create the usage for a method with two paramters
+    param_1 = MethodParameter.new
+    @parameter_method_usage = MethodUsage.new(param_1)
+    
+    # Create the method with paramaters
+    @method_with_paramaters = RuntimeMethod.new(@parameter_method_usage)
+    
+    # Setting the method paramaters 
+    #@method_with_paramaters.parameters = [MethodParameter.new(Requirement.new(This.new,Equal.new,Literal.new('test')))]
+        
+  end
+  
+  def teardown
+    System.reset
+    RuntimeMethod.reset_global_id    
+  end
+  
+  def test_simple_statement_inclusion  
+        
+    # Test statement is valid
+    assert_equal(true,@declaration_statement.valid_syntax?) 
+    
+    # Test the method is empty
+    assert_equal(0,@simple_method.length)
+    
+    # Test the output of the written method
+    file_dump = ""
+    f = File.open($LOC+File.join(['test','output','simple_method.txt']),'r')
+    f.each_line do |l|
+      file_dump << l
+    end
+    f.close()  
+
+    assert_equal(file_dump,@simple_method.write)
+    
+    # Add the statement to the method
+    # assert_nothing_raised() {@simple_method.consider @declaration_statement}
+    
+    # Retrieve the possible methods that could use the @declaration_statement
+    # possible_methods = @simple_method.consider @declaration_statement
+    
+    # Confirm that there is only one possible method
+    # assert_equal(1,possible_methods.length)
+    
+    # Confirm that a runtime method was returned
+    # assert_equal(true,possible_methods.first.kind_of?(RuntimeMethod),'Error: Expected RuntimeMethod class')
+    
+#    new_file_dump = ""
+#    f = File.open($LOC+File.join(['test','output','test_method','first_possible_method.txt']),'r')
+#    f.each_line do |l|
+#      new_file_dump << l
+#    end
+#    f.close()
+#    assert_equal(new_file_dump,possible_methods.first.write)
+    
+  end
+  
+  def test_method_copy
+  
+    # Create the usage for a method with a parameter
+    param_1 = MethodParameter.new()
+    parameter_method_usage = MethodUsage.new(param_1)    
+    
+    # Create the method 
+    original_method = RuntimeMethod.new(parameter_method_usage)
+    
+    # Add parameters to the method
+    param_values = MethodParameter.new(Requirement.new(This.new,Equal.new,Literal.new('test')))
+    #original_method.parameters = [param_values]
+    
+    # Check the number of paramaters
+    #assert_equal(1,original_method.parameters.length)
+    
+    # Copy the method
+    assert_nothing_raised(){copied_method = original_method.copy}
+    copied_method = original_method.copy
+    
+    # Confirm class of copied method
+    assert_equal(true,copied_method.class==RuntimeMethod)
+    
+    # Check that the correct number of parameters were copied
+    #assert_equal(original_method.parameters.length,copied_method.parameters.length)
+    
+  end
+  
+  def test_statement_inclusion_with_not_declared_variables
+    
+    # Test the method is empty
+    assert_equal(0,@method_with_paramaters.length)          
+    
+    # Create the statement with unknown variables in them
+    chop_statement = DeclarationStatement.new(Unknown.new,Equal.new,InstanceCallContainer.new(Unknown.new,Chop.new))
+    assert_equal(false,chop_statement.valid_syntax?)
+    
+    # Test the number of paramaters
+    #assert_equal(1,@method_with_paramaters.parameters.length)
+    
+    # Check the paramters description
+    #assert_equal("var_4\t\t= 'test'\n",@method_with_paramaters.parameters.first.describe)
+    
+    # Retrieve the two possible methods  
+    #possible_methods = @method_with_paramaters.consider chop_statement
+    
+#    # Confirm that an array of results was returned
+#    assert_equal(true,possible_methods.class == Array)
+#    
+#    # Confirm the total number of results
+#    assert_equal(1,possible_methods.length)
+#    
+#    # Check the data type of all the returned methods
+#    possible_methods.each do |m|
+#      assert_equal(true,m.class == RuntimeMethod)
+#    end
+      
+  end
+  
+end