cauldron 0.1.0

data/test/unit/core/statement/tc_statement_dependencies.rb

@@ -0,0 +1,146 @@
+
+require 'required'
+require 'test/unit'
+
+class TestStatementDependencies < Test::Unit::TestCase
+  
+  def setup
+    
+    # 
+    # var_a = 'Wally'.chop
+    # var_b = var_a.length
+    # var_c = var_a.chop
+    
+    # Create some statements with dependencies
+    @wally = Literal.new('Wally')
+    @chopped_wally = Unknown.new
+    @chop_wally = Statement.new(@chopped_wally,Equal.new,InstanceCallContainer.new(@wally,Chop.new))
+    @chopped_length = Unknown.new
+    @chop_length = Statement.new(@chopped_length,Equal.new,InstanceCallContainer.new(@chopped_wally,StringLength.new))
+    @wall = Unknown.new
+    @statement_c = Statement.new(@wall,Equal.new,InstanceCallContainer.new(@chopped_wally,Chop.new))
+    @hermot = Literal.new('Hermot')
+    @hermot_var = Unknown.new
+    @declared_hermot = Statement.new(@hermot_var,Equal.new,@hermot)
+    @hermo_wall = Unknown.new
+    @hermo_wall_statement = Statement.new(@hermo_wall,Equal.new,InstanceCallContainer.new(@hermot_var,Chop.new),Addition.new,InstanceCallContainer.new(@chopped_wally,Chop.new))
+    
+    # This statement uses variables that haven't been declared in a statement
+    @bad_statement = Statement.new(Unknown.new,Equal.new,InstanceCallContainer.new(StringVariable.new('badboy'),Chop.new))
+    
+    # Chopping wall
+    @wal = Unknown.new
+    @statement_d = Statement.new(@wal,Equal.new,InstanceCallContainer.new(@wall,Chop.new))
+    
+    # Create a simple set of statement dependencies that use params
+    # var_a = MethodUsage.new
+    # var_b = RuntimeMethod.new(var_a)
+    @dependency_set_1 = StatementDependencies.new
+    @var_a = Unknown.new
+    @var_b = Unknown.new
+    @statement_a = Statement.new(@var_a,Equal.new,ClassMethodCallContainer.new(MethodUsageClass.new,New.new))
+    @statement_b = Statement.new(@var_b,Equal.new,ClassMethodCallContainer.new(RuntimeMethodClass.new,New.new,@var_a))
+    @dependency_set_1.push(@statement_a)
+    @dependency_set_1.push(@statement_b)      
+    
+    
+  end
+
+  def teardown
+    System.reset
+  end   
+  
+  def test_push
+    
+    # Check statements can be added 
+    statement_depenencies = StatementDependencies.new(@chop_wally)
+    assert_equal(1,statement_depenencies.length)
+    
+    # Check pushing new statements
+    statement_depenencies.push(@chop_length)
+    assert_equal(2,statement_depenencies.length)
+    
+    # Check that an error is thrown if the statement dependencies can't be found
+    assert_raises(StandardError){statement_depenencies.push(@bad_statement)}    
+    
+    # Here we are check depenceys are found for statements with multiple variables in
+        
+    
+  end
+  
+  def test_dependencies_for
+    
+    statement_depenencies = StatementDependencies.new()  
+    # hermot = 'Hermot'
+    statement_depenencies.push(@declared_hermot)
+    
+    # This statement shouldn't have any depenencies
+    assert_equal(1,statement_depenencies.dependencies_for(@declared_hermot.statement_id).length)  
+    
+    # Add a statement dependent on the first statement
+    # chopped_wally = 'Wally'.chop
+    statement_depenencies.push(@chop_wally)
+    assert_equal(1,statement_depenencies.dependencies_for(@chop_wally.statement_id).length)
+    statement_chop_chop_wally = Statement.new(Unknown.new,Equal.new,InstanceCallContainer.new(@chopped_wally,Chop.new))
+    statement_depenencies.push(statement_chop_chop_wally)
+    assert_equal(2,statement_depenencies.dependencies_for(statement_chop_chop_wally.statement_id).length)
+     
+    # Now add a string+string statement that uses the above statement
+    statement_depenencies.push(@hermo_wall_statement)
+    assert_equal(3,statement_depenencies.dependencies_for(@hermo_wall_statement.statement_id).length)
+    
+    assert_equal(1,@dependency_set_1.dependencies_for(@statement_a.statement_id).length)
+    assert_equal(@statement_a.statement_id,@dependency_set_1.dependencies_for(@statement_a.statement_id).first)    
+    assert_equal(2,@dependency_set_1.dependencies_for(@statement_b.statement_id).length)    
+    
+    # Create the statement with dependencies
+    statement_depenencies = StatementDependencies.new(@chop_wally,@chop_length,@statement_c)
+    
+    # Find the needed variables for the statements
+    assert_equal(1,@chop_length.not_declared_variables.length)
+    
+    # First statement doesn't have any dependecies
+    assert_equal(1,statement_depenencies.dependencies_for(@chop_wally.statement_id).length)        
+    
+    # The secound statement has one dependency
+    assert_equal(2,statement_depenencies.dependencies_for(@chop_length.statement_id).length)        
+    assert_equal(@chop_wally.statement_id,statement_depenencies.dependencies_for(@chop_length.statement_id).first)        
+    
+    # The third statement also only has one dependency
+    assert_equal(@chop_wally.statement_id,statement_depenencies.dependencies_for(@statement_c.statement_id).first)        
+    
+    # Add a fourth statement with 2 dependencies 'Wally' then 'Wall'
+    statement_depenencies.push(@statement_d)
+    assert_equal(3,statement_depenencies.dependencies_for(@statement_d.statement_id).length)            
+
+    # Check that an error is raised when looking for depencies for a variable that doesn't exist
+    assert_raises(StandardError){statement_depenencies.dependencies_for(@bad_statement.statement_id)}    
+    
+  end
+
+  def test_find_dependencies_for
+     assert_equal(0,@dependency_set_1.find_dependencies_for(@statement_a).length)
+     assert_equal(1,@dependency_set_1.find_dependencies_for(@statement_b).length) 
+     
+    #  Check that dependies are found for modified statements
+    #   var_a = 8
+    #   var_b = []
+    #   var_b.push(9)
+    #   var_b.push(10)
+    statement_a_1 = Statement.new(Unknown.new,Equal.new,8.to_literal)
+    statement_a_2 = Statement.new(Unknown.new,Equal.new,[].to_literal)    
+    statement_a_3 = Statement.new(InstanceCallContainer.new(statement_a_2.first.copy,Push.new,9.to_literal))
+    statement_a_4 = Statement.new(InstanceCallContainer.new(statement_a_3.first.subject.copy,Push.new,10.to_literal))
+    runtime_a = RuntimeMethod.new(MethodUsage.new)
+    runtime_a.push(statement_a_1)
+    runtime_a.push(statement_a_2)
+    runtime_a.push(statement_a_3)
+    runtime_a.push(statement_a_4)
+    
+    # Realise the method and add each of statements
+    assert_nothing_raised(){runtime_a.realise2(ParametersContainer.new)}
+    
+     
+  end
+
+end

