cauldron 0.1.2 → 0.1.3

data/test/fixtures/theories/7/desc

@@ -1,11 +1,11 @@
 if: 
-	if(var1.realise2(var2[var3][:params]).params[var4].value.length == var2[var3][:output])
-		return true
-	end
+  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)
+  <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
+  if(var1.pass?(var2[var3]))
+    return true
+  end

data/test/fixtures/theories/8/desc

@@ -1,11 +1,11 @@
 if: 
-	if(var1[var2][:params][var2] + var1[var2][:params][var3] == var1[var2][:output])
-		return true
-	end
+  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)
+  <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
+  if(var4.all_pass?(var1))
+    return true
+  end

data/test/fixtures/theories/9/desc

@@ -1,20 +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
+  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(Statement.new(If.new, Container.new(var2[var3][:params][var6], Equivalent.new, var2[var3][:output])),var1.statement_id)
+  <runtime_method>.add_statement_at(Statement.new(If.new, Container.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
+  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/ts_complete.rb

@@ -12,7 +12,7 @@ require 'test/unit/core/tc_instance_call_container'
 # require 'test/unit/core/syntax/tc_block_container'
 # require 'test/unit/core/syntax/tc_if_container'
 # require 'test/unit/core/declaration/tc_literal_declaration'
-# 
+
 require 'test/unit/ruby_code/tc_string'
 require 'test/unit/ruby_code/tc_fixnum'
 require 'test/unit/ruby_code/tc_hash'
@@ -33,12 +33,6 @@ require 'test/unit/core/statement/tc_statement_group'
 require 'test/unit/core/statement/tc_array_access'
 require 'test/unit/core/statement/tc_theory_statement'
 
-require 'test/unit/core/structure/tc_return_structure'
-require 'test/unit/core/structure/tc_instance_call_container_structure'
-require 'test/unit/core/structure/tc_declare_new_instance_structure'
-require 'test/unit/core/structure/tc_declare_variable_as_literal_structure'
-require 'test/unit/core/structure/tc_declare_variable_as_variable_structure'
-
 require 'test/unit/core/tracking/tc_history'
 require 'test/unit/core/tracking/tc_step'
 
@@ -66,12 +60,9 @@ require 'test/unit/theory/tc_theory_implementation'
 # require 'test/unit/theory/tc_theory_chain_validator'
 require 'test/unit/theory/tc_theory_action_implementation'
 
-require 'test/unit/tc_instance_call_structure'
 require 'test/unit/tc_instance_call'
 require 'test/unit/tc_method_usage'
 require 'test/unit/tc_runtime_tracking_method'
-require 'test/unit/core/statement/tc_statement_dependencies'
-require 'test/unit/tc_statement_structure_2'
 require 'test/unit/tc_variable_declaration'
 
 require 'test/tc_describe'

data/test/unit/core/runtime_method/tc_realised_runtime_method.rb

@@ -1,5 +1,6 @@
 $LOAD_PATH << File.expand_path('../../../../../lib',__FILE__)
 
+require 'cauldron'
 require 'required'
 require 'test/unit'
 

data/test/unit/core/runtime_method/tc_runtime_method.rb

@@ -1,6 +1,6 @@
 $LOAD_PATH << File.expand_path('../../../../../lib',__FILE__)
 
-require 'required'
+require 'cauldron'
 require 'test/unit'
 
 class TestRuntimeMethod < Test::Unit::TestCase
@@ -256,7 +256,9 @@ class TestRuntimeMethod < Test::Unit::TestCase
     tracking_method = RuntimeTrackingMethod.new(instance_tracking_variable)    
 
     # Trackify it and check nothing is raised
-    assert_nothing_raised(){string_runtime_method.trackify(ParametersContainer.new('Manny'.to_var),tracking_method)}
+    assert_nothing_raised(){
+      string_runtime_method.trackify(ParametersContainer.new('Manny'.to_var),tracking_method)
+    }
 
     # Check that the method is unchanged after trackify
     assert_equal(original_written,string_runtime_method.write)    
@@ -318,8 +320,8 @@ class TestRuntimeMethod < Test::Unit::TestCase
     }
     realised_instance_1 = simple_method.realise2(['Grim','fandango','Threepwood'])
     assert_equal(
-      "\n#\n#\t@param\t[StringVariable] 'Grim'\n#\t@param\t[StringVariable] 'fandango'\n" \
-      "#\t@param\t[StringVariable] 'Threepwood'\n#\n#\n" \
+      "\n#\n#  @param  [StringVariable] 'Grim'\n#  @param  [StringVariable] 'fandango'\n" \
+      "#  @param  [StringVariable] 'Threepwood'\n#\n#\n" \
       "def method_0(var_#{simple_method.usage[0].variable_id}, var_#{simple_method.usage[1].variable_id}, var_#{simple_method.usage[2].variable_id})\n\nend\n",
       realised_instance_1.write
     )
@@ -342,9 +344,9 @@ class TestRuntimeMethod < Test::Unit::TestCase
     simple_method.push(Statement.new(var_c,Equal.new,InstanceCallContainer.new(var_a,StringLength.new)))
     realised_instance_2 = simple_method.realise2(['Grim','fandango','Threepwood'])
     assert_equal(
-      "\n#\n#\t@param\t[StringVariable] 'Grim'\n#\t@param\t[StringVariable] 'fandango'\n#\t@param\t[StringVariable] 'Threepwood'\n#\n#\n"\
+      "\n#\n#  @param  [StringVariable] 'Grim'\n#  @param  [StringVariable] 'fandango'\n#  @param  [StringVariable] 'Threepwood'\n#\n#\n"\
       "def method_0(var_#{simple_method.usage[0].variable_id}, var_#{simple_method.usage[1].variable_id}, var_#{simple_method.usage[2].variable_id})"\
-      "\n\tvar_64 = var_35.length\nend\n",
+      "\n  var_64 = var_35.length\nend\n",
       realised_instance_2.write
     )
     
@@ -354,11 +356,11 @@ class TestRuntimeMethod < Test::Unit::TestCase
     simple_method_written_3 = simple_method.write
     realised_simple_method_3 = simple_method.realise2(['Grim','fandango','Threepwood'])
     assert_equal(
-      "\n#\n#\t@param\t[StringVariable] 'Grim'\n"\
-      "#\t@param\t[StringVariable] 'fandango'\n"\
-      "#\t@param\t[StringVariable] 'Threepwood'\n"\
+      "\n#\n#  @param  [StringVariable] 'Grim'\n"\
+      "#  @param  [StringVariable] 'fandango'\n"\
+      "#  @param  [StringVariable] 'Threepwood'\n"\
       "#\n#\ndef method_0(var_#{simple_method.usage[0].variable_id}, var_#{simple_method.usage[1].variable_id}, var_#{simple_method.usage[2].variable_id})\n"\
-      "\tvar_64 = var_#{simple_method.usage[0].variable_id}.length\n\tvar_76 = var_#{simple_method.usage[0].variable_id}.chop\nend\n",
+      "  var_64 = var_#{simple_method.usage[0].variable_id}.length\n  var_76 = var_#{simple_method.usage[0].variable_id}.chop\nend\n",
       realised_simple_method_3.write
     )
     
@@ -377,7 +379,7 @@ class TestRuntimeMethod < Test::Unit::TestCase
     simple_method_written_4 = simple_method.write
     realised_simple_method_4 = simple_method.realise2(['Grim','fandango','Threepwood'])
     assert_equal(
-      "\n#\n#\t@param\t[StringVariable] 'Grim'\n#\t@param\t[StringVariable] 'fandango'\n#\t@param\t[StringVariable] 'Threepwood'\n#\n#\ndef method_0(var_35, var_36, var_37)\n\tvar_64 = var_35.length\n\tvar_76 = var_35.chop\n\tvar_89 = var_36.length\n\tvar_90 = var_89 + var_64\nend\n",
+      "\n#\n#  @param  [StringVariable] 'Grim'\n#  @param  [StringVariable] 'fandango'\n#  @param  [StringVariable] 'Threepwood'\n#\n#\ndef method_0(var_35, var_36, var_37)\n  var_64 = var_35.length\n  var_76 = var_35.chop\n  var_89 = var_36.length\n  var_90 = var_89 + var_64\nend\n",
       realised_simple_method_4.write
     )
     
@@ -400,7 +402,7 @@ class TestRuntimeMethod < Test::Unit::TestCase
     
     # a.  Create the method that returns a statement variable
     return_statement_method = RuntimeMethod.new(MethodUsage.new(),Statement.new.to_var)
-    return_statement_method.push(Statement.new(Return.new,Statement.new(Return.new,'sparky').to_declaration ))    
+    return_statement_method.push(Parser.run('return Statement.new(Return.new,"sparky")'))
     
     # b.  Create the method 
     runtime_method_2 = RuntimeMethod.new(MethodUsage.new)    
@@ -437,10 +439,10 @@ class TestRuntimeMethod < Test::Unit::TestCase
     assert_not_equal("#\n#\ndef method_"+method_example_b.method_id.to_s+"\n\nend\n",method_example_b.write)    
       
     # Test that neested methods are writen properly      
-    assert_equal("\n#\n#\ndef method_6\n\tvar_28 = ''\n\tvar_29 = 'x'\n\t3.times do |var_30|\n\t\tvar_28 = var_28 + var_29\n\tend\n\nend\n",@build_xxx_method.write)  
+    assert_equal("\n#\n#\ndef method_6\n  var_28 = ''\n  var_29 = 'x'\n  3.times do |var_30|\n    var_28 = var_28 + var_29\n  end\n\nend\n",@build_xxx_method.write)  
     
     # Test how the method is written with tabs
-    assert_equal("\n\t#\n\t#\n\tdef method_6\n\t\tvar_28 = ''\n\t\tvar_29 = 'x'\n\t\t3.times do |var_30|\n\t\t\tvar_28 = var_28 + var_29\n\t\tend\n\n\tend\n",@build_xxx_method.write(nil,1))      
+    assert_equal("\n  #\n  #\n  def method_6\n    var_28 = ''\n    var_29 = 'x'\n    3.times do |var_30|\n      var_28 = var_28 + var_29\n    end\n\n  end\n",@build_xxx_method.write(nil,1))      
          
   end
   
@@ -510,31 +512,6 @@ class TestRuntimeMethod < Test::Unit::TestCase
     assert_equal(9,@simple_method.to_var(8,9).uniq_id)    
     
   end
-  
-  def test_to_declaration
-    
-    # Test the simplest possible runtime method - accepts nothing and returns nothing
-    simple_runtime_method = RuntimeMethod.new(MethodUsage.new,nil.to_var)
-    assert_nothing_raised() {simple_runtime_method.to_declaration}
-
-    # Test a simple runtime method expected to return a literal
-    literal_return_runtime_method = RuntimeMethod.new(MethodUsage.new,56) 
-    assert_nothing_raised() {literal_return_runtime_method.to_declaration}
-
-    # Test a simple runtime method that accepts a parameter
-    single_parameter_runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new()),nil)        
-    assert_nothing_raised() {single_parameter_runtime_method.to_declaration}
-    
-    # Test that a runtime method that contains one statement is duplicated correctly
-    test_3_runtime_method = RuntimeMethod.new(MethodUsage.new)
-    test_3_runtime_method.push Statement.new(Return.new,'Tony')
-    assert_equal('Tony',MethodValidation.new.use_runtime_method(test_3_runtime_method))
-    
-    # Create a duplicate of the simple runtime method
-    duplicate_test_3_runtime_method = test_3_runtime_method.to_declaration.evaluate
-    assert_equal('Tony',MethodValidation.new.use_runtime_method(duplicate_test_3_runtime_method))
-
-  end
 
   def test_abstract_variables_for_tracking_with_some_simple_statement
     #assert_equal(1,@simple_method.abstract_variables_for_tracking(Parser.run('var4 = "test"')).length)

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

