ffi 0.3.5 → 0.4.0

data/lib/ffi/types.rb

@@ -1,7 +1,7 @@
 module FFI
 #  TypeDefs = Hash.new
   def self.add_typedef(current, add)
-    if current.kind_of? Integer
+    if current.kind_of?(FFI::Type)
       code = current
     else
       code = TypeDefs[current]
@@ -13,8 +13,7 @@ module FFI
   def self.find_type(name, type_map = nil)
     type_map = TypeDefs if type_map.nil?
     code = type_map[name]
-    code = name if !code && name.kind_of?(Integer)
-    code = name if !code && name.kind_of?(FFI::CallbackInfo)
+    code = name if !code && name.kind_of?(FFI::Type)
     raise TypeError, "Unable to resolve type '#{name}'" unless code
     return code
   end
@@ -92,7 +91,11 @@ module FFI
   add_typedef(NativeType::BUFFER_IN, :buffer_in)
   add_typedef(NativeType::BUFFER_OUT, :buffer_out)
   add_typedef(NativeType::BUFFER_INOUT, :buffer_inout)
+
   add_typedef(NativeType::VARARGS, :varargs)
+  
+  add_typedef(NativeType::ENUM, :enum)
+  add_typedef(NativeType::BOOL, :bool)
 
   # Use for a C struct with a char [] embedded inside.
   add_typedef(NativeType::CHAR_ARRAY, :char_array)

data/lib/ffi/variadic.rb

@@ -1,7 +1,7 @@
 module FFI
   class VariadicInvoker
-    def VariadicInvoker.new(library, function, arg_types, ret_type, options)
-      invoker = self.__new(library, function, ret_type, options[:convention].to_s)
+    def VariadicInvoker.new(function, arg_types, rb_ret_type, ret_type, options)
+      invoker = self.__new(function, rb_ret_type, ret_type, options[:convention].to_s, options[:enums])
       invoker.init(arg_types, options[:type_map])
       invoker
     end

data/spec/ffi/bool_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+describe "Function with primitive boolean arguments and return values" do
+  module LibTest
+    extend FFI::Library
+    ffi_lib TestLibrary::PATH
+    attach_function :bool_return_true, [ ], :bool
+    attach_function :bool_return_false, [ ], :bool
+    attach_function :bool_return_val, [ :bool ], :bool
+    attach_function :bool_reverse_val, [ :bool ], :bool
+  end
+  it "bools" do
+    LibTest.bool_return_true.should == true
+    LibTest.bool_return_false.should == false
+
+    LibTest.bool_return_val(true).should == true
+    LibTest.bool_return_val(false).should == false
+
+    LibTest.bool_reverse_val(true).should == false
+    LibTest.bool_reverse_val(false).should == true
+  end
+  it "raise error on invalid types" do
+    lambda { LibTest.bool_return_val(nil) }.should raise_error(::TypeError)
+  end
+end

data/spec/ffi/callback_spec.rb

@@ -37,21 +37,30 @@ describe "Callback" do
     callback :cbVrU16, [ ], :ushort
     callback :cbVrS32, [ ], :int
     callback :cbVrU32, [ ], :uint
+    callback :cbVrL, [ ], :long
+    callback :cbVrUL, [ ], :ulong
     callback :cbVrS64, [ ], :long_long
     callback :cbVrU64, [ ], :ulong_long
     callback :cbVrP, [], :pointer
+    callback :cbVrZ, [], :bool
     callback :cbCrV, [ :char ], :void
     callback :cbSrV, [ :short ], :void
     callback :cbIrV, [ :int ], :void
+    callback :cbLrV, [ :long ], :void
+    callback :cbULrV, [ :ulong ], :void
     callback :cbLrV, [ :long_long ], :void
+
     attach_function :testCallbackVrS8, :testClosureVrB, [ :cbVrS8 ], :char
     attach_function :testCallbackVrU8, :testClosureVrB, [ :cbVrU8 ], :uchar
     attach_function :testCallbackVrS16, :testClosureVrS, [ :cbVrS16 ], :short
     attach_function :testCallbackVrU16, :testClosureVrS, [ :cbVrU16 ], :ushort
     attach_function :testCallbackVrS32, :testClosureVrI, [ :cbVrS32 ], :int
     attach_function :testCallbackVrU32, :testClosureVrI, [ :cbVrU32 ], :uint
