cauldron 0.1.3 → 0.1.5

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

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

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

@@ -1,53 +0,0 @@
-$LOAD_PATH << File.expand_path('../../../../../lib',__FILE__)
-
-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  return true\nend",
-      theory.replace_theory_variables!(mapping).write
-    )
-    
-    
-  end
-      
-end

data/test/unit/core/syntax/tc_block_container.rb

@@ -1,32 +0,0 @@
-require 'required'
-require 'test/unit'
-
-class TestBlockContainer < Test::Unit::TestCase
-  
-  def setup
-    
-    # Create block containers with different numbers of variables
-    @block_container_1 = BlockContainer.new('lotus'.to_var)
-    @block_container_2 = BlockContainer.new(9.to_var,'test'.to_var)
-    
-  end
-  
-  def teardown
-System.reset
-    RuntimeMethod.reset_global_id
-  end  
-
-  def test_write
-    assert_equal('|var_0|',@block_container_1.write)
-    assert_equal('|var_1, var_2|',@block_container_2.write)
-  end
-  
-  def test_copy
-    assert_equal(@block_container_1.length,@block_container_1.copy.length)
-    assert_equal(@block_container_2.length,@block_container_2.copy.length)
-    assert_equal(@block_container_1.first.variable_id,@block_container_1.copy.first.variable_id)
-    assert_equal(@block_container_2.first.variable_id,@block_container_2.copy.first.variable_id)    
-    assert_equal(@block_container_2.last.variable_id,@block_container_2.copy.last.variable_id)        
-  end
-      
-end

data/test/unit/core/syntax/tc_if_container.rb

@@ -1,39 +0,0 @@
-require 'required'
-require 'test/unit'
-
-class TestIfContainer < Test::Unit::TestCase
-  
-  def setup
-    
-  end
-  
-  def teardown
-    System.reset
-    RuntimeMethod.reset_global_id
-  end  
-
-  def test_write
-    
-    # 1.  if(true)
-    assert_equal('if(true)',Statement.new(If.new,Container.new(True.new)).write)
-    
-    # 2.  if(var_x == 'test')
-    unknown_variable_2 = Unknown.new
-    if_statement_2 = Statement.new(If.new,Container.new(unknown_variable_2,Equivalent.new,Literal.new('test')))
-    assert_equal('if(var_'+unknown_variable_2.variable_id.to_s+" == 'test')",if_statement_2.write)
-    
-  end  
-  
-  def test_copy
-    
-    # 1.  Check copy works if(true)
-    assert_equal(Statement.new(If.new,Container.new(True.new)).write,Statement.new(If.new(Container.new(True.new))).copy.write)
-    
-    # 2.  Check copy works for "if(var_x == 'test')"
-    unknown_variable_2 = Unknown.new
-    if_statement_2 = Statement.new(If.new,Container.new(unknown_variable_2,Equivalent.new,Literal.new('test')))
-    assert_equal(if_statement_2.copy.write,if_statement_2.write)    
-    
-  end
-  
-end

data/test/unit/core/tc_class_method_call.rb

@@ -1,34 +0,0 @@
-require 'required'
-require 'test/unit'
-
-class TestClassMethodCallContainer < Test::Unit::TestCase
-  
-  def setup
-    
-    # Create a simple method call var_a = MethodUsage.new
-    @simple_method_usage = ClassMethodCallContainer.new(MethodUsageClass.new,New.new)          
-    
-    # Create a simple method usage instance
-    @simple_method_usage_var = MethodUsage.new().to_var
-    @simple_runtime_method_instance = ClassMethodCallContainer.new(RuntimeMethodClass.new,New.new,@simple_method_usage_var)
-          
-  end
-  
-  def teardown
-    System.reset
-    RuntimeMethod.reset_global_id    
-  end
-  
-  def test_select_all
-    
-    # Test where method doesn't exist
-    assert_equal(0,@simple_method_usage.select_all {|x| x.kind_of?(MethodUsageVariable)}.length)
-    
-    assert_equal(
-      @simple_method_usage_var.variable_id,
-      @simple_runtime_method_instance.select_all {|x| x.kind_of?(Variable)}.first.variable_id
-    )
-   
-  end
-  
-end

data/test/unit/core/tc_container.rb

@@ -1,41 +0,0 @@
-require 'required'
-require 'test/unit'
-
-class TestContainer < Test::Unit::TestCase
-  
-  def setup
-    @simple_container = Container.new(Parser.run('var3'),Equivalent.new,Parser.run('var2'))          
-  end
-  
-  def teardown
-    System.reset
-    RuntimeMethod.reset_global_id    
-  end
-  
-  def test_initialize
-    Container.new(
-      Parser.run('var3'),
-      Equivalent.new,
-      Parser.run('var2')
-    )    
-  end
-  
-  def test_write
-    assert_equal(
-        Container.new(
-          Parser.run('var3'),
-          Equivalent.new,
-          Parser.run('var2')
-        ).write,
-        '(var_3 == var_2)'
-    )
-  end  
-  
-  def test_select_all
-    assert_equal(
-      2,
-      @simple_container.select_all {|x| x.kind_of?(BaseVariable)}.length
-    )
-  end    
-   
-end

