cauldron 0.1.0

data/test/unit/core/tc_theory_generator_heavy.rb

@@ -0,0 +1,42 @@
+require 'required'
+require 'test/unit'
+
+class TestTheoryGenerator < Test::Unit::TestCase
+  
+  def setup
+
+    test_case_1 = CTestCase.new 
+    test_case_1[:params] = ['something']
+    test_case_1[:output] = 'exists'
+    test_case_2 = CTestCase.new
+    test_case_2[:params] = ['my willpower']
+    test_case_2[:output] = 'does not exist'
+    @set_1_test_cases = [
+      test_case_1,test_case_2
+    ]
+    @runtime_method = RuntimeMethod.new(MethodUsage.new(MethodParameter.new))    
+    
+  end
+  
+  def teardown
+    System.reset
+    RuntimeMethod.reset_global_id
+  end  
+  
+  # Checks that the first statement "if(var == 'my willpower')" can be generated
+  # 
+  # test time: 37mins
+  #
+  def test_generate_theories_with_case_1_statement_1
+    
+    accessors, mapping = TheoryGenerator.new.generate_accessors_and_mapping(@set_1_test_cases,@runtime_method,3)
+    theories = TheoryGenerator.new.generate_theories(@set_1_test_cases,@runtime_method,accessors,mapping)    
+    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)'
+      end
+    )
+  end
+      
+end

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

@@ -0,0 +1,102 @@
+require 'required'
+require 'test/unit'
+
+class TestHistory < Test::Unit::TestCase
+  
+  def setup
+    
+    # Create the initial runtime method instance for testing
+    @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 = 'Grim Fandango'.to_var(@grim_fandango_method_var.variable_id)
+    @string_runtime_method = RuntimeMethod.new(MethodUsage.new(@grim_fandango_method_var),nil)
+        
+  end
+  
+  def teardown
+    System.reset
+    RuntimeMethod.reset_global_id
+  end  
+  
+  def test_initialize
+    
+  end
+  
+  def test_find_steps_with_variable
+
+    # Add 'var_b = var_a.chop'
+    b_equals_A_chop = Statement.new(Unknown.new,Equal.new,InstanceCallContainer.new(@grim_fandango_method_var,Chop.new))    
+    @string_runtime_method.push(b_equals_A_chop)
+    assert_equal(
+      2,
+      @string_runtime_method.history([@grim_fandango]).find_steps_with_variable(
+        @grim_fandango_method_var.variable_id
+      ).length
+    )
+    assert_equal(1,@string_runtime_method.history(ParametersContainer.new(@grim_fandango)).find_steps_with_variable(b_equals_A_chop.declared_variable_id).length)    
+    
+  end
+
+# ================= CUSTOM ====================
+
+  def test_history_call_through_runtime_method
+    
+    # Check that a essentially empty history object is returned
+    assert(@simple_runtime_method.history(ParametersContainer.new).kind_of?(History))
+    
+    # Check that a runtime method that includes a string returns properly
+    assert(@string_runtime_method.history(ParametersContainer.new(@grim_fandango)).kind_of?(History))
+    assert_equal(1,@string_runtime_method.history(ParametersContainer.new(@grim_fandango)).length)
+    
+    # Add 'var_b = var_a.chop'
+    b = Unknown.new
+    b_equals_A_chop = Statement.new(b,Equal.new,InstanceCallContainer.new(@grim_fandango_method_var,Chop.new))
+    @string_runtime_method.push(b_equals_A_chop)
+    after_one_statement = @string_runtime_method.history(ParametersContainer.new(@grim_fandango))
+    assert_equal(2,after_one_statement.length)
+    
+    # Check that the correct number of variables are retained at each stage  
+    assert_equal(1,after_one_statement[0]['variables'].length)
+    assert_equal(2,after_one_statement[1]['variables'].length)    
+    
+    # Check that the variable has the correct id
+    assert_equal(true,after_one_statement[1]['variables'].any? {|x| x['id']== b_equals_A_chop.declared_variable_id})
+    
+    # Confirm that all the saved variables have the correct ids
+    found_steps = after_one_statement.find_steps_with_variable(@grim_fandango.variable_id)
+    found_steps.each do |x|
+      found_steps.each do |y| 
+        assert_equal(x.find_data_for_variable(@grim_fandango.variable_id)['abs_id'],y.find_data_for_variable(@grim_fandango.variable_id)['abs_id'])  
+      end
+    end    
+    
+    # Add a length statement
+    c = Unknown.new
+    c_equals_a_length = Statement.new(c,Equal.new,InstanceCallContainer.new(b,StringLength.new))
+    @string_runtime_method.push(c_equals_a_length)
+    
+    # Confirm that there are now 3 steps in the history
+    assert_equal(3,@string_runtime_method.history(ParametersContainer.new(@grim_fandango)).length)
+    
+    # Add the first nested statement to the method.
+    c_times = Statement.new(InstanceCallContainer.new(c,Times.new))
+    c_time_do = BlockStatement.new(c_times)     
+    @string_runtime_method.push(c_time_do)     
+
+    # Confirm that each part of the statement is tracked
+    assert_equal(16,@string_runtime_method.history(ParametersContainer.new(@grim_fandango)).length) 
+    
+  end
+  
+  def test_history_call_through_runtime_method_using_complex_method      
+        
+    # Add a length statement
+    c = Unknown.new
+    c_equals_a_length = Statement.new(c,Equal.new,InstanceCallContainer.new(@grim_fandango,StringLength.new))
+    @string_runtime_method.push(c_equals_a_length)
+    
+  end
+      
+end

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