-    attach_function :testCallbackVrS64, :testClosureVrL, [ :cbVrS64 ], :long_long
-    attach_function :testCallbackVrU64, :testClosureVrL, [ :cbVrU64 ], :ulong_long
+    attach_function :testCallbackVrL, :testClosureVrL, [ :cbVrL ], :long
+    attach_function :testCallbackVrZ, :testClosureVrZ, [ :cbVrZ ], :bool
+    attach_function :testCallbackVrUL, :testClosureVrL, [ :cbVrUL ], :ulong
+    attach_function :testCallbackVrS64, :testClosureVrLL, [ :cbVrS64 ], :long_long
+    attach_function :testCallbackVrU64, :testClosureVrLL, [ :cbVrU64 ], :ulong_long
     attach_function :testCallbackVrP, :testClosureVrP, [ :cbVrP ], :pointer
     attach_function :testCallbackCrV, :testClosureBrV, [ :cbCrV, :char ], :void
     attach_variable :cbVrS8, :gvar_pointer, :cbVrS8
@@ -122,7 +131,6 @@ describe "Callback" do
   it "returning :ushort (-1)" do
     LibTest.testCallbackVrU16 { -1 }.should == 0xffff
   end
-
   it "returning :int (0)" do
     LibTest.testCallbackVrS32 { 0 }.should == 0
   end
@@ -136,7 +144,6 @@ describe "Callback" do
   it "returning :int (-1)" do
     LibTest.testCallbackVrS32 { -1 }.should == -1
   end
-
   it "returning :uint (0)" do
     LibTest.testCallbackVrU32 { 0 }.should == 0
   end
@@ -153,7 +160,39 @@ describe "Callback" do
   it "Callback returning :uint (-1)" do
     LibTest.testCallbackVrU32 { -1 }.should == 0xffffffff
   end
-
+  it "returning :long (0)" do
+    LibTest.testCallbackVrL { 0 }.should == 0
+  end
+  it "returning :long (0x7fffffff)" do
+    LibTest.testCallbackVrL { 0x7fffffff }.should == 0x7fffffff
+  end
+  # test wrap around
+  it "returning :long (-0x80000000)" do
+    LibTest.testCallbackVrL { -0x80000000 }.should == -0x80000000
+  end
+  it "returning :long (-1)" do
+    LibTest.testCallbackVrL { -1 }.should == -1
+  end
+  it "returning :ulong (0)" do
+    LibTest.testCallbackVrUL { 0 }.should == 0
+  end
+  it "returning :ulong (0x7fffffff)" do
+    LibTest.testCallbackVrUL { 0x7fffffff }.should == 0x7fffffff
+  end
+  # test wrap around
+  it "returning :ulong (0x80000000)" do
+    LibTest.testCallbackVrUL { 0x80000000 }.should == 0x80000000
+  end
+  it "returning :ulong (0xffffffff)" do
+    LibTest.testCallbackVrUL { 0xffffffff }.should == 0xffffffff
+  end
+  it "Callback returning :ulong (-1)" do
+    if FFI::Platform::LONG_SIZE == 32
+      LibTest.testCallbackVrUL { -1 }.should == 0xffffffff
+    else
+      LibTest.testCallbackVrUL { -1 }.should == 0xffffffffffffffff
+    end
+  end
   it "returning :long_long (0)" do
     LibTest.testCallbackVrS64 { 0 }.should == 0
   end
@@ -167,11 +206,14 @@ describe "Callback" do
   it "returning :long_long (-1)" do
     LibTest.testCallbackVrS64 { -1 }.should == -1
   end
+  it "returning bool" do
+    LibTest.testCallbackVrZ { true }.should be_true
+  end
   it "returning :pointer (nil)" do
     LibTest.testCallbackVrP { nil }.null?.should be_true
   end
   it "returning :pointer (MemoryPointer)" do
-    p = MemoryPointer.new :long
+    p = FFI::MemoryPointer.new :long
     LibTest.testCallbackVrP { p }.should == p
   end
 
@@ -187,6 +229,113 @@ describe "Callback" do
     end
   end
 