data/test/unit/core/tc_ctest_case.rb

@@ -1,25 +0,0 @@
-require 'required'
-require 'test/unit'
-
-class TestCTestCase < Test::Unit::TestCase
-  
-  def setup
-    @cauldron_test_case_1 = CTestCase.new() 
-    @cauldron_test_case_1[:params] = ['something']
-    @cauldron_test_case_1[:output] = 'exists'      
-  end
-  
-  def teardown
-    System.reset
-    RuntimeMethod.reset_global_id    
-  end
-  
-  def test_cauldron_method_calls
-    assert_equal(2,@cauldron_test_case_1.cauldron_method_calls.length)
-    assert_equal(
-      "[:output]",
-      @cauldron_test_case_1.cauldron_method_calls.first
-    )
-  end
-  
-end

data/test/unit/core/tc_instance_call_container.rb

@@ -1,93 +0,0 @@
-require 'required'
-require 'test/unit'
-
-class TestInstanceCallContainer < Test::Unit::TestCase
-  
-  def setup
-      
-  end
-  
-  def teardown
-    System.reset
-    RuntimeMethod.reset_global_id    
-  end
-  
-  def test_equivalent
-    
-    # Create a push statement and confirm they are captured as equivalent
-    instance_call_container_a = InstanceCallContainer.new(RuntimeMethod.new(MethodUsage.new).to_var,Push.new,Statement.new.to_var)
-    assert(true,instance_call_container_a.equivalent?(instance_call_container_a.copy))
-    
-  end
-  
-  def test_subst!
-    
-    # Test that variables are replaced in the instance call
-    # 'warren'.length -> 'marc'.length
-    warren = 'warren'.to_var
-    new_var_length = InstanceCallContainer.new(warren,StringLength.new)
-    marc = 'marc'.to_var
-    assert_equal(warren.uniq_id,new_var_length.subject.uniq_id)
-    new_var_length.subst!(marc) {|x| x.uniq_id == warren.uniq_id}
-    assert_equal(marc.uniq_id,new_var_length.subject.uniq_id)
-    assert_not_equal(warren.uniq_id,new_var_length.subject.uniq_id)
-    
-    # Test the paramters are properly replaced
-    # [].push('dragon') -> [].push('unicorn')
-    dragon = 'dragon'.to_var
-    unicorn = 'unicorn'.to_var
-    pushing_call = InstanceCallContainer.new([].to_var,Push.new,dragon)
-    assert_equal(pushing_call.parameters.last.uniq_id,dragon.uniq_id)
-    pushing_call.subst!(unicorn){|x| x.uniq_id == dragon.uniq_id}
-    assert_not_equal(pushing_call.parameters.last.uniq_id,dragon.uniq_id)   
-    assert_equal(pushing_call.parameters.last.uniq_id,unicorn.uniq_id)       
-        
-  end
-  
-  def test_select_all
-    assert_equal(
-      2,
-      StringToTheory.run(
-        "var1.realise2(var3).params[0].value.length"
-      ).select_all {|x| x.kind_of?(TheoryVariable)}.length
-    )
-  end
-  
-  def test_contains
-    assert_equal(
-      true,
-      Parser.run('var1.push(8)').kind_of?(InstanceCallContainer)
-    )
-    assert_equal(
-      true,
-      Parser.run('var1.push(8)').contains? {|x| x.kind_of?(Unknown)}
-    )
-    assert_equal(
-      true,
-      Parser.run('var1.push(8)').contains? {|x| x.kind_of?(Push)}
-    )
-    assert_equal(
-      true,
-      Parser.run('var1.push(8)').contains? {|x| x.kind_of?(Literal)}
-    )     
-  end
-  
-  def test_equivalent
-    assert_equal(
-      true,
-      Parser.run('var1.push(8)').equivalent?(Parser.run('var1.push(8)'))
-    )
-    assert_equal(
-      true,
-      Parser.run('var2.push(8)').equivalent?(Parser.run('var1.push(8)'))
-    )
-    assert_equal(
-      true,
-      Parser.run('var2.push(var8)').equivalent?(Parser.run('var1.push(var9)'))
-    )
-    assert_equal(
-      false,
-      Parser.run('var2.push(var8)').equivalent?(Parser.run('var1.push(var9,var7)'))
-    )    
-  end
-end

data/test/unit/core/tc_literal.rb

@@ -1,30 +0,0 @@
-require 'required'
-require 'test/unit'
-
-class TestLiteral < Test::Unit::TestCase
-  
-  def setup
-    
-    @spectre = Literal.new('spectre')  
-    @num_2009 = Literal.new(2009)
-    
-  end
-  
-  def teardown
-    System.reset
-    RuntimeMethod.reset_global_id
-  end  
-  
-  def test_initialize
-    
-    # Attempt to create an unknown literal
-    assert_raises(UnliteralisableError){Literal.new(MethodUsage.new)}
-    
-  end
-  
-  def test_to_literal_string      
-    assert_equal("'spectre'",@spectre.to_literal_string)
-    assert_equal("2009",@num_2009.to_literal_string)    
-  end
-      
-end