@@ -0,0 +1,65 @@
+require 'required'
+require 'test/unit'
+
+class TestStep < Test::Unit::TestCase
+  
+  def setup
+    #   "variables"=>[
+    #     {"id"=>3, "value"=>"Grim Fandang", "abs_id"=>-606538658, :uniq_id=>3}, 
+    #     {"id"=>1, "value"=>"Grim Fandango", "abs_id"=>-606538498, :uniq_id=>2}
+    #   ], 
+    #   "line"=>1, 
+    #   "statement_id"=>625, 
+    #   "action"=>"var='Grim Fandango'.chop"}
+    @basic_step = Step.new(
+      1,
+      625,
+      [ {"id"=>3, "value"=>"Grim Fandang", "abs_id"=>-606538658, :uniq_id=>3}, 
+        {"id"=>1, "value"=>"Grim Fandango", "abs_id"=>-606538498, :uniq_id=>2}],
+      "var='Grim Fandango'.chop"
+    )            
+            
+  end
+  
+  def teardown
+    System.reset
+  end  
+  
+  def test_initialize
+    assert_nothing_raised(){
+      basic_step = Step.new(
+        1,
+        625,
+        [ {"id"=>3, "value"=>"Grim Fandang", "abs_id"=>-606538658, :uniq_id=>3}, 
+          {"id"=>1, "value"=>"Grim Fandango", "abs_id"=>-606538498, :uniq_id=>2}],
+        "var='Grim Fandango'.chop"
+      )     
+    }
+  end
+  
+  def test_find_data_for_variable
+
+  end
+
+  def test_to_var
+    assert_nothing_raised(){@basic_step.to_var}
+    assert_kind_of(StepVariable,@basic_step.to_var)
+  end
+       
+  def test_copy
+    assert_nothing_raised(){@basic_step.copy}
+    assert_equal(
+      @basic_step['line'],
+      @basic_step.copy['line']
+    )
+    assert_equal(
+      @basic_step['variables'][0]['abs_id'],
+      @basic_step.copy['variables'][0]['abs_id']
+    )
+    assert_equal(
+      @basic_step['variables'][1]['abs_id'],
+      @basic_step.copy['variables'][1]['abs_id']
+    )        
+  end
+
+end

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

@@ -0,0 +1,61 @@
+require 'required'
+require 'test/unit'
+
+class TestArrayVariable < Test::Unit::TestCase
+  
+  def setup
+    @animals = ['spider','bear','rat'].to_var    
+    @games = ['Grim Fandango','Fallout'].to_var
+    @games.instance_variable = true
+  end
+  
+  def teardown
+    System.reset
+  end  
+
+  def test_to_declaration
+    assert(@animals.to_declaration.kind_of?(VariableDeclaration))
+    assert_not_nil(@animals.to_declaration.write,'Should write out command to create array variable')
+  end
+  
+  def test_initialize
+    assert_equal(3,@animals.length)
+  end
+  
+  def test_literalise
+    assert(@animals.literalise.value.instance_of?(Array))
+    assert_equal(3,@animals.literalise.value.length)    
+    assert_equal('spider',@animals.literalise.value.first)        
+  end
+  
+  def test_copy
+    assert_equal(@animals.length,@animals.copy.length) 
+    assert_equal(@animals.variable_id,@animals.copy.variable_id)     
+    assert_equal(@animals.first,@animals.copy.first)         
+    assert_equal('@var_'+@games.variable_id.to_s,@games.copy.write)         
+    assert_not_nil(@animals.uniq_id)
+    assert_equal(@animals.uniq_id,@animals.copy.uniq_id)
+  end
+  
+  # Find the following access calls for the array .length [0],[1],[2]
+  def test_instance_calls
+    assert_equal(4,@animals.instance_calls.length) 
+    assert_equal(4,@animals.instance_calls.find_all {|x| x.kind_of?(InstanceCallContainer)}.length)     
+    assert_equal(3,@animals.instance_calls.find_all {|x| x.kind_of?(ArrayAccess)}.length)         
+  end
+  
+  def test_write
+    assert_equal('var_'+@animals.variable_id.to_s,@animals.write)
+    assert_equal('@var_'+@games.variable_id.to_s,@games.write)
+  end
+  
+  def test_instance_variable
+    tmp = ['bad','science'].to_var
+    assert_equal(false,tmp.instance_variable)
+    tmp.instance_variable = true
+    assert_equal(true,tmp.instance_variable)
+    assert_equal(false,@animals.instance_variable)
+    assert_equal(true,@games.instance_variable)    
+  end
+      
+end

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