+  describe 'when inlined' do
+    it 'could be anonymous' do
+      module LibTest
+        extend FFI::Library
+        attach_function :testCallbackVrS8, :testClosureVrB, [ callback([ ], :char) ], :char
+      end
+      LibTest.testCallbackVrS8 { 0 }.should == 0
+    end
+  end
+
+  describe "as return value" do
+
+    it "should not blow up when a callback is defined that returns a callback" do
+      module LibTest
+        extend FFI::Library
+        callback :cb_return_type_1, [ :short ], :short
+        callback :cb_lookup_1, [ :short ], :cb_return_type_1
+        attach_function :testReturnsCallback_1, :testReturnsClosure, [ :cb_lookup_1, :short ], :cb_return_type_1
+      end      
+    end
+
+    it "should return a callback" do
+      module LibTest
+        extend FFI::Library
+        callback :cb_return_type, [ :int ], :int
+        callback :cb_lookup, [ ], :cb_return_type
+        attach_function :testReturnsCallback, :testReturnsClosure, [ :cb_lookup, :int ], :int
+      end      
+
+      lookup_proc_called = false
+      return_proc_called = false
+
+      return_proc = Proc.new do |a|
+        return_proc_called = true
+        a * 2
+      end
+      lookup_proc = Proc.new do
+        lookup_proc_called = true
+        return_proc
+      end
+
+      val = LibTest.testReturnsCallback(lookup_proc, 0x1234)
+      val.should == 0x1234 * 2
+      lookup_proc_called.should be_true
+      return_proc_called.should be_true
+    end
+
+    it "should return a method callback" do
+      module LibTest
+        extend FFI::Library
+        callback :cb_return_type, [ :int ], :int
+        callback :cb_lookup, [ ], :cb_return_type
+        attach_function :testReturnsCallback, :testReturnsClosure, [ :cb_lookup, :int ], :int
+      end
+      module MethodCallback
+        def self.lookup
+          method(:perform)
+        end
+        def self.perform num
+          num * 2
+        end
+      end
+
+      LibTest.testReturnsCallback(MethodCallback.method(:lookup), 0x1234).should == 0x2468
+    end
+
+    it 'should not blow up when a callback takes a callback as argument' do
+      module LibTest
+        extend FFI::Library
+        callback :cb_argument, [ :int ], :int
+        callback :cb_with_cb_argument, [ :cb_argument, :int ], :int
+        attach_function :testCallbackAsArgument, :testArgumentClosure, [ :cb_with_cb_argument, :int ], :int
+      end   
+    end
+    it 'should be able to use the callback argument' do
+      module LibTest
+        extend FFI::Library
+        callback :cb_argument, [ :int ], :int
+        callback :cb_with_cb_argument, [ :cb_argument, :int ], :int
+        attach_function :testCallbackAsArgument, :testArgumentClosure, [ :cb_with_cb_argument, :cb_argument, :int ], :int
+      end   
+      callback_arg_called = false
+      callback_with_callback_arg_called = false         
+      callback_arg = Proc.new do |val|
+        callback_arg_called = true
+        val * 2
+      end
+      callback_with_callback_arg = Proc.new do |cb, val|
+        callback_with_callback_arg_called = true
+        cb.call(val)
+      end
+      val = LibTest.testCallbackAsArgument(callback_with_callback_arg, callback_arg, 0xff1)
+      val.should == 0xff1 * 2
+      callback_arg_called.should be_true
+      callback_with_callback_arg_called.should be_true         
+    end
+    it 'function returns callable object' do
+      module LibTest
+        extend FFI::Library
+        callback :funcptr, [ :int ], :int
+        attach_function :testReturnsFunctionPointer, [  ], :funcptr
+      end
+      f = LibTest.testReturnsFunctionPointer
+      f.call(3).should == 6
+    end
+  end
+
 end
 describe "primitive argument" do
   #
@@ -199,16 +348,27 @@ describe "primitive argument" do
     callback :cbU8rV, [ :uchar ], :void
     callback :cbS16rV, [ :short ], :void
     callback :cbU16rV, [ :ushort ], :void
+
+    callback :cbZrV, [ :bool ], :void
     callback :cbS32rV, [ :int ], :void
     callback :cbU32rV, [ :uint ], :void