data/test/unit/core/statement/tc_statement_group.rb

@@ -0,0 +1,35 @@
+require 'required'
+require 'test/unit'
+
+class TestStatementGroup < Test::Unit::TestCase
+  
+  def setup
+    
+  end
+  
+  def teardown
+System.reset
+    RuntimeMethod.reset_global_id
+  end  
+  
+  def test_find_all_required_runtime_methods
+    
+    # 1.  Find all the runtime methods in a statement group with two statements in
+    #   a.  Create both statements and methods used in the statement group
+    method_1 = RuntimeMethod.new(MethodUsage.new)
+    method_2 = RuntimeMethod.new(MethodUsage.new)
+    statement_1 = Statement.new(Unknown.new,Equal.new,DefCall.new(nil.to_var,method_1))
+    statement_2 = Statement.new(Unknown.new,Equal.new,DefCall.new(nil.to_var,method_2))    
+    
+    #   b.  Create the statement group with the runtime methods and check that both
+    #       runtime methods are retrieved.
+    statement_group_1 = StatementGroup.new(statement_1,statement_2)
+    assert_equal(2,statement_group_1.find_all_required_runtime_methods.length)
+    statement_group_1.find_all_required_runtime_methods.each do |x|
+      assert(x.kind_of?(RuntimeMethod))
+    end
+    
+  end
+  
+  
+end

data/test/unit/core/statement/tc_statement_replace_variable.rb