@@ -35,13 +35,13 @@ class TestBlockStatement < Test::Unit::TestCase
   
   def test_write
     assert_equal("var_0.each do |var_"+@block_variable.variable_id.to_s+"|\nend\n",@each_game.write(0))    
-    assert_equal("\tvar_0.each do |var_1|\n\tend\n",@each_game.write(1))    
+    assert_equal("  var_0.each do |var_1|\n  end\n",@each_game.write(1))    
     assert_equal(
-      "var_0.each do |var_"+@populated_loop_block_var.variable_id.to_s+"|\n\tvar_"+@declared_unknown.variable_id.to_s+" = 6\nend\n",
+      "var_0.each do |var_"+@populated_loop_block_var.variable_id.to_s+"|\n  var_"+@declared_unknown.variable_id.to_s+" = 6\nend\n",
       @populated_loop.write(0)
     )    
     assert_equal(
-      "\tvar_0.each do |var_"+@populated_loop_block_var.variable_id.to_s+"|\n\t\tvar_"+@declare_six.declared_variable_id.to_s+" = 6\n\tend\n",
+      "  var_0.each do |var_"+@populated_loop_block_var.variable_id.to_s+"|\n    var_"+@declare_six.declared_variable_id.to_s+" = 6\n  end\n",
       @populated_loop.write(1)
     )        
   end

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

