ruby2c 1.0.0.9 → 1.1.0

data/test/test_function_table.rb

@@ -3,74 +3,74 @@
 $TESTING = true
 
 require 'minitest/autorun' if $0 == __FILE__
-require 'minitest/unit'
+require 'minitest/test'
 require 'function_table'
 require 'type'
 
-class TestFunctionTable < MiniTest::Unit::TestCase
+class TestFunctionTable < Minitest::Test
 
   def setup
     @function_table = FunctionTable.new
   end
 
   def test_add_function
-    type = @function_table.add_function :func, Type.long
+    type = @function_table.add_function :func, CType.long
 
-    assert_equal Type.long, type
-    assert_equal Type.long, @function_table[:func]
+    assert_equal CType.long, type
+    assert_equal CType.long, @function_table[:func]
   end
 
   def test_cheat
-    @function_table.add_function :func, Type.long
-    @function_table.add_function :func, Type.str
+    @function_table.add_function :func, CType.long
+    @function_table.add_function :func, CType.str
 
-    assert_equal [Type.long, Type.str], @function_table.cheat(:func)
+    assert_equal [CType.long, CType.str], @function_table.cheat(:func)
   end
 
   def test_has_key?
-    @function_table.add_function :func, Type.long
+    @function_table.add_function :func, CType.long
 
     assert_equal true, @function_table.has_key?(:func)
     assert_equal false, @function_table.has_key?('no such func')
   end
 
   def test_index
-    @function_table.add_function :func, Type.long
+    @function_table.add_function :func, CType.long
 
-    assert_equal Type.long, @function_table[:func]
+    assert_equal CType.long, @function_table[:func]
 
-    @function_table.add_function :func, Type.str
+    @function_table.add_function :func, CType.str
 
-    assert_equal Type.long, @function_table[:func]
+    assert_equal CType.long, @function_table[:func]
   end
 
   def test_unify_one_type
-    @function_table.add_function :func, Type.unknown
+    @function_table.add_function :func, CType.unknown
 
-    @function_table.unify :func, Type.long do
+    @function_table.unify :func, CType.long do
       flunk "Block should not have been called"
     end
 
-    assert_equal Type.long, @function_table[:func]
+    assert_equal CType.long, @function_table[:func]
   end
 
   def test_unify_two_type
-    @function_table.add_function :func, Type.unknown
-    @function_table.add_function :func, Type.str
+    @function_table.add_function :func, CType.unknown
+    @function_table.add_function :func, CType.str
 
-    @function_table.unify :func, Type.long do
+    @function_table.unify :func, CType.long do
       flunk "Block should not have been called"
     end
 
-    assert_equal Type.long, @function_table[:func]
+    assert_equal CType.long, @function_table[:func]
   end
 
   def test_unify_block_called_no_type
-    @function_table.add_function :func, Type.str
+    @function_table.add_function :func, CType.str
 
     test_var = false
 
-    @function_table.unify :func, Type.long do
+    @function_table.unify :func, CType.long do
       test_var = true
     end
 
@@ -80,7 +80,7 @@ class TestFunctionTable < MiniTest::Unit::TestCase
   def test_unify_block_called_no_unify
     test_var = false
 
-    @function_table.unify :func, Type.long do
+    @function_table.unify :func, CType.long do
       test_var = true
     end
 

data/test/test_function_type.rb

@@ -3,53 +3,53 @@
 $TESTING = true
 
 require 'minitest/autorun' if $0 == __FILE__
-require 'minitest/unit'
+require 'minitest/test'
 require 'function_type'
 require 'type'
 
-class TestFunctionType < MiniTest::Unit::TestCase
+class TestFunctionType < Minitest::Test
   def setup
-    @function_type = FunctionType.new Type.void, [Type.long, Type.str], Type.value
+    @function_type = FunctionType.new CType.void, [CType.long, CType.str], CType.value
   end
 
   def test_formal_types
-    assert_equal [Type.long, Type.str], @function_type.formal_types
+    assert_equal [CType.long, CType.str], @function_type.formal_types
   end
 
   def test_formal_types=