@@ -0,0 +1,17 @@
+require 'required'
+require 'test/unit'
+
+class TestBlockVariable < Test::Unit::TestCase
+  
+  def setup
+  end
+  
+  def teardown
+    System.reset
+  end  
+  
+  def test_copy
+    
+  end
+          
+end

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

@@ -0,0 +1,54 @@
+require 'required'
+require 'test/unit'
+
+class TestFixnumVariable < Test::Unit::TestCase
+  
+  def setup
+    
+    # Create a simple fixnum for testing
+    @var_8 = FixnumVariable.new(8)
+    
+  end
+  
+  def teardown
+    System.reset
+  end  
+
+  def test_copy
+    
+    # Test a simple fixnum example cap be copied 
+    assert_nothing_raised(){@var_8.copy}    
+    assert_equal(@var_8.variable_id,@var_8.copy.variable_id)
+    assert_not_nil(@var_8.uniq_id)
+    assert_equal(@var_8.uniq_id,@var_8.copy.uniq_id)    
+    
+  end
+  
+  def test_variable_id=
+    
+    # Checks that non fixnum instances can edit the variable id
+    assert_nothing_raised(){@var_8.variable_id = 3}
+    
+  end  
+  
+  # Checks that the description is written correctly.  It should contain
+  # a newline character at the end because the description will probably
+  # require an each_line call made to it.
+  #
+  def test_describe
+    assert_equal("[FixnumVariable] 8\n",@var_8.describe)
+  end
+  
+  # Check the instance calls a single fixnum variable can create.  Currently
+  # there aren't any but that might change.
+  #
+  def test_instance_calls
+    assert_equal(0,@var_8.instance_calls().length)
+  end
+  
+  def test_to_declaration
+    assert_nothing_raised() {@var_8.to_declaration}
+    assert_equal('FixnumVariable.new(8)',@var_8.to_declaration.write)
+  end
+  
+end

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

@@ -0,0 +1,22 @@
+require 'required'
+require 'test/unit'
+
+class TestMethodParameterVariable < Test::Unit::TestCase
+  
+  def setup
+  end
+  
+  def teardown
+    System.reset
+    RuntimeMethod.reset_global_id
+  end  
+
+  def test_initialize
+    assert_nothing_raised(){MethodParameter.new('Grim'.to_requirement)}
+  end
+  
+  def test_initialize_variable_id_is_created
+    assert(MethodParameter.new('Grim'.to_requirement).variable_id.kind_of?(Fixnum))
+  end
+      
+end

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

@@ -0,0 +1,32 @@
+require 'required'
+require 'test/unit'
+
+class TestRuntimeMethodParameter < Test::Unit::TestCase
+  
+  def setup
+    
+    # Create a simple runtime method instance for testing
+    @empty_runtime_method = RuntimeMethod.new(MethodUsage.new).to_var
+    
+  end
+  
+  def teardown
+    System.reset
+  end  
+  
+  def test_copy
+    assert_equal(@empty_runtime_method.copy.variable_id,@empty_runtime_method.variable_id)
+    assert_equal(@empty_runtime_method.copy.uniq_id,@empty_runtime_method.uniq_id)        
+  end
+  
+  def test_instance_calls
+    
+    # Check that a .push instance call can be created
+    statement_var = Statement.new().to_var
+    possible_instance_calls = @empty_runtime_method.instance_calls([statement_var])
+    assert_equal(1,possible_instance_calls.length)
+    assert_equal(@empty_runtime_method.write+'.push('+statement_var.write+')',possible_instance_calls.first.write)
+
+  end
+  
+end

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

@@ -0,0 +1,37 @@
+require 'required'
+require 'test/unit'
+
+class TestStringVariable < Test::Unit::TestCase
+  
+  def setup
+    
+    # Create a simple fixnum for testing
+    @var_manny = StringVariable.new('manny')
+
+  end
+  
+  def teardown
+System.reset
+    RuntimeMethod.reset_global_id
+  end  
+
+  def test_copy
+    
+    # Test a simple fixnum example cap be copied 
+    assert_nothing_raised(){@var_manny.copy}    
+    assert_equal(@var_manny.variable_id,@var_manny.copy.variable_id)
+    
+  end
+  
+  # 
+  def test_instance_calls
+    
+    # Confirm the datatype of all the returned elements in an array
+    assert(@var_manny.instance_calls.kind_of?(Array))
+    @var_manny.instance_calls.each do |instance_call|
+      assert(instance_call.kind_of?(InstanceCallContainer))
+    end
+    
+  end
+  
+end

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

@@ -0,0 +1,24 @@
+require 'required'
+require 'test/unit'
+
+class TestUnknown < Test::Unit::TestCase
+  
+  def setup
+  
+  end
+  
+  def teardown
+    System.reset
+  end  
+  
+  def test_initialize
+  end
+  
+  # 
+  def test_to_var
+    assert_nothing_raised(){Unknown.new.to_var}
+    assert_equal(89,Unknown.new.to_var(89).variable_id)
+    assert_equal(99,Unknown.new.to_var(89,99).uniq_id)    
+  end
+  
+end