cauldron 0.1.0 → 0.1.1

data/test/tc_describe.rb

@@ -18,8 +18,7 @@ System.reset
   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)
+    method_variable = MethodParameter.new
     
 #    # Create runtime method with one parameter ('test')
 #    runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))

data/test/tc_method.rb

@@ -12,7 +12,7 @@ class TestMethod < Test::Unit::TestCase
     @simple_method_usage = MethodUsage.new()
     
     # Create the simple runtime method
-    @simple_method = RuntimeMethod.new(@simple_method_usage)
+    @simple_method = RuntimeMethod.new(@simple_method_usage,0)
     
     # Create the usage for a method with two paramters
     param_1 = MethodParameter.new
@@ -20,9 +20,6 @@ class TestMethod < Test::Unit::TestCase
     
     # 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
   
@@ -81,7 +78,7 @@ class TestMethod < Test::Unit::TestCase
     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')))
+    param_values = MethodParameter.new
     #original_method.parameters = [param_values]
     
     # Check the number of paramaters

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

@@ -1,3 +1,5 @@
+$LOAD_PATH << File.expand_path('../../../../../lib',__FILE__)
+
 require 'required'
 require 'test/unit'
 
@@ -6,9 +8,9 @@ class TestRealisedRuntimeMethod < Test::Unit::TestCase
   def setup
     
     # Create the method usage 
-    @method_var_a = MethodParameter.new(Requirement.new(InstanceCallContainer.new(This.new,ClassCall.new),Equivalent.new,StringClass.new))
+    @method_var_a = MethodParameter.new
     # Not used in the method
-    @method_var_b = MethodParameter.new(Requirement.new(InstanceCallContainer.new(This.new,ClassCall.new),Equivalent.new,StringClass.new))
+    @method_var_b = MethodParameter.new
     @single_parameter_usage = MethodUsage.new(@method_var_a,@method_var_b)
     
     # Create the simple method used in the tests
@@ -96,7 +98,7 @@ class TestRealisedRuntimeMethod < Test::Unit::TestCase
       firefox = 'firefox'.to_declared_variable_statement
       statement_with_open_statement.push(firefox)
       firefox_var = firefox.declared_variable
-      if_statement = Statement.new(IfContainer.new(InstanceCallContainer.new(firefox_var,StringLength.new),Equivalent.new,7.to_literal))
+      if_statement = Statement.new(If.new,Container.new(InstanceCallContainer.new(firefox_var,StringLength.new),Equivalent.new,7.to_literal))
       open_if_statement = OpenStatement.new(if_statement)
       open_if_statement.push('IE'.to_declared_variable_statement)
       statement_with_open_statement.push(open_if_statement)

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

@@ -1,3 +1,5 @@
+$LOAD_PATH << File.expand_path('../../../../../lib',__FILE__)
+
 require 'required'
 require 'test/unit'
 
@@ -6,9 +8,9 @@ class TestRuntimeMethod < Test::Unit::TestCase
   def setup
     
     # Create the method usage 
-    @method_var_a = MethodParameter.new(Requirement.new(InstanceCallContainer.new(This.new,ClassCall.new),Equivalent.new,StringClass.new))
+    @method_var_a = MethodParameter.new
     # Not used in the method
-    @method_var_b = MethodParameter.new(Requirement.new(InstanceCallContainer.new(This.new,ClassCall.new),Equivalent.new,StringClass.new))
+    @method_var_b = MethodParameter.new
     @single_parameter_usage = MethodUsage.new(@method_var_a,@method_var_b)
     
     # Create the simple method used in the tests
@@ -34,7 +36,7 @@ class TestRuntimeMethod < Test::Unit::TestCase
     @method_b = RuntimeMethod.new(MethodUsage.new)
     
     # Create a method that accepts one string parameter and some string parameters to use
-    @method_c = RuntimeMethod.new(MethodUsage.new(MethodParameter.new(Requirement.new(InstanceCallContainer.new(This.new,ClassCall.new),Equivalent.new,StringClass.new))))
+    @method_c = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))
     @var_g = 'Monkey'.to_var
     @var_h = 'Island'.to_var   
     @var_i = '3'.to_var