-    @function_type.formal_types = [Type.str, Type.long]
-    assert_equal [Type.str, Type.long], @function_type.formal_types
+    @function_type.formal_types = [CType.str, CType.long]
+    assert_equal [CType.str, CType.long], @function_type.formal_types
   end
 
   def test_receiver_type
-    assert_equal Type.void, @function_type.receiver_type
+    assert_equal CType.void, @function_type.receiver_type
   end
 
   def test_receiver_type=
-    @function_type.receiver_type = Type.str
-    assert_equal Type.str, @function_type.receiver_type
+    @function_type.receiver_type = CType.str
+    assert_equal CType.str, @function_type.receiver_type
   end
 
   def test_return_type
-    assert_equal Type.value, @function_type.return_type
+    assert_equal CType.value, @function_type.return_type
   end
 
   def test_return_type=
-    @function_type.return_type = Type.long
-    assert_equal Type.long, @function_type.return_type
+    @function_type.return_type = CType.long
+    assert_equal CType.long, @function_type.return_type
   end
 
   def test_equals
     funs = []
-    funs << FunctionType.new(Type.unknown, [], Type.unknown)
-    funs << FunctionType.new(Type.unknown, [Type.unknown], Type.unknown)
-    funs << FunctionType.new(Type.unknown, [], Type.long)
-    funs << FunctionType.new(Type.unknown, [Type.long], Type.unknown)
-    funs << FunctionType.new(Type.unknown, [Type.long], Type.long)
-    funs << FunctionType.new(Type.unknown, [Type.unknown, Type.unknown], Type.unknown)
-    funs << FunctionType.new(Type.unknown, [Type.long, Type.unknown], Type.unknown)
-    funs << FunctionType.new(Type.unknown, [Type.long, Type.long], Type.long)
-    #funs << FunctionType.new(Type.unknown, [], Type.long)
+    funs << FunctionType.new(CType.unknown, [], CType.unknown)
+    funs << FunctionType.new(CType.unknown, [CType.unknown], CType.unknown)
+    funs << FunctionType.new(CType.unknown, [], CType.long)
+    funs << FunctionType.new(CType.unknown, [CType.long], CType.unknown)
+    funs << FunctionType.new(CType.unknown, [CType.long], CType.long)
+    funs << FunctionType.new(CType.unknown, [CType.unknown, CType.unknown], CType.unknown)
+    funs << FunctionType.new(CType.unknown, [CType.long, CType.unknown], CType.unknown)
+    funs << FunctionType.new(CType.unknown, [CType.long, CType.long], CType.long)
+    #funs << FunctionType.new(CType.unknown, [], CType.long)
 
     funs.each_with_index do |fun1, i|
       funs.each_with_index do |fun2, j|
@@ -63,59 +63,59 @@ class TestFunctionType < MiniTest::Unit::TestCase
   end
 
   def test_unify_components
-    fun1 = FunctionType.new(Type.unknown, [Type.unknown], Type.unknown)
-    fun2 = FunctionType.new(Type.long, [Type.long], Type.long)
+    fun1 = FunctionType.new(CType.unknown, [CType.unknown], CType.unknown)
+    fun2 = FunctionType.new(CType.long, [CType.long], CType.long)
     fun1.unify_components fun2
     assert_equal fun2, fun1
 
-    fun3 = FunctionType.new(Type.unknown, [Type.long], Type.unknown)
-    fun4 = FunctionType.new(Type.long, [Type.unknown], Type.long)
+    fun3 = FunctionType.new(CType.unknown, [CType.long], CType.unknown)
+    fun4 = FunctionType.new(CType.long, [CType.unknown], CType.long)
     fun3.unify_components fun4
     assert_equal fun4, fun3
 
-    fun5 = FunctionType.new(Type.unknown, [], Type.unknown)
-    fun6 = FunctionType.new(Type.long, [], Type.long)
+    fun5 = FunctionType.new(CType.unknown, [], CType.unknown)
+    fun6 = FunctionType.new(CType.long, [], CType.long)
     fun5.unify_components fun6
     assert_equal fun6, fun5
   end
 
   def test_initialize_fail
     assert_raises(RuntimeError) do
-      FunctionType.new(Type.unknown, nil, Type.long)
+      FunctionType.new(CType.unknown, nil, CType.long)
     end
 
     assert_raises(RuntimeError)do