@@ -0,0 +1,61 @@
+# This test case tests the direct replacement of a variable within a statement.
+
+require 'required'
+require 'test/unit'
+
+class TestStatementReplaceVariable < Test::Unit::TestCase
+  
+  def setup
+    
+  end
+  
+  def teardown
+System.reset
+    RuntimeMethod.reset_global_id    
+  end
+  
+  def test_variable_replacement_with_statement_with_three_variables
+
+    # Create the statement to be tested
+    var_A = Unknown.new
+    var_B = Unknown.new
+    var_C = Unknown.new
+    statement = Statement.new(var_C,Equal.new,var_A,Addition.new,var_B)
+    assert_nothing_raised(){statement.write}
+    
+    # Check that the variable id in the statement matches
+    assert_equal(var_A.variable_id,statement[2].variable_id)
+    
+    # Replace the variable in the statement
+    var_D = Unknown.new
+    assert_nothing_raised(){statement.replace_variable!(var_A.variable_id,var_D)}
+    
+    # Check that the statement has been updated
+    assert_not_equal(var_A.variable_id,statement[2].variable_id)
+    assert_equal(var_D.variable_id,statement[2].variable_id)
+    
+  end
+  
+  def test_instance_call_replacement
+    
+    # Create the statement with the instance call
+    var_A = Unknown.new
+    var_B = 'test'.to_var
+    statement = Statement.new(var_A,Equal.new,InstanceCallContainer.new(var_B,Chop.new))
+    assert_nothing_raised(){statement.write}    
+
+    # Check that the variable id in the statement matches
+    assert_equal(var_B.variable_id,statement[2].variable_id)
+    
+    # Replace var_B with variable C
+    var_C = 'scentilla'.to_var
+    assert_nothing_raised(){statement.replace_variable!(var_B.variable_id,var_C)}
+    
+    # Check that the statement is still valid
+    assert(statement[2].kind_of?(InstanceCallContainer))
+    assert_equal(var_C.variable_id,statement[2].variable_id)    
+    assert(statement[2].subject.kind_of?(Variable))  
+      
+  end
+  
+end

data/test/unit/core/statement/tc_theory_statement.rb

@@ -0,0 +1,51 @@
+require 'required'
+require 'test/unit'
+
+class TestTheoryStatement < Test::Unit::TestCase
+  
+  def setup
+    @statement_1 = StringToTheory.run("var8 = 7")
+  end
+  
+  def teardown
+    System.reset
+    RuntimeMethod.reset_global_id
+  end  
+
+  def test_copy
+    assert(@statement_1.copy.kind_of?(TheoryStatement))
+  end
+  
+  def test_select_all
+    assert_equal(
+      3,
+      StringToTheory.run(
+        'var1.realise2(var3).params[0].value.length == var2.length'
+      ).select_all {|x| x.kind_of?(TheoryVariable)}.length
+    )      
+  end
+  
+  #   Using:
+  #   if((var1.params[var3].length == var1) == false)
+  #     return true
+  #   end
+  #
+  def test_replace_theory_variables_with_case_1
+    theory = TheoryStatement.new(
+      StringToTheory.run("if((var1.params[var3].length == var1) == false)\nreturn true\nend")
+    )
+    
+    # Create the intrinsic mapping for the theory
+    mapping = Mapping.new
+    mapping[1] = Parser.run('runtime_method')
+    mapping[3] = IntrinsicLiteral.new(0)
+    
+    assert_equal(
+      "if((runtime_method.params[0].length == runtime_method) == false)\n\treturn true\nend",
+      theory.replace_theory_variables!(mapping).write
+    )
+    
+    
+  end
+      
+end

data/test/unit/core/structure/tc_declare_new_instance_structure.rb

@@ -0,0 +1,41 @@
+require 'required'
+require 'test/unit'
+
+class TestDeclareNewInstanceStructure < Test::Unit::TestCase
+  
+  def setup
+    
+    # Create the structure instance that generates the appropriate statement
+    @statement_generator = DeclareNewInstanceStructure.new(MethodUsageClass.new,RuntimeMethodClass.new)
+    
+  end
+  
+  def teardown
+    System.reset
+  end
+  
+  def test_statements
+    
+    # Test that "var = MethodUsage.new" can be created
+    assert_equal(true,@statement_generator.statements().all? {|x| x.kind_of?(Statement)})
+    assert_equal(true,(@statement_generator.statements().select_all {|x| x.kind_of?(MethodUsageClass) }.length > 0))
+    
+    # Test that "var = RuntimeMethod.new(<#method_usage>")
+    method_usage = MethodUsageVariable.new()
+    assert_equal(1,@statement_generator.statements([method_usage]).select_all {|x| x.kind_of?(RuntimeMethodClass)}.length)
+    
+    # Test that a statement that declares a new fixnum as variable can be created
+    new_statement_statement_generator = DeclareNewInstanceStructure.new(StatementClass.new)
+    assert_equal(
+      1,
+      new_statement_statement_generator.statements([5.to_literal]).select_all {|x| x.kind_of?(StatementClass)}.length
+    )
+    assert_equal(
+      'var_6 = Statement.new(Unknown.new, Equal.new, 5.to_declaration)',
+      new_statement_statement_generator.statements([5.to_literal]).first.write
+    )
+    
+    
+  end
+  
+end