@@ -45,12 +47,12 @@ class TestRuntimeMethod < Test::Unit::TestCase
     @method_d = RuntimeMethod.new(MethodUsage.new(),@method_respnse_a)
     
     # Create a method that excepts two string parameters
-    @method_usage_var_b = MethodParameter.new(Requirement.new(InstanceCallContainer.new(This.new,ClassCall.new),Equivalent.new,StringClass.new))
-    @method_usage_var_c = MethodParameter.new(Requirement.new(InstanceCallContainer.new(This.new,ClassCall.new),Equivalent.new,StringClass.new))
+    @method_usage_var_b = MethodParameter.new()
+    @method_usage_var_c = MethodParameter.new()
     @method_e = RuntimeMethod.new(MethodUsage.new(@method_usage_var_b,@method_usage_var_c))
     
-    @method_usage_var_e = MethodParameter.new(Requirement.new(InstanceCallContainer.new(This.new,ClassCall.new),Equivalent.new,StringClass.new))
-    @method_usage_var_f = MethodParameter.new(Requirement.new(InstanceCallContainer.new(This.new,ClassCall.new),Equivalent.new,StringClass.new))
+    @method_usage_var_e = MethodParameter.new()
+    @method_usage_var_f = MethodParameter.new()
     @method_respnse_b = 'Halo'.to_var
     @method_f = RuntimeMethod.new(MethodUsage.new(@method_usage_var_e,@method_usage_var_f),@method_respnse_b)
     
@@ -169,7 +171,13 @@ class TestRuntimeMethod < Test::Unit::TestCase
     # Check that each of the variables has the correct evaluated value
     local_var_a = 'test'.to_var
     local_var_b = 'LividKel'.to_var
-    assert_equal(local_var_a.value,@simple_method.literal_value_of_var(@method_var_a.variable_id,ParametersContainer.new(local_var_a,local_var_b)))        
+    assert_equal(
+      local_var_a.value,
+      @simple_method.literal_value_of_var(
+        @method_var_a.variable_id,
+        ParametersContainer.new(local_var_a,local_var_b)
+      )
+    )        
     assert_equal(9,@simple_method.literal_value_of_var(@var_b.variable_id,ParametersContainer.new(local_var_a,local_var_b)))        
     assert_equal(local_var_a.value.clone.chop,@simple_method.literal_value_of_var(@var_c.variable_id,ParametersContainer.new(local_var_a,local_var_b)))            
     assert_equal(local_var_a.value.clone.chop.length,@simple_method.literal_value_of_var(@var_d.variable_id,ParametersContainer.new(local_var_a,local_var_b)))            
@@ -200,24 +208,6 @@ class TestRuntimeMethod < Test::Unit::TestCase
     assert_equal(9,@method_e.callable_combinations([@var_g,@var_h,@var_i]).length)                      
 
   end
-
-  # Tests the method that converts any runtime method instances to def_calls
-  # using the other variables available to it.
-  #
-  def test_convert_methods_to_def_calls
-   
-    # Check that when there are no runtime methdods just the supplied variables are returned
-    assert_equal(2,@method_c.send(:convert_methods_to_def_calls,[@var_g,@var_h]).length)      
-    
-    # Check that a single runtime method is converted to a def_call
-    assert(@method_c.send(:convert_methods_to_def_calls,[@method_d]).last.kind_of?(DefCall))      
-    
-    # Check that method_f (excepts two parameters) gets changed into 4 different def_calls
-    # 2 = both variables
-    # 4 = @method_f using both variables in different combinations
-    assert_equal(6,@method_c.send(:convert_methods_to_def_calls,[@var_g,@var_h,@method_f]).length)      
-    
-  end
   
   # TODO  Need to test with methods that require parameters (var_a) etc
   def test_history                                      
@@ -228,7 +218,7 @@ class TestRuntimeMethod < Test::Unit::TestCase
     
     # Check that history retains the correct variable ids
     manny = 'Manny'.to_var
-    string_runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new('Manny'.to_requirement)),nil)   
+    string_runtime_method = RuntimeMethod.new(MethodUsage.new(),nil)   
     
     # Add a statement to the runtime method
     manny_length_var = Unknown.new
@@ -274,7 +264,7 @@ class TestRuntimeMethod < Test::Unit::TestCase
   def test_trackify
     
     # Create a simple method to be trackified