-      FunctionType.new(Type.unknown, [], nil)
+      FunctionType.new(CType.unknown, [], nil)
     end
   end
 
   def test_unify_components_fail
-    fun1 = FunctionType.new(Type.long, [Type.str], Type.unknown)
-    fun2 = FunctionType.new(Type.unknown, [Type.long], Type.long)
+    fun1 = FunctionType.new(CType.long, [CType.str], CType.unknown)
+    fun2 = FunctionType.new(CType.unknown, [CType.long], CType.long)
     assert_raises(TypeError) do
       fun1.unify_components fun2
     end
 
-    fun3 = FunctionType.new(Type.long, [], Type.unknown)
-    fun4 = FunctionType.new(Type.unknown, [Type.unknown], Type.long)
+    fun3 = FunctionType.new(CType.long, [], CType.unknown)
+    fun4 = FunctionType.new(CType.unknown, [CType.unknown], CType.long)
     assert_raises(TypeError) do
       fun3.unify_components fun4
     end
 
-    fun5 = FunctionType.new(Type.long, [Type.unknown], Type.unknown)
-    fun6 = FunctionType.new(Type.unknown, [], Type.long)
+    fun5 = FunctionType.new(CType.long, [CType.unknown], CType.unknown)
+    fun6 = FunctionType.new(CType.unknown, [], CType.long)
     assert_raises(TypeError) do
       fun5.unify_components fun6
     end
 
-    fun7 = FunctionType.new(Type.long, [], Type.str)
-    fun8 = FunctionType.new(Type.unknown, [], Type.long)
+    fun7 = FunctionType.new(CType.long, [], CType.str)
+    fun8 = FunctionType.new(CType.unknown, [], CType.long)
     assert_raises(TypeError) do
       fun7.unify_components fun8
     end
 
-    fun9 = FunctionType.new(Type.long, [], Type.str)
-    funa = FunctionType.new(Type.str, [], Type.unknown)
+    fun9 = FunctionType.new(CType.long, [], CType.str)
+    funa = FunctionType.new(CType.str, [], CType.unknown)
 
     fun9, funa = funa, fun9 # get rid of unused warnings but keep them rooted
 
@@ -125,4 +125,3 @@ class TestFunctionType < MiniTest::Unit::TestCase
   end
 
 end
-

data/test/test_handle.rb

@@ -3,10 +3,10 @@
 $TESTING = true
 
 require 'minitest/autorun' if $0 == __FILE__
-require 'minitest/unit'
+require 'minitest/test'
 require 'handle'
 
-class TestHandle < MiniTest::Unit::TestCase
+class TestHandle < Minitest::Test
 
   def setup
     @handle = Handle.new("text")

data/test/test_r2cenvironment.rb

@@ -3,31 +3,31 @@
 $TESTING = true
 
 require 'minitest/autorun' if $0 == __FILE__
-require 'minitest/unit'
+require 'minitest/test'
 require 'r2cenvironment'
 require 'type'
 
-class TestR2CEnvironment < MiniTest::Unit::TestCase
+class TestR2CEnvironment < Minitest::Test
 
   def setup
     @env = R2CEnvironment.new
   end
 
   def test_add
-    assert_equal Type.long, @env.add(:var, Type.long)
-    assert_equal Type.long, @env.lookup(:var)
+    assert_equal CType.long, @env.add(:var, CType.long)
+    assert_equal CType.long, @env.lookup(:var)
   end
 
   def test_add_depth
     @env.scope do
-      assert_equal Type.long, @env.add(:var, Type.long, 1)
+      assert_equal CType.long, @env.add(:var, CType.long, 1)
     end
-    assert_equal Type.long, @env.lookup(:var)
+    assert_equal CType.long, @env.lookup(:var)
   end
 
   def test_add_raises_on_illegal
     assert_raises RuntimeError do
-      @env.add nil, Type.long
+      @env.add nil, CType.long
     end
 
     assert_raises RuntimeError do
@@ -37,8 +37,8 @@ class TestR2CEnvironment < MiniTest::Unit::TestCase
 
   def test_add_segmented
     @env.scope do
-      @env.add :var, Type.long
-      assert_equal Type.long, @env.lookup(:var)
+      @env.add :var, CType.long
+      assert_equal CType.long, @env.lookup(:var)
     end
 
     assert_raises NameError do