data/test/unit/core/structure/tc_declare_variable_as_literal_structure.rb

@@ -0,0 +1,41 @@
+require 'required'
+require 'test/unit'
+
+class TestDeclareVariableAsLiteralStructure < Test::Unit::TestCase
+  
+  def setup
+    
+    # Create the structure instance that generates the appropriate statement
+    @statement_generator = DeclareVariableAsLiteralStructure.new
+    
+    
+  end
+  
+  def teardown
+    CodeHandler.reset_global_id
+    System.reset
+    RuntimeMethod.reset_global_id    
+  end
+  
+  def test_statements
+    
+    # Test that "var = 7" can be created
+    assert_equal(true,@statement_generator.statements([7.to_literal]).all? {|x| x.kind_of?(Statement)})
+    assert_equal(1,@statement_generator.statements([7.to_literal]).length)
+    assert_equal('var_2 = 7',@statement_generator.statements([7.to_literal]).first.write())
+    
+    # Test that "var = 8", "var = 'Grogg'" and 'var = []'
+    assert_equal(true,
+      @statement_generator.statements([
+        8.to_literal,'Grogg'.to_literal,[].to_literal
+        ]).all? {|x| x.kind_of?(Statement)}
+    )
+    assert_equal(true,
+      @statement_generator.statements([
+        8.to_literal,'Grogg'.to_literal,[].to_literal
+      ]).contains? {|x| x.kind_of?(Literal)}
+    )    
+    
+  end
+  
+end

data/test/unit/core/structure/tc_declare_variable_as_variable_structure.rb

@@ -0,0 +1,66 @@
+require 'required'
+require 'test/unit'
+
+class TestDeclareVariableAsVariableStructure < Test::Unit::TestCase
+  
+  def setup
+    
+    # Create the structure instance that generates the appropriate statement
+    @statement_generator = DeclareVariableAsVariableStructure.new
+    
+    # Create some simple variable declarations
+    @fixnum_variable = FixnumVariable.new(8)
+    @manny_variable = StringVariable.new('manny')    
+    
+  end
+  
+  def teardown
+    System.reset
+  end
+  
+  def test_statements
+    
+    # Test that "var = var(8)" can be created   
+    assert_equal(1,@statement_generator.statements([@fixnum_variable]).length)   
+    assert(@statement_generator.statements([@fixnum_variable]).first.kind_of?(Statement))   
+    assert_equal(@statement_generator.length,@statement_generator.statements([@fixnum_variable]).first.length)  
+
+    assert_equal(3,@statement_generator.statements([@manny_variable]).length)   
+    assert_equal(0,@statement_generator.statements([]).length)    
+    
+    # Attempt to generate structures that generate string variables
+    assert_equal(3,@statement_generator.statements([@manny_variable]).length)  
+    
+    # Attempt to generate a string+string statement
+    le = 'Le'.to_var
+    chuck = 'Chuck'.to_var
+    assert_equal(6,@statement_generator.statements([le,chuck]).length)
+    
+    # Test that declared variables can be retrieved from statement variabies
+    # e.g. var = statement_var.declared_variable
+    statement_var_a_unknown = Unknown.new
+    statement_var_a = Statement.new(statement_var_a_unknown,Equal.new,8.to_literal).to_var
+    # TODO  I'm not sure I should allow the re-dclaration of variables here
+    assert_equal(2,@statement_generator.statements([statement_var_a]).length)
+    assert_equal(
+      ' = var_'+statement_var_a.variable_id.to_s+'.declared_variable',
+      @statement_generator.statements([statement_var_a]).last.write[6..35]
+    )    
+    
+    # Check that the 'push' method isn't used in statement declarations
+    # Otherwise we generate allot of redundant variables.
+    # e.g. 
+    # var_a = ['test','asdf']
+    # var_b = var_a.push('test2')
+    #
+    # var_a and var_b are essentially the same variable.
+    options_a = [
+      Statement.new(Return.new,6.to_literal).to_var,
+      RuntimeMethod.new(MethodUsage.new).to_var
+    ]
+    assert_equal(3,@statement_generator.statements(options_a).length)
+    
+  end
+  
+end
+