@@ -37,7 +37,7 @@ class TestOpenStatement < Test::Unit::TestCase
     
     # Test that internal statements are properly tabs
     @simple_open_if_statement << Statement.new(Return.new,True.new)
-    assert_equal("if(#{@simple_if_statement_var.write} == 'Stobart')\n\treturn true\nend" ,@simple_open_if_statement.write)
+    assert_equal("if(#{@simple_if_statement_var.write} == 'Stobart')\n  return true\nend" ,@simple_open_if_statement.write)
     
   end
   
@@ -71,9 +71,9 @@ class TestOpenStatement < Test::Unit::TestCase
   
   def test_write_structure_with_simple_examples
     assert_equal("if(a == b)\nend",Parser.run("if(var1 == var2)\nend").write_structure)
-    assert_equal("if(a == b)\n\treturn c\nend",Parser.run("if(var1 == var2)\nreturn 8\nend").write_structure)
-    assert_equal("if(a.chop == b)\n\treturn c\nend",Parser.run("if(var1.chop == var2)\nreturn 8\nend").write_structure)
-    assert_equal("if(a.chop == b)\n\treturn a.chop\nend", Parser.run("if(var1.chop == var2)\nreturn var1.chop\nend").write_structure)
+    assert_equal("if(a == b)\n  return c\nend",Parser.run("if(var1 == var2)\nreturn 8\nend").write_structure)
+    assert_equal("if(a.chop == b)\n  return c\nend",Parser.run("if(var1.chop == var2)\nreturn 8\nend").write_structure)
+    assert_equal("if(a.chop == b)\n  return a.chop\nend", Parser.run("if(var1.chop == var2)\nreturn var1.chop\nend").write_structure)
   end    
       
 end

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