+
+    callback :cbLrV, [ :long ], :void
+    callback :cbULrV, [ :ulong ], :void
+
     callback :cbS64rV, [ :long_long ], :void
     attach_function :testCallbackCrV, :testClosureBrV, [ :cbS8rV, :char ], :void
     attach_function :testCallbackU8rV, :testClosureBrV, [ :cbU8rV, :uchar ], :void
     attach_function :testCallbackSrV, :testClosureSrV, [ :cbS16rV, :short ], :void
     attach_function :testCallbackU16rV, :testClosureSrV, [ :cbU16rV, :ushort ], :void
+    attach_function :testCallbackZrV, :testClosureZrV, [ :cbZrV, :bool ], :void
     attach_function :testCallbackIrV, :testClosureIrV, [ :cbS32rV, :int ], :void
     attach_function :testCallbackU32rV, :testClosureIrV, [ :cbU32rV, :uint ], :void
-    attach_function :testCallbackLrV, :testClosureLrV, [ :cbS64rV, :long_long ], :void
+
+    attach_function :testCallbackLrV, :testClosureLrV, [ :cbLrV, :long ], :void
+    attach_function :testCallbackULrV, :testClosureULrV, [ :cbULrV, :ulong ], :void
+
+    attach_function :testCallbackLLrV, :testClosureLLrV, [ :cbS64rV, :long_long ], :void
   end
   it ":char (0) argument" do
     v = 0xdeadbeef
@@ -230,7 +390,6 @@ describe "primitive argument" do
     LibTest.testCallbackCrV(-1) { |i| v = i }
     v.should == -1
   end
-
   it ":uchar (0) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackU8rV(0) { |i| v = i }
@@ -272,7 +431,6 @@ describe "primitive argument" do
     LibTest.testCallbackSrV(-1) { |i| v = i }
     v.should == -1
   end
-
   it ":ushort (0) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackU16rV(0) { |i| v = i }
@@ -293,7 +451,11 @@ describe "primitive argument" do
     LibTest.testCallbackU16rV(0xffff) { |i| v = i }
     v.should == 0xffff
   end
-
+  it ":bool (true) argument" do
+    v = false
+    LibTest.testCallbackZrV(true) { |i| v = i }
+    v.should be_true
+  end
   it ":int (0) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackIrV(0) { |i| v = i }
@@ -314,7 +476,6 @@ describe "primitive argument" do
     LibTest.testCallbackIrV(-1) { |i| v = i }
     v.should == -1
   end
-
   it ":uint (0) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackU32rV(0) { |i| v = i }
@@ -335,26 +496,65 @@ describe "primitive argument" do
     LibTest.testCallbackU32rV(0xffffffff) { |i| v = i }
     v.should == 0xffffffff
   end
-
-  it ":long_long (0) argument" do
+  it ":long (0) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackLrV(0) { |i| v = i }
     v.should == 0
   end
+  it ":long (0x7fffffff) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackLrV(0x7fffffff) { |i| v = i }
+    v.should == 0x7fffffff
+  end
+  it ":long (-0x80000000) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackLrV(-0x80000000) { |i| v = i }
+    v.should == -0x80000000
+  end
+  it ":long (-1) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackLrV(-1) { |i| v = i }
+    v.should == -1
+  end
+  it ":ulong (0) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackULrV(0) { |i| v = i }
+    v.should == 0
+  end
+  it ":ulong (0x7fffffff) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackULrV(0x7fffffff) { |i| v = i }
+    v.should == 0x7fffffff
+  end
+  it ":ulong (0x80000000) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackULrV(0x80000000) { |i| v = i }
+    v.should == 0x80000000
+  end
+  it ":ulong (0xffffffff) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackULrV(0xffffffff) { |i| v = i }
+    v.should == 0xffffffff
+  end
+  it ":long_long (0) argument" do
+    v = 0xdeadbeef
+    LibTest.testCallbackLLrV(0) { |i| v = i }
+    v.should == 0
+  end
   it ":long_long (0x7fffffffffffffff) argument" do
     v = 0xdeadbeef
-    LibTest.testCallbackLrV(0x7fffffffffffffff) { |i| v = i }
+    LibTest.testCallbackLLrV(0x7fffffffffffffff) { |i| v = i }
     v.should == 0x7fffffffffffffff
   end
   it ":long_long (-0x8000000000000000) argument" do
     v = 0xdeadbeef