@@ -47,30 +47,30 @@ class TestR2CEnvironment < MiniTest::Unit::TestCase
   end
 
   def test_current
-    @env.add :var, Type.long
+    @env.add :var, CType.long
     @env.set_val :var, 42
-    
-    expected = { :var => [Type.long, 42] }
+
+    expected = { :var => [CType.long, 42] }
     assert_equal expected, @env.current
   end
 
   def test_all
     @env.scope do
-      @env.add :x, Type.long
+      @env.add :x, CType.long
 
       @env.scope do
-        @env.add :y, Type.str
-        @env.add :x, Type.float
+        @env.add :y, CType.str
+        @env.add :x, CType.float
 
-        expected = { :x => [Type.float], :y => [Type.str] }
+        expected = { :x => [CType.float], :y => [CType.str] }
         assert_equal expected, @env.all
       end
 
-      expected = { :x => [Type.long] }
+      expected = { :x => [CType.long] }
       assert_equal expected, @env.all
     end
   end
-  
+
   def test_depth
     assert_equal 1, @env.depth
 
@@ -86,28 +86,28 @@ class TestR2CEnvironment < MiniTest::Unit::TestCase
   end
 
   def test_get_val
-    @env.add :var, Type.long
+    @env.add :var, CType.long
     @env.set_val :var, 42
 
     assert_equal 42, @env.get_val(:var)
   end
 
   def test_set_val
-    @env.add :var, Type.long
+    @env.add :var, CType.long
     assert_equal 42, @env.set_val(:var, 42)
 
     assert_equal 42, @env.get_val(:var)
   end
 
   def test_set_val_static_array
-    @env.add :var, Type.long
+    @env.add :var, CType.long
     assert_equal "[2]", @env.set_val(:var, "[2]")
 
     assert_equal "[2]", @env.get_val(:var)
   end
 
   def test_get_val_unset
-    @env.add :var, Type.long
+    @env.add :var, CType.long
 
     assert_nil @env.get_val(:var)
   end
@@ -126,8 +126,8 @@ class TestR2CEnvironment < MiniTest::Unit::TestCase
   end
 
   def test_lookup
-    @env.add :var, Type.long
-    assert_equal Type.long, @env.lookup(:var)
+    @env.add :var, CType.long
+    assert_equal CType.long, @env.lookup(:var)
   end
 
   def test_lookup_raises
@@ -137,49 +137,49 @@ class TestR2CEnvironment < MiniTest::Unit::TestCase
   end
 
   def test_lookup_scope
-    @env.add :var, Type.long
-    assert_equal Type.long, @env.lookup(:var)
+    @env.add :var, CType.long
+    assert_equal CType.long, @env.lookup(:var)
 
     @env.scope do
-      assert_equal Type.long, @env.lookup(:var)
+      assert_equal CType.long, @env.lookup(:var)
     end
   end
 
   def test_scope
-    @env.add :var, Type.long
-    assert_equal Type.long, @env.lookup(:var)
+    @env.add :var, CType.long
+    assert_equal CType.long, @env.lookup(:var)
 
     @env.scope do
-      @env.add :var, Type.float
-      assert_equal Type.float, @env.lookup(:var)
+      @env.add :var, CType.float
+      assert_equal CType.float, @env.lookup(:var)
     end
 
-    assert_equal Type.long, @env.lookup(:var)
+    assert_equal CType.long, @env.lookup(:var)
   end
 
   def test_scope_raise
-    @env.add :a, Type.float
+    @env.add :a, CType.float
 
     begin
       @env.scope do
-        @env.add :a, Type.long
-        @env.add :b, Type.long
+        @env.add :a, CType.long
+        @env.add :b, CType.long
         raise "woo"
       end
     rescue
       # should replicate baddies
     end
 
-    expected = { :a => [Type.float] }
+    expected = { :a => [CType.float] }
     assert_equal expected, @env.all
   end
 
   def test_unextend
     @env.extend
 
-    @env.add :var, Type.long
+    @env.add :var, CType.long
 
-    assert_equal Type.long, @env.lookup(:var)
+    assert_equal CType.long, @env.lookup(:var)
 
     @env.unextend