@@ -1,6 +1,6 @@
 $LOAD_PATH << File.expand_path('../../../../../lib',__FILE__)
 
-require 'required'
+require 'cauldron'
 require 'test/unit'
 
 class TestStatement < Test::Unit::TestCase
@@ -212,21 +212,6 @@ class TestStatement < Test::Unit::TestCase
       assert_not_equal(statement.object_id,copied_statement[i].object_id)
     end
     
-    # Check that the statement_type is maintained for copied statements.
-    statement_1 = Statement.new(@var_a,Equal.new,Literal.new('Daggerfall')) 
-    #statement_1.statement_type = StatementStructure::DECLARATION_STATEMENT
-    assert_equal(statement_1.copy.statement_type,statement_1.statement_type)
-    
-  end
-  
-  # Tests it can identifiy the structure of the statement.
-  #
-  def test_statement_type
-    assert_equal(StatementStructure::DECLARATION_STATEMENT,@statement_b.statement_type)  
-    assert_equal(StatementStructure::RETURN_STATEMENT,@return_statement_a.statement_type)
-    
-    # Test some poorly structured statements
-    assert_raises(UnknownStatementType){Statement.new(RequirementsVariable.new,RequirementsVariable.new).statement_type}
   end
   
   def test_required_variable_ids
@@ -314,42 +299,6 @@ class TestStatement < Test::Unit::TestCase
   def test_write
     
   end