-    LibTest.testCallbackLrV(-0x8000000000000000) { |i| v = i }
+    LibTest.testCallbackLLrV(-0x8000000000000000) { |i| v = i }
     v.should == -0x8000000000000000
   end
   it ":long_long (-1) argument" do
     v = 0xdeadbeef
-    LibTest.testCallbackLrV(-1) { |i| v = i }
+    LibTest.testCallbackLLrV(-1) { |i| v = i }
     v.should == -1
   end
   
-end unless true
+end # unless true

data/spec/ffi/enum_spec.rb

@@ -0,0 +1,164 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+module TestEnum0
+  extend FFI::Library
+end
+
+module TestEnum1
+  extend FFI::Library
+  ffi_lib TestLibrary::PATH
+
+  enum [:c1, :c2, :c3, :c4]
+  enum [:c5, 42, :c6, :c7, :c8]
+  enum [:c9, 42, :c10, :c11, 4242, :c12]
+  enum [:c13, 42, :c14, 4242, :c15, 424242, :c16, 42424242]
+  
+  attach_function :test_untagged_enum, [:int], :int
+end
+
+module TestEnum3
+  extend FFI::Library
+  ffi_lib TestLibrary::PATH
+
+  enum :enum_type1, [:c1, :c2, :c3, :c4]
+  enum :enum_type2, [:c5, 42, :c6, :c7, :c8]
+  enum :enum_type3, [:c9, 42, :c10, :c11, 4242, :c12]
+  enum :enum_type4, [:c13, 42, :c14, 4242, :c15, 424242, :c16, 42424242]
+
+  attach_function :test_tagged_typedef_enum1, [:enum_type1], :enum_type1
+  attach_function :test_tagged_typedef_enum2, [:enum_type2], :enum_type2
+  attach_function :test_tagged_typedef_enum3, [:enum_type3], :enum_type3
+  attach_function :test_tagged_typedef_enum4, [:enum_type4], :enum_type4
+end
+
+describe "A library with no enum defined" do
+  it "returns nil when asked for an enum" do
+    TestEnum0.enum_type(:foo).should == nil
+  end
+end
+
+describe "An untagged enum" do
+  it "constants can be used as function parameters and return value" do
+    TestEnum1.test_untagged_enum(:c1).should == 0
+    TestEnum1.test_untagged_enum(:c2).should == 1
+    TestEnum1.test_untagged_enum(:c3).should == 2
+    TestEnum1.test_untagged_enum(:c4).should == 3
+    TestEnum1.test_untagged_enum(:c5).should == 42
+    TestEnum1.test_untagged_enum(:c6).should == 43
+    TestEnum1.test_untagged_enum(:c7).should == 44
+    TestEnum1.test_untagged_enum(:c8).should == 45
+    TestEnum1.test_untagged_enum(:c9).should == 42
+    TestEnum1.test_untagged_enum(:c10).should == 43
+    TestEnum1.test_untagged_enum(:c11).should == 4242
+    TestEnum1.test_untagged_enum(:c12).should == 4243
+    TestEnum1.test_untagged_enum(:c13).should == 42
+    TestEnum1.test_untagged_enum(:c14).should == 4242
+    TestEnum1.test_untagged_enum(:c15).should == 424242
+    TestEnum1.test_untagged_enum(:c16).should == 42424242
+  end
+end
+
+describe "A tagged typedef enum" do
+  it "is accessible through its tag" do
+    TestEnum3.enum_type(:enum_type1).should_not == nil
+    TestEnum3.enum_type(:enum_type2).should_not == nil
+    TestEnum3.enum_type(:enum_type3).should_not == nil
+    TestEnum3.enum_type(:enum_type4).should_not == nil
+  end
+  it "contains enum constants" do
+    TestEnum3.enum_type(:enum_type1).symbols.length.should == 4
+    TestEnum3.enum_type(:enum_type2).symbols.length.should == 4
+    TestEnum3.enum_type(:enum_type3).symbols.length.should == 4
+    TestEnum3.enum_type(:enum_type4).symbols.length.should == 4
+  end
+  it "constants can be used as function parameters and return value" do
+    TestEnum3.test_tagged_typedef_enum1(:c1).should == :c1
+    TestEnum3.test_tagged_typedef_enum1(:c2).should == :c2
+    TestEnum3.test_tagged_typedef_enum1(:c3).should == :c3
+    TestEnum3.test_tagged_typedef_enum1(:c4).should == :c4
+    TestEnum3.test_tagged_typedef_enum2(:c5).should == :c5
+    TestEnum3.test_tagged_typedef_enum2(:c6).should == :c6
+    TestEnum3.test_tagged_typedef_enum2(:c7).should == :c7
+    TestEnum3.test_tagged_typedef_enum2(:c8).should == :c8
+    TestEnum3.test_tagged_typedef_enum3(:c9).should == :c9
+    TestEnum3.test_tagged_typedef_enum3(:c10).should == :c10
+    TestEnum3.test_tagged_typedef_enum3(:c11).should == :c11
+    TestEnum3.test_tagged_typedef_enum3(:c12).should == :c12
+    TestEnum3.test_tagged_typedef_enum4(:c13).should == :c13
+    TestEnum3.test_tagged_typedef_enum4(:c14).should == :c14
+    TestEnum3.test_tagged_typedef_enum4(:c15).should == :c15
+    TestEnum3.test_tagged_typedef_enum4(:c16).should == :c16
+  end
+end
+
+describe "All enums" do
+  it "have autonumbered constants when defined with names only" do
+    TestEnum1.enum_value(:c1).should == 0
+    TestEnum1.enum_value(:c2).should == 1
+    TestEnum1.enum_value(:c3).should == 2
+    TestEnum1.enum_value(:c4).should == 3
+
+    TestEnum3.enum_value(:c1).should == 0
+    TestEnum3.enum_value(:c2).should == 1
+    TestEnum3.enum_value(:c3).should == 2
+    TestEnum3.enum_value(:c4).should == 3
+  end
+  it "can have an explicit first constant and autonumbered subsequent constants" do
+    TestEnum1.enum_value(:c5).should == 42
+    TestEnum1.enum_value(:c6).should == 43
+    TestEnum1.enum_value(:c7).should == 44
+    TestEnum1.enum_value(:c8).should == 45
+
+    TestEnum3.enum_value(:c5).should == 42
+    TestEnum3.enum_value(:c6).should == 43
+    TestEnum3.enum_value(:c7).should == 44
+    TestEnum3.enum_value(:c8).should == 45
+  end
+  it "can have a mix of explicit and autonumbered constants" do
+    TestEnum1.enum_value(:c9).should  == 42
+    TestEnum1.enum_value(:c10).should == 43
+    TestEnum1.enum_value(:c11).should == 4242
+    TestEnum1.enum_value(:c12).should == 4243
+
+    TestEnum3.enum_value(:c9).should  == 42
+    TestEnum3.enum_value(:c10).should == 43
+    TestEnum3.enum_value(:c11).should == 4242
+    TestEnum3.enum_value(:c12).should == 4243
+  end
+  it "can have all its constants explicitely valued" do
+    TestEnum1.enum_value(:c13).should == 42
+    TestEnum1.enum_value(:c14).should == 4242
+    TestEnum1.enum_value(:c15).should == 424242
+    TestEnum1.enum_value(:c16).should == 42424242
+    
+    TestEnum3.enum_value(:c13).should == 42
+    TestEnum3.enum_value(:c14).should == 4242
+    TestEnum3.enum_value(:c15).should == 424242
+    TestEnum3.enum_value(:c16).should == 42424242
+  end
+  it "return the constant corresponding to a specific value" do
+    enum = TestEnum3.enum_type(:enum_type1)
+    enum[0].should == :c1
+    enum[1].should == :c2
+    enum[2].should == :c3
+    enum[3].should == :c4
+
+    enum = TestEnum3.enum_type(:enum_type2)
+    enum[42].should == :c5
+    enum[43].should == :c6
+    enum[44].should == :c7
+    enum[45].should == :c8
+
+    enum = TestEnum3.enum_type(:enum_type3)
+    enum[42].should == :c9
+    enum[43].should == :c10
+    enum[4242].should == :c11
+    enum[4243].should == :c12
+
+    enum = TestEnum3.enum_type(:enum_type4)
+    enum[42].should == :c13
+    enum[4242].should == :c14
+    enum[424242].should == :c15
+    enum[42424242].should == :c16
+  end
+end