-    manny = MethodParameter.new(Requirement.new(This.new,Equivalent.new,'Manny'.to_literal))
+    manny = MethodParameter.new()
     string_runtime_method = RuntimeMethod.new(MethodUsage.new(manny),nil)
     
     # Add a statement to the runtime method
@@ -339,11 +329,9 @@ class TestRuntimeMethod < Test::Unit::TestCase
   def test_realise
     
     # Create a simple runtime method and check that the paramaters are valid
-    var_a = MethodParameter.new('Grim'.to_requirement)
-    var_b = MethodParameter.new('fandango'.to_requirement)        
-    var_g = MethodParameter.new(
-      Requirement.new(InstanceCallContainer.new(This.new,ClassCall.new),Equivalent.new,ArrayClass.new)
-    )
+    var_a = MethodParameter.new
+    var_b = MethodParameter.new        
+    var_g = MethodParameter.new
     simple_method = RuntimeMethod.new(MethodUsage.new(var_a,var_b,var_g))
     
     # Check that realise returns an identical runtime method
@@ -370,7 +358,7 @@ class TestRuntimeMethod < Test::Unit::TestCase
     assert_not_equal(true,realised_instance_1.available_variables(ParametersContainer.new(var_a_value,var_b_value,var_g_value)).any? {|x| x.value == 'WARREN' })
     
     # Check that invalid paramters and undeclared parameters are caught
-    temp_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new(Requirement.new(InstanceCallContainer.new(This.new,ClassCall.new),Equivalent.new,StringClass.new))))
+    temp_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))
     assert_raises(StandardError) {temp_method.realise2([])}
     
     # Now let's add a few statements to the method
@@ -381,7 +369,7 @@ class TestRuntimeMethod < Test::Unit::TestCase
     assert_equal(
       "\n#\n#\t@param\t[StringVariable] 'Grim'\n#\t@param\t[StringVariable] 'fandango'\n#\t@param\t[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_58 = var_33.length\nend\n",
+      "\n\tvar_64 = var_35.length\nend\n",
       realised_instance_2.write
     )
     
@@ -395,7 +383,7 @@ class TestRuntimeMethod < Test::Unit::TestCase
       "#\t@param\t[StringVariable] 'fandango'\n"\
       "#\t@param\t[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_58 = var_#{simple_method.usage[0].variable_id}.length\n\tvar_68 = var_#{simple_method.usage[0].variable_id}.chop\nend\n",
+      "\tvar_64 = var_#{simple_method.usage[0].variable_id}.length\n\tvar_76 = var_#{simple_method.usage[0].variable_id}.chop\nend\n",
       realised_simple_method_3.write
     )
     
@@ -414,7 +402,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_33, var_34, var_35)\n\tvar_58 = var_33.length\n\tvar_68 = var_33.chop\n\tvar_79 = var_34.length\n\tvar_80 = var_79  + var_58\nend\n",
+      "\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",
       realised_simple_method_4.write
     )
     
@@ -459,44 +447,34 @@ class TestRuntimeMethod < Test::Unit::TestCase
     
   end
   
-#  def test_realise_when_it_contains_a_method_variable
-#  
-#    runtime_method = RuntimeMethod.new(MethodUsage.new)
-#    runtime_method << Statement.new(Unknown.new,Equal.new,ClassMethodCallContainer.new(MethodParameterClass.new,New.new))
-#    assert_nothing_raised(runtime_method.realise2(ParametersContainer.new))
-#    
-#  end
-  
   # Test that the runtime methods are written properly.  
   #
   def test_write
 
     # Create a simple method with no paramaters
     method_example_a = RuntimeMethod.new(MethodUsage.new)       
-    assert_equal("\n#\n#\ndef method_#{method_example_a.method_id.to_s}\n\nend\n",method_example_a.write(nil))
+    assert_equal("\n#\n#\ndef method_#{method_example_a.method_id.to_s}\nend\n",method_example_a.write(nil))
     
     # Test a simple method with one paramter
     #param_1 = StringVariable.new('Girm')