- 
-  def test_to_declaration
-    
-    # Check that statement returns a declaration statement
-    assert_equal(true,@simple_statement.to_declaration.kind_of?(VariableDeclaration))
-    
-    # Check to_declaration command when excluding a variable
-    assert_equal(
-      "Statement.new(var_#{@var_c.variable_id}, Equal.new(), InstanceCallContainer.new(StringVariable.new('Arena'), Chop.new()))",
-      @statement_b.to_declaration([@var_c.variable_id]).write
-    )
-    
-  end
-  
-  def test_find_all_required_runtime_methods
-    
-    # Check that any empty array is returned if there are no runtime methods used
-    assert_equal(0,@simple_statement.find_all_required_runtime_methods.length)        
-    
-    # 1.  Create a statement that calls a runtime method
-    static_statement = Statement.new
-    #static_statement.statement_type = StatementStructure::MISC_STATEMENT
-    return_statement_method = RuntimeMethod.new(MethodUsage.new(),static_statement.to_var)
-    return_statement = Statement.new(Return.new,'sparky')
-    #return_statement.statement_type = StatementStructure::RETURN_STATEMENT
-    return_declaration_statement = Statement.new(Return.new,return_statement.to_declaration )
-    #return_declaration_statement.statement_type = StatementStructure::RETURN_STATEMENT
-    return_statement_method.push(return_declaration_statement)    
-    
-    # 1a.   Create the statement that contains the method call
-    statement_with_method_call = Statement.new(Unknown.new,Equal.new,DefCall.new(static_statement.to_var,return_statement_method))
-    #statement_with_method_call.statement_type = StatementStructure::DECLARATION_STATEMENT
-    assert_equal(1,statement_with_method_call.find_all_required_runtime_methods.length)
-    assert(statement_with_method_call.find_all_required_runtime_methods.kind_of?(Array))    
-        
-  end
   
   def test_realise2
             
@@ -399,12 +348,8 @@ class TestStatement < Test::Unit::TestCase
     called_runtime_method_3 = RuntimeMethod.new(MethodUsage.new,blank_statement.to_var)
     
     #   b.  Create the statement that is returned as a variable. 
-    returned_statement_variable = Statement.new(Return.new,'sparky')
     declared_return_statement_var = Unknown.new
-    #declare_return_statement = Statement.new(declared_return_statement_var,Equal.new,returned_statement_variable.to_declaration)
-    return_return_statement = Statement.new(Return.new,returned_statement_variable.to_declaration)    
-    #return_return_statement.statement_type = StatementStructure::RETURN_STATEMENT
-    #declare_return_statement = StatementStructure::DECLARATION_STATEMENT
+    return_return_statement = Statement.new(Return.new,Parser.run("Statement.new(Return.new,'sparky')"))    
     called_runtime_method_3.push(return_return_statement)
     
     #   c.  Create the method that includes a call to "called_runtime_method_3"
@@ -430,73 +375,6 @@ class TestStatement < Test::Unit::TestCase
     
   end
   
-  def test_statement_type
-    
-    # Test that statement type is saved correctly - even after copying
-    return_statement = Statement.new(Return.new,6.to_literal)
-    #return_statement.statement_type = StatementStructure::RETURN_STATEMENT
-    assert_equal(return_statement.statement_type,StatementStructure::RETURN_STATEMENT)
-    assert_equal(return_statement.copy.statement_type,StatementStructure::RETURN_STATEMENT)
-    
-    # Test that return statements can be dynamically identified
-    return_statement_without_statement_type = Statement.new(Return.new,8.to_literal)
-    assert_nothing_raised(){return_statement_without_statement_type.statement_type}
-    assert_equal(return_statement_without_statement_type.statement_type,StatementStructure::RETURN_STATEMENT)
-    
-  end
-  
-  def test_replace_variable_if
-    
-    # Create a simple statement will have it's variable replaced
-    # unknown = 7
-    statement_a_unknown = Unknown.new
-    statement_a = Statement.new(statement_a_unknown,Equal.new,7.to_literal)      
-    assert(statement_a.first.kind_of?(Unknown))
-    modified_statement_a = statement_a.replace_variable_if(FixnumVariable.new(7)) {|x| x.uniq_id == statement_a_unknown.uniq_id }
-    assert(modified_statement_a.first.kind_of?(FixnumVariable))
-    
-    # Create a statement with an instance call container 
-    # unknown = 'test'.chop
-    statement_b_unknown = Unknown.new
-    statement_b = Statement.new(Unknown.new,Equal.new,InstanceCallContainer.new(statement_b_unknown,Chop.new))    
-    modified_statement_b = statement_b.replace_variable_if('test'.to_var) do |x|
-      x.uniq_id  == statement_b_unknown.uniq_id
-    end
-    assert(modified_statement_b.kind_of?(Statement))
-    assert_equal(3,modified_statement_b.length)    
-    assert_not_equal(modified_statement_b[2].subject.variable_id,statement_b_unknown.variable_id)
-    
-    # Create a statement with parameters in the statement
-    # ['goo'].push('jon')
-    statement_c_unknown = Unknown.new
-    statement_c = Statement.new(InstanceCallContainer.new(['goo'].to_var,Push.new,statement_c_unknown))
-    modified_statement_c = statement_c.replace_variable_if('jon'.to_var) do |x|
-      x.uniq_id == statement_c_unknown.uniq_id
-    end
-    assert(modified_statement_c.kind_of?(Statement))  
-    assert_not_equal(modified_statement_c[0][0].uniq_id,statement_c_unknown.uniq_id)
-
-    # Create a statement with no matches
-    # unknown = 5 + 6
-    statement_d = Statement.new(Unknown.new,Equal.new,5.to_var,Addition.new,6.to_var)
-    modified_statement_d = statement_d.replace_variable_if('jon'.to_var) do |x|
-      x.uniq_id == 21312
-    end    
-    assert_equal(statement_d.write,modified_statement_d.write)
-    
-    # Create an instance call statement with no matches
-    # unknown = var_a.length
-    statement_e = Statement.new(Unknown.new,Equal.new,InstanceCallContainer.new('richardson'.to_var,StringLength.new))
-    modified_statement_e = statement_e.replace_variable_if('jon'.to_var) do |x|
-      if x.uniq_id == 3242
-        next true
-      end
-      false
-    end
-    assert_equal(statement_e.write,modified_statement_e.write)
-      
-  end
-  
   def test_find_actual_variable
     
     # 1.  Check that the actual variable is returned from a statement
@@ -535,29 +413,6 @@ class TestStatement < Test::Unit::TestCase
     
   end
   
-  def test_exchange_variables
-    
-    # Create a statement that includes a method variable and is replaced by a different variable
-    method_variable_1 = MethodParameter.new
-    unknown_variable_1 = Unknown.new
-    statement_1 = Statement.new(unknown_variable_1,Equal.new,InstanceCallContainer.new(method_variable_1,Chop.new))      
-    pip = 'pip'.to_var
-    conversions = Hash.new()
-    conversions[method_variable_1.variable_id.to_s.to_sym] = pip.copy
-    assert(statement_1.exchange_variables(conversions).kind_of?(Statement))    
-    assert_nothing_raised(){statement_1.exchange_variables(conversions).to_literal_string}
-    assert_equal(
-      'var_'+unknown_variable_1.variable_id.to_s+' = var_'+pip.variable_id.to_s+'.chop',
-      statement_1.exchange_variables(conversions).write
-    )
-    
-    # Create a statement that modifies an existing variable.
-    
-    
-    # TODO  Test with the same variable used twice in a statement e.g. var_a = var_b+var_b
-      
-  end
-  
   def test_creates_variable?
     
     # Check that a declaration statement creates a variable