-    param_1 = MethodParameter.new(Requirement.new(This.new,Equivalent.new,'Grim'.to_literal))
+    param_1 = MethodParameter.new
     method_example_b = RuntimeMethod.new(MethodUsage.new(param_1))
     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_7\n\tvar_26 = ''\n\tvar_27 = 'x'\n\t3.times do |var_28|\n\t\tvar_26 = var_26  + var_27\n\tend\n\nend\n",@build_xxx_method.write)  
+    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)  
     
     # Test how the method is written with tabs
-    assert_equal("\n\t#\n\t#\n\tdef method_7\n\t\tvar_26 = ''\n\t\tvar_27 = 'x'\n\t\t3.times do |var_28|\n\t\t\tvar_26 = var_26  + var_27\n\t\tend\n\n\tend\n",@build_xxx_method.write(nil,1))      
-    
-    # TODO  Test write with passed in parameters         
+    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))      
+         
   end
   
   def test_push
     
     # Create a method that is passed a string
     #manny = 'Manny'.to_var
-    manny = MethodParameter.new('Manny'.to_requirement)
-    string_runtime_method = RuntimeMethod.new(MethodUsage.new(manny),nil)
-    #string_runtime_method.parameters = [manny]    
+    manny = MethodParameter.new
+    string_runtime_method = RuntimeMethod.new(MethodUsage.new(manny),nil)    
     
     manny_length_var = Unknown.new
     a_equals_manny_length = Statement.new(manny_length_var,Equal.new,InstanceCallContainer.new(manny_length_var,StringLength.new))
@@ -518,7 +496,7 @@ class TestRuntimeMethod < Test::Unit::TestCase
     #   end
     # end
     string_runtime_method = RuntimeMethod.new(
-      MethodUsage.new(MethodParameter.new(Requirement.new(This.new,Equivalent.new,'Manny'.to_literal))),nil
+      MethodUsage.new(MethodParameter.new),nil
     )
     
     manny_length_var = Unknown.new
@@ -569,7 +547,7 @@ class TestRuntimeMethod < Test::Unit::TestCase
     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('test'.to_requirement)),nil)        
+    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

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

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

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

@@ -1,3 +1,5 @@
+$LOAD_PATH << File.expand_path('../../../../../lib',__FILE__)
+
 require 'required'
 require 'test/unit'
 
@@ -7,7 +9,7 @@ class TestOpenStatement < Test::Unit::TestCase
     
     # Create a simple open if statement
     @simple_if_statement_var = Unknown.new
-    simple_if_statement = Statement.new(If.new,@simple_if_statement_var,Equivalent.new,'Stobart'.to_literal)
+    simple_if_statement = Statement.new(If.new,Container.new(@simple_if_statement_var,Equivalent.new,'Stobart'.to_literal))
     @simple_open_if_statement = OpenStatement.new(simple_if_statement)
     
     # Create a simple open statement with variables
@@ -31,11 +33,11 @@ class TestOpenStatement < Test::Unit::TestCase
   def test_write  
     
     # Test the simple statement is written out properly
-    assert_equal("if #{@simple_if_statement_var.write} == 'Stobart'\nend" ,@simple_open_if_statement.write)
+    assert_equal("if(#{@simple_if_statement_var.write} == 'Stobart')\nend" ,@simple_open_if_statement.write)
     
     # 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\treturn true\nend" ,@simple_open_if_statement.write)
     
   end
   
@@ -55,9 +57,16 @@ class TestOpenStatement < Test::Unit::TestCase
     # Test copy with an open theory statement
     # TODO  This is quite a good way to test copy - I should use it across the other main classes
     initial_theory = StringToTheory.run("if(var1.length = var2.length)\nend")
-    original_element_ids = initial_theory.select_all{true}.collect {|x| x.object_id}
-    copied_elements_ids = initial_theory.copy.select_all{true}.collect {|x| x.object_id}
-    assert_equal(initial_theory.select_all{true}.length*2,(copied_elements_ids + original_element_ids).uniq.length)
+    # => TODO uniq shouldn't be needed - why is it selecting the same value 
+    original_element_ids = initial_theory.select_all{true}.collect {|x| x.object_id}.uniq
+    
+    copied_theory = initial_theory.copy
+    copied_elements_ids = copied_theory.select_all{true}.collect {|x| x.object_id}.uniq
+
+    assert_equal(
+      original_element_ids.length*2,
+      (copied_elements_ids + original_element_ids).uniq.length
+    )
   end
   
   def test_write_structure_with_simple_examples

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

@@ -1,3 +1,5 @@
+$LOAD_PATH << File.expand_path('../../../../../lib',__FILE__)
+
 require 'required'
 require 'test/unit'
 
@@ -128,10 +130,7 @@ class TestStatement < Test::Unit::TestCase
   def test_variable_subst
    
     # Create the substitute variable (the one to replace the current one) self.class = String
-    class_req = Requirement.new(InstanceCallContainer.new(This.new,ClassCall.new),Equal.new,StringClass.new)
-    # TODO  If this is 8 it still works - it should raise an exception since it is a conflict
-    string_value_req = Requirement.new(This.new,Equal.new,Literal.new('tests'))
-    subst_variable = MethodParameter.new(class_req)
+    subst_variable = MethodParameter.new
 
     # Create the variable to be replaced self.class = String
     replacable_variable = Unknown.new
@@ -404,7 +403,7 @@ class TestStatement < Test::Unit::TestCase
     
     #   c.  Retrieve the history instance for the runtime method
     history_2 = runtime_method_2.history(ParametersContainer.new,[calling_runtime_method_2])
-
+    
     assert_equal(true,statement_2.realise2(history_2).find_variable(unknown_variable_2.variable_id).kind_of?(StringVariable))
     assert_equal('sparky',statement_2.realise2(history_2).find_variable(unknown_variable_2.variable_id).value)
 

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

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

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

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

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

@@ -8,18 +8,18 @@ class TestIfContainer < Test::Unit::TestCase
   end
   
   def teardown
-System.reset
+    System.reset
     RuntimeMethod.reset_global_id
   end  
 
   def test_write
     
     # 1.  if(true)
-    assert_equal('if(true)',IfContainer.new(True.new).write)
+    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 = IfContainer.new(unknown_variable_2,Equivalent.new,Literal.new('test'))
+    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  
@@ -27,11 +27,11 @@ System.reset
   def test_copy
     
     # 1.  Check copy works if(true)
-    assert_equal(IfContainer.new(True.new).write,IfContainer.new(True.new).copy.write)
+    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 = IfContainer.new(unknown_variable_2,Equivalent.new,Literal.new('test'))
+    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

data/test/unit/core/tc_theory_generator_heavy.rb

@@ -34,7 +34,7 @@ class TestTheoryGenerator < Test::Unit::TestCase
     assert_equal(
       true,
       theories.any? do |x|
-        x.write == '<runtime_method>.add_statement_at(OpenStatement.new(IfContainer.new(var1.params[var5], Equivalent.new, var2[var3][:params][var5])),var1.statement_id)'
+        x.write == '<runtime_method>.add_statement_at(OpenStatement.new(Statement.new(If.new,Container.new(var1.params[var5], Equivalent.new, var2[var3][:params][var5]))),var1.statement_id)'
       end
     )
   end

data/test/unit/core/tracking/tc_history.rb

@@ -1,3 +1,5 @@
+$LOAD_PATH << File.expand_path('../../../../../lib',__FILE__)
+
 require 'required'
 require 'test/unit'
 
@@ -9,7 +11,7 @@ class TestHistory < Test::Unit::TestCase
     @simple_runtime_method = RuntimeMethod.new(MethodUsage.new,nil.to_var)        
     
     # Create a method that is passed a string
-    @grim_fandango_method_var = MethodParameter.new('Grim Fandango'.to_requirement)
+    @grim_fandango_method_var = MethodParameter.new
     @grim_fandango = 'Grim Fandango'.to_var(@grim_fandango_method_var.variable_id)
     @string_runtime_method = RuntimeMethod.new(MethodUsage.new(@grim_fandango_method_var),nil)
         

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

@@ -12,11 +12,11 @@ class TestMethodParameterVariable < Test::Unit::TestCase
   end  
 
   def test_initialize
-    assert_nothing_raised(){MethodParameter.new('Grim'.to_requirement)}
+    assert_nothing_raised(){MethodParameter.new}
   end
   
   def test_initialize_variable_id_is_created
-    assert(MethodParameter.new('Grim'.to_requirement).variable_id.kind_of?(Fixnum))
+    assert(MethodParameter.new.variable_id.kind_of?(Fixnum))
   end
       
 end