ffi 1.9.21-x64-mingw32 → 1.9.22-x64-mingw32

data/spec/ffi/custom_param_type.rb

@@ -1,37 +0,0 @@
-#
-# This file is part of ruby-ffi.
-# For licensing, see LICENSE.SPECS
-#
-
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-
-describe "functions with custom parameter types" do
-  before :each do
-
-    Custom_enum = Class.new do
-      extend FFI::DataConverter
-      ToNativeMap= { :a => 1, :b => 2 }
-      FromNativeMap = { 1 => :a, 2 => :b }
-
-      def self.native_type
-        @native_type_called = true
-        FFI::Type::INT32
-      end
-
-      def self.to_native(val, ctx)
-        @to_native_called = true
-        ToNativeMap[val]
-      end
-
-      def self.from_native(val, ctx)
-        @from_native_called = true
-        FromNativeMap[val]
-      end
-      def self.native_type_called?; @native_type_called; end
-      def self.from_native_called?; @from_native_called; end
-      def self.to_native_called?; @to_native_called; end
-    end
-
-    # FIXME add tests
-  end
-end

data/spec/ffi/custom_type_spec.rb

@@ -1,74 +0,0 @@
-#
-# This file is part of ruby-ffi.
-# For licensing, see LICENSE.SPECS
-#
-
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-
-describe "functions with custom types" do
-  class Custom_enum
-    extend FFI::DataConverter
-    ToNativeMap= { :a => 1, :b => 2, :c => 3 }
-    FromNativeMap = { 1 => :a, 2 => :b, 3 => :c }
-
-    def self.native_type
-      @native_type_called = true
-      FFI::Type::INT32
-    end
-
-    def self.to_native(val, ctx)
-      @to_native_called = true
-      ToNativeMap[val]
-    end
-
-    def self.from_native(val, ctx)
-      @from_native_called = true
-      FromNativeMap[val]
-    end
-    def self.native_type_called?; @native_type_called; end
-    def self.from_native_called?; @from_native_called; end
-    def self.to_native_called?; @to_native_called; end
-  end
-
-  it "can attach with custom return type" do
-    expect do
-      Module.new do
-        extend FFI::Library
-        ffi_lib TestLibrary::PATH
-        attach_function :ret_s32, [ :int ], Custom_enum
-      end
-    end.not_to raise_error
-  end
-
-  it "should return object of correct type" do
-
-    m = Module.new do
-
-      extend FFI::Library
-      ffi_lib TestLibrary::PATH
-      attach_function :ret_s32, [ :int ], Custom_enum
-    end
-
-    expect(m.ret_s32(1).is_a?(Symbol)).to be true
-  end
-
-  it "from_native should be called for result" do
-    m = Module.new do
-      extend FFI::Library
-      ffi_lib TestLibrary::PATH
-      attach_function :ret_s32, [ :int ], Custom_enum
-    end
-    m.ret_s32(1)
-    expect(Custom_enum.from_native_called?).to be true
-  end
-
-  it "to_native should be called for parameter" do
-    m = Module.new do
-      extend FFI::Library
-      ffi_lib TestLibrary::PATH
-      attach_function :ret_s32, [ Custom_enum ], :int
-    end
-    m.ret_s32(:a)
-    expect(Custom_enum.to_native_called?).to be true
-  end
-end

data/spec/ffi/dup_spec.rb

@@ -1,52 +0,0 @@
-#
-# This file is part of ruby-ffi.
-# For licensing, see LICENSE.SPECS
-#
-
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-
-describe "Pointer#dup" do 
-  it "clone should be independent" do
-    p1 = FFI::MemoryPointer.new(:char, 1024)
-    p1.put_string(0, "test123");
-    p2 = p1.dup
-    p1.put_string(0, "deadbeef")
-    
-    expect(p2.get_string(0)).to eq("test123")
-  end
-  
-  it "sliced pointer can be cloned" do
-    p1 = FFI::MemoryPointer.new(:char, 1024)
-    p1.put_string(0, "test123");
-    p2 = p1[1].dup
-    
-    # first char will be excised
-    expect(p2.get_string(0)).to eq("est123")
-    expect(p1.get_string(0)).to eq("test123")
-  end
-  
-  it "sliced pointer when cloned is independent" do
-    p1 = FFI::MemoryPointer.new(:char, 1024)
-    p1.put_string(0, "test123");
-    p2 = p1[1].dup
-    
-    p1.put_string(0, "deadbeef")
-    # first char will be excised
-    expect(p2.get_string(0)).to eq("est123")
-  end
-end
-
-
-describe "Struct#dup" do
-  it "clone should be independent" do
-    s = Class.new(FFI::Struct) do
-      layout :i, :int
-    end
-    s1 = s.new
-    s1[:i] = 0x12345
-    s2 = s1.dup
-    s1[:i] = 0x98765
-    expect(s2[:i]).to eq(0x12345)
-    expect(s1[:i]).to eq(0x98765)
-  end
-end

data/spec/ffi/embed-test/ext/Makefile

@@ -1,242 +0,0 @@
-
-SHELL = /bin/sh
-
-# V=0 quiet, V=1 verbose.  other values don't work.
-V = 0
-Q1 = $(V:1=)
-Q = $(Q1:0=@)
-ECHO1 = $(V:1=@:)
-ECHO = $(ECHO1:0=@echo)
-NULLCMD = :
-
-#### Start of system configuration section. ####
-
-srcdir = .
-topdir = /home/lars/.rvm/rubies/rbx-3.83/machine/include/capi
-hdrdir = $(topdir)
-arch_hdrdir = /home/lars/.rvm/rubies/rbx-3.83/machine/include/capi
-PATH_SEPARATOR = :
-VPATH = $(srcdir):$(arch_hdrdir)/ruby:$(hdrdir)/ruby
-prefix = $(DESTDIR)/home/lars/.rvm/rubies/rbx-3.83
-install_prefix = $(DESTDIR)
-exec_prefix = $(prefix)
-bindir = $(DESTDIR)/home/lars/.rvm/rubies/rbx-3.83/bin
-sbindir = $(exec_prefix)/sbin
-libexecdir = $(exec_prefix)/libexec
-datarootdir = $(prefix)/share
-datadir = $(datarootdir)
-sysconfdir = $(prefix)/etc
-sharedstatedir = $(prefix)/com
-localstatedir = $(prefix)/var
-includedir = $(prefix)/include
-oldincludedir = $(DESTDIR)/usr/include
-docdir = $(datarootdir)/doc/$(PACKAGE)
-infodir = $(datarootdir)/info
-htmldir = $(docdir)
-dvidir = $(docdir)
-pdfdir = $(docdir)
-psdir = $(docdir)
-libdir = $(exec_prefix)/lib
-localedir = $(datarootdir)/locale
-mandir = $(datarootdir)/man
-rubyhdrdir = $(DESTDIR)/home/lars/.rvm/rubies/rbx-3.83/machine/include/capi
-sitedir = $(DESTDIR)/home/lars/.rvm/rubies/rbx-3.83/site
-sitelibdir = $(DESTDIR)/home/lars/.rvm/rubies/rbx-3.83/site
-rubylibdir = $(DESTDIR)/home/lars/.rvm/rubies/rbx-3.83/site
-archdir = $(DESTDIR)/home/lars/.rvm/rubies/rbx-3.83/site/x86_64-linux-gnu
-sitearchdir = $(DESTDIR)/home/lars/.rvm/rubies/rbx-3.83/site/x86_64-linux-gnu
-rubyarchhdrdir = $(DESTDIR)/home/lars/.rvm/rubies/rbx-3.83/machine/include/capi
-
-
-CC = cc
-CXX = c++
-LIBRUBY = $(LIBRUBY_SO)
-LIBRUBY_A = 
-LIBRUBYARG_SHARED = 
-LIBRUBYARG_STATIC = 
-empty =
-OUTFLAG = -o $(empty)
-COUTFLAG = -o $(empty)
-
-RUBY_EXTCONF_H = 
-cflags   = 
-cxxflags = 
-optflags = 
-debugflags = 
-warnflags = 
-CCDLFLAGS =  -fPIC
-CFLAGS   = $(CCDLFLAGS) -g -O2 -fPIC $(ARCH_FLAG)
-INCFLAGS = -I. -I$(arch_hdrdir) -I$(hdrdir)/ruby/backward -I$(hdrdir) -I$(srcdir)
-DEFS     = 
-CPPFLAGS =  
-CXXFLAGS = $(CCDLFLAGS) -g -O2 -std=c++11  $(ARCH_FLAG)
-ldflags  =  -Wl,--export-dynamic -lrt -lcrypt -ldl -lpthread -latomic 
-dldflags =  
-ARCH_FLAG = 
-DLDFLAGS = $(ldflags) $(dldflags) $(ARCH_FLAG)
-LDSHARED = cc -shared
-LDSHAREDXX = c++ -shared
-AR = ar
-EXEEXT = 
-
-RUBY_INSTALL_NAME = rbx
-RUBY_SO_NAME = rubinius-3.83
-RUBYW_INSTALL_NAME = 
-
-arch = x86_64-linux-gnu
-sitearch = x86_64-linux-gnu
-ruby_version = 2.3
-ruby = $(bindir)/rbx
-RUBY = $(ruby)
-ruby_headers = $(hdrdir)/ruby.h $(hdrdir)/ruby/ruby.h $(hdrdir)/ruby/defines.h $(hdrdir)/ruby/missing.h $(hdrdir)/ruby/intern.h $(hdrdir)/ruby/st.h $(hdrdir)/ruby/subst.h $(arch_hdrdir)/ruby/config.h
-
-RM = rm -f
-RM_RF = $(RUBY) -run -e rm -- -rf
-RMDIRS = $(RUBY) -run -e rmdir -- -p
-MAKEDIRS = mkdir -p
-INSTALL = install -c
-INSTALL_PROG = $(INSTALL) -m 0755
-INSTALL_DATA = $(INSTALL) -m 644
-COPY = cp
-TOUCH = exit >
-
-#### End of system configuration section. ####
-
-preload = 
-
-libpath = . $(libdir)
-LIBPATH =  -L. -L$(libdir) -Wl,-R$(libdir)
-DEFFILE = 
-
-CLEANFILES = mkmf.log
-DISTCLEANFILES = 
-DISTCLEANDIRS = 
-
-extout = 
-extout_prefix = 
-target_prefix = 
-LOCAL_LIBS = 
-LIBS = $(LIBRUBYARG_STATIC)   
-ORIG_SRCS = embed.c
-SRCS = $(ORIG_SRCS) 
-OBJS = embed.o
-HDRS = 
-TARGET = embed_test
-TARGET_NAME = embed_test
-TARGET_ENTRY = Init_$(TARGET_NAME)
-DLLIB = $(TARGET).so
-EXTSTATIC = 
-STATIC_LIB = 
-
-TIMESTAMP_DIR = .
-BINDIR        = $(bindir)
-RUBYCOMMONDIR = $(sitedir)$(target_prefix)
-RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
-RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
-HDRDIR        = $(rubyhdrdir)/ruby$(target_prefix)
-ARCHHDRDIR    = $(rubyhdrdir)/$(arch)/ruby$(target_prefix)
-
-TARGET_SO     = $(DLLIB)
-CLEANLIBS     = $(TARGET).so 
-CLEANOBJS     = *.o  *.bak
-
-all:    $(DLLIB)
-static: $(STATIC_LIB) install-rb
-.PHONY: all install static install-so install-rb
-.PHONY: clean clean-so clean-static clean-rb
-
-clean-static::
-clean-rb-default::
-clean-rb::
-clean-so::
-clean: clean-so clean-static clean-rb-default clean-rb
-		-$(Q)$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES) .*.time
-
-distclean-rb-default::
-distclean-rb::
-distclean-so::
-distclean-static::
-distclean: clean distclean-so distclean-static distclean-rb-default distclean-rb
-		-$(Q)$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
-		-$(Q)$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
-		-$(Q)$(RMDIRS) $(DISTCLEANDIRS) 2> /dev/null || true
-
-realclean: distclean
-install: install-so install-rb
-
-install-so: $(DLLIB) $(TIMESTAMP_DIR)/.RUBYARCHDIR.time
-	$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
-clean-static::
-	-$(Q)$(RM) $(STATIC_LIB)
-install-rb: pre-install-rb install-rb-default
-install-rb-default: pre-install-rb-default
-pre-install-rb: Makefile
-pre-install-rb-default: Makefile
-pre-install-rb-default:
-	@$(NULLCMD)
-$(TIMESTAMP_DIR)/.RUBYARCHDIR.time:
-	$(Q) $(MAKEDIRS) $(@D) $(RUBYARCHDIR)
-	$(Q) $(TOUCH) $@
-
-site-install: site-install-so site-install-rb
-site-install-so: install-so
-site-install-rb: install-rb
-
-.SUFFIXES: .c .m .cc .mm .cxx .cpp .o .S
-
-.cc.o:
-	$(ECHO) compiling $(<)
-	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
-
-.cc.S:
-	$(ECHO) translating $(<)
-	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $<
-
-.mm.o:
-	$(ECHO) compiling $(<)
-	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
-
-.mm.S:
-	$(ECHO) translating $(<)
-	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $<
-
-.cxx.o:
-	$(ECHO) compiling $(<)
-	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
-
-.cxx.S:
-	$(ECHO) translating $(<)
-	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $<
-
-.cpp.o:
-	$(ECHO) compiling $(<)
-	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
-
-.cpp.S:
-	$(ECHO) translating $(<)
-	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $<
-
-.c.o:
-	$(ECHO) compiling $(<)
-	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $<
-
-.c.S:
-	$(ECHO) translating $(<)
-	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -S $<
-
-.m.o:
-	$(ECHO) compiling $(<)
-	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $<
-
-.m.S:
-	$(ECHO) translating $(<)
-	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -S $<
-
-$(DLLIB): $(OBJS) Makefile
-	$(ECHO) linking shared-object $(DLLIB)
-	-$(Q)$(RM) $(@)
-	$(Q) $(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
-
-
-
-$(OBJS): $(HDRS) $(ruby_headers)

data/spec/ffi/enum_spec.rb

@@ -1,423 +0,0 @@
-#
-# This file is part of ruby-ffi.
-# For licensing, see LICENSE.SPECS
-#
-
-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
-
-module TestEnum4
-  extend FFI::Library
-  ffi_lib TestLibrary::PATH
-
-  enum [:c1, :c2, :c3, :c4]
-  enum :enum_type1, [:c5, 0x42, :c6, :c7, :c8]
-  enum :enum_type2, [:c9, 0x42, :c10, :c11, 0x4242, :c12]
-  enum :enum_type3, [:c13, 0x42, :c14, 0x4242, :c15, 0x42424242, :c16, 0x4242424242424242]
-  enum FFI::Type::UINT16, :enum_type4, [:c17, 0x42, :c18, :c19, :c20]
-  enum FFI::Type::UINT32, :enum_type5, [:c21, 0x42, :c22, :c23, 0x4242, :c24]
-  enum FFI::Type::UINT64, :enum_type6, [:c25, 0x42, :c26, 0x4242, :c27, 0x42424242, :c28, 0x4242424242424242]
-  enum FFI::Type::UINT64, [:c29, 0x4242424242424242, :c30, :c31, :c32]
-
-  attach_function :test_untagged_nonint_enum, [:uint8],  :uint8
-  attach_function :test_tagged_nonint_enum1,  [:uint16], :uint16
-  attach_function :test_tagged_nonint_enum2,  [:uint32], :uint32
-  attach_function :test_tagged_nonint_enum3,  [:uint64], :uint64
-  attach_function :test_tagged_nonint_enum4, :test_tagged_nonint_enum1,  [:enum_type4], :enum_type4
-  attach_function :test_tagged_nonint_enum5, :test_tagged_nonint_enum2,  [:enum_type5], :enum_type5
-  attach_function :test_tagged_nonint_enum6, :test_tagged_nonint_enum3,  [:enum_type6], :enum_type6
-end
-
-describe "A library with no enum defined" do
-  it "returns nil when asked for an enum" do
-    expect(TestEnum0.enum_type(:foo)).to be_nil
-  end
-end
-
-describe "An untagged enum" do
-  it "constants can be used as function parameters and return value" do
-    expect(TestEnum1.test_untagged_enum(:c1)).to eq(0)
-    expect(TestEnum1.test_untagged_enum(:c2)).to eq(1)
-    expect(TestEnum1.test_untagged_enum(:c3)).to eq(2)
-    expect(TestEnum1.test_untagged_enum(:c4)).to eq(3)
-    expect(TestEnum1.test_untagged_enum(:c5)).to eq(42)
-    expect(TestEnum1.test_untagged_enum(:c6)).to eq(43)
-    expect(TestEnum1.test_untagged_enum(:c7)).to eq(44)
-    expect(TestEnum1.test_untagged_enum(:c8)).to eq(45)
-    expect(TestEnum1.test_untagged_enum(:c9)).to eq(42)
-    expect(TestEnum1.test_untagged_enum(:c10)).to eq(43)
-    expect(TestEnum1.test_untagged_enum(:c11)).to eq(4242)
-    expect(TestEnum1.test_untagged_enum(:c12)).to eq(4243)
-    expect(TestEnum1.test_untagged_enum(:c13)).to eq(42)
-    expect(TestEnum1.test_untagged_enum(:c14)).to eq(4242)
-    expect(TestEnum1.test_untagged_enum(:c15)).to eq(424242)
-    expect(TestEnum1.test_untagged_enum(:c16)).to eq(42424242)
-    expect(TestEnum4.test_untagged_nonint_enum(:c1)).to eq(0)
-    expect(TestEnum4.test_untagged_nonint_enum(:c2)).to eq(1)
-    expect(TestEnum4.test_untagged_nonint_enum(:c3)).to eq(2)
-    expect(TestEnum4.test_untagged_nonint_enum(:c4)).to eq(3)
-    expect(TestEnum4.test_tagged_nonint_enum3(:c29)).to eq(0x4242424242424242)
-    expect(TestEnum4.test_tagged_nonint_enum3(:c30)).to eq(0x4242424242424243)
-    expect(TestEnum4.test_tagged_nonint_enum3(:c31)).to eq(0x4242424242424244)
-    expect(TestEnum4.test_tagged_nonint_enum3(:c32)).to eq(0x4242424242424245)
-  end
-end
-
-describe "A tagged typedef enum" do
-  it "is accessible through its tag" do
-    expect(TestEnum3.enum_type(:enum_type1)).not_to be_nil
-    expect(TestEnum3.enum_type(:enum_type2)).not_to be_nil
-    expect(TestEnum3.enum_type(:enum_type3)).not_to be_nil
-    expect(TestEnum3.enum_type(:enum_type4)).not_to be_nil
-    expect(TestEnum4.enum_type(:enum_type1)).not_to be_nil
-    expect(TestEnum4.enum_type(:enum_type2)).not_to be_nil
-    expect(TestEnum4.enum_type(:enum_type3)).not_to be_nil
-    expect(TestEnum4.enum_type(:enum_type4)).not_to be_nil
-    expect(TestEnum4.enum_type(:enum_type5)).not_to be_nil
-    expect(TestEnum4.enum_type(:enum_type6)).not_to be_nil
-  end
-
-  it "contains enum constants" do
-    expect(TestEnum3.enum_type(:enum_type1).symbols.length).to eq(4)
-    expect(TestEnum3.enum_type(:enum_type2).symbols.length).to eq(4)
-    expect(TestEnum3.enum_type(:enum_type3).symbols.length).to eq(4)
-    expect(TestEnum3.enum_type(:enum_type4).symbols.length).to eq(4)
-    expect(TestEnum4.enum_type(:enum_type1).symbols.length).to eq(4)
-    expect(TestEnum4.enum_type(:enum_type2).symbols.length).to eq(4)
-    expect(TestEnum4.enum_type(:enum_type3).symbols.length).to eq(4)
-    expect(TestEnum4.enum_type(:enum_type4).symbols.length).to eq(4)
-    expect(TestEnum4.enum_type(:enum_type5).symbols.length).to eq(4)
-    expect(TestEnum4.enum_type(:enum_type6).symbols.length).to eq(4)
-  end
-
-  it "constants can be used as function parameters and return value" do
-    expect(TestEnum3.test_tagged_typedef_enum1(:c1)).to be :c1
-    expect(TestEnum3.test_tagged_typedef_enum1(:c2)).to be :c2
-    expect(TestEnum3.test_tagged_typedef_enum1(:c3)).to be :c3
-    expect(TestEnum3.test_tagged_typedef_enum1(:c4)).to be :c4
-    expect(TestEnum3.test_tagged_typedef_enum2(:c5)).to be :c5
-    expect(TestEnum3.test_tagged_typedef_enum2(:c6)).to be :c6
-    expect(TestEnum3.test_tagged_typedef_enum2(:c7)).to be :c7
-    expect(TestEnum3.test_tagged_typedef_enum2(:c8)).to be :c8
-    expect(TestEnum3.test_tagged_typedef_enum3(:c9)).to be :c9
-    expect(TestEnum3.test_tagged_typedef_enum3(:c10)).to be :c10
-    expect(TestEnum3.test_tagged_typedef_enum3(:c11)).to be :c11
-    expect(TestEnum3.test_tagged_typedef_enum3(:c12)).to be :c12
-    expect(TestEnum3.test_tagged_typedef_enum4(:c13)).to be :c13
-    expect(TestEnum3.test_tagged_typedef_enum4(:c14)).to be :c14
-    expect(TestEnum3.test_tagged_typedef_enum4(:c15)).to be :c15
-    expect(TestEnum3.test_tagged_typedef_enum4(:c16)).to be :c16
-    expect(TestEnum4.test_tagged_nonint_enum1(:c5)).to eq(0x42)
-    expect(TestEnum4.test_tagged_nonint_enum1(:c6)).to eq(0x43)
-    expect(TestEnum4.test_tagged_nonint_enum1(:c7)).to eq(0x44)
-    expect(TestEnum4.test_tagged_nonint_enum1(:c8)).to eq(0x45)
-    expect(TestEnum4.test_tagged_nonint_enum2(:c9)).to eq(0x42)
-    expect(TestEnum4.test_tagged_nonint_enum2(:c10)).to eq(0x43)
-    expect(TestEnum4.test_tagged_nonint_enum2(:c11)).to eq(0x4242)
-    expect(TestEnum4.test_tagged_nonint_enum2(:c12)).to eq(0x4243)
-    expect(TestEnum4.test_tagged_nonint_enum3(:c13)).to eq(0x42)
-    expect(TestEnum4.test_tagged_nonint_enum3(:c14)).to eq(0x4242)
-    expect(TestEnum4.test_tagged_nonint_enum3(:c15)).to eq(0x42424242)
-    expect(TestEnum4.test_tagged_nonint_enum3(:c16)).to eq(0x4242424242424242)
-    expect(TestEnum4.test_tagged_nonint_enum4(:c17)).to eq(:c17)
-    expect(TestEnum4.test_tagged_nonint_enum4(:c18)).to eq(:c18)
-    expect(TestEnum4.test_tagged_nonint_enum4(:c19)).to eq(:c19)
-    expect(TestEnum4.test_tagged_nonint_enum4(:c20)).to eq(:c20)
-    expect(TestEnum4.test_tagged_nonint_enum5(:c21)).to eq(:c21)
-    expect(TestEnum4.test_tagged_nonint_enum5(:c22)).to eq(:c22)
-    expect(TestEnum4.test_tagged_nonint_enum5(:c23)).to eq(:c23)
-    expect(TestEnum4.test_tagged_nonint_enum5(:c24)).to eq(:c24)
-    expect(TestEnum4.test_tagged_nonint_enum6(:c25)).to eq(:c25)
-    expect(TestEnum4.test_tagged_nonint_enum6(:c26)).to eq(:c26)
-    expect(TestEnum4.test_tagged_nonint_enum6(:c27)).to eq(:c27)
-    expect(TestEnum4.test_tagged_nonint_enum6(:c28)).to eq(:c28)
-  end
-
-  it "integers can be used instead of constants" do
-    expect(TestEnum3.test_tagged_typedef_enum1(0)).to be :c1
-    expect(TestEnum3.test_tagged_typedef_enum1(1)).to be :c2
-    expect(TestEnum3.test_tagged_typedef_enum1(2)).to be :c3
-    expect(TestEnum3.test_tagged_typedef_enum1(3)).to be :c4
-    expect(TestEnum3.test_tagged_typedef_enum2(42)).to be :c5
-    expect(TestEnum3.test_tagged_typedef_enum2(43)).to be :c6
-    expect(TestEnum3.test_tagged_typedef_enum2(44)).to be :c7
-    expect(TestEnum3.test_tagged_typedef_enum2(45)).to be :c8
-    expect(TestEnum3.test_tagged_typedef_enum3(42)).to be :c9
-    expect(TestEnum3.test_tagged_typedef_enum3(43)).to be :c10
-    expect(TestEnum3.test_tagged_typedef_enum3(4242)).to be :c11
-    expect(TestEnum3.test_tagged_typedef_enum3(4243)).to be :c12
-    expect(TestEnum3.test_tagged_typedef_enum4(42)).to be :c13
-    expect(TestEnum3.test_tagged_typedef_enum4(4242)).to be :c14
-    expect(TestEnum3.test_tagged_typedef_enum4(424242)).to be :c15
-    expect(TestEnum3.test_tagged_typedef_enum4(42424242)).to be :c16
-    expect(TestEnum4.test_tagged_nonint_enum4(0x42)).to eq(:c17)
-    expect(TestEnum4.test_tagged_nonint_enum4(0x43)).to eq(:c18)
-    expect(TestEnum4.test_tagged_nonint_enum4(0x44)).to eq(:c19)
-    expect(TestEnum4.test_tagged_nonint_enum4(0x45)).to eq(:c20)
-    expect(TestEnum4.test_tagged_nonint_enum5(0x42)).to eq(:c21)
-    expect(TestEnum4.test_tagged_nonint_enum5(0x43)).to eq(:c22)
-    expect(TestEnum4.test_tagged_nonint_enum5(0x4242)).to eq(:c23)
-    expect(TestEnum4.test_tagged_nonint_enum5(0x4243)).to eq(:c24)
-    expect(TestEnum4.test_tagged_nonint_enum6(0x42)).to eq(:c25)
-    expect(TestEnum4.test_tagged_nonint_enum6(0x4242)).to eq(:c26)
-    expect(TestEnum4.test_tagged_nonint_enum6(0x42424242)).to eq(:c27)
-    expect(TestEnum4.test_tagged_nonint_enum6(0x4242424242424242)).to eq(:c28)
-  end
-end
-
-describe "All enums" do
-  it "have autonumbered constants when defined with names only" do
-    expect(TestEnum1.enum_value(:c1)).to eq(0)
-    expect(TestEnum1.enum_value(:c2)).to eq(1)
-    expect(TestEnum1.enum_value(:c3)).to eq(2)
-    expect(TestEnum1.enum_value(:c4)).to eq(3)
-
-    expect(TestEnum3.enum_value(:c1)).to eq(0)
-    expect(TestEnum3.enum_value(:c2)).to eq(1)
-    expect(TestEnum3.enum_value(:c3)).to eq(2)
-    expect(TestEnum3.enum_value(:c4)).to eq(3)
-
-    expect(TestEnum4.enum_value(:c1)).to eq(0)
-    expect(TestEnum4.enum_value(:c2)).to eq(1)
-    expect(TestEnum4.enum_value(:c3)).to eq(2)
-    expect(TestEnum4.enum_value(:c4)).to eq(3)
-  end
-
-  it "can have an explicit first constant and autonumbered subsequent constants" do
-    expect(TestEnum1.enum_value(:c5)).to eq(42)
-    expect(TestEnum1.enum_value(:c6)).to eq(43)
-    expect(TestEnum1.enum_value(:c7)).to eq(44)
-    expect(TestEnum1.enum_value(:c8)).to eq(45)
-
-    expect(TestEnum3.enum_value(:c5)).to eq(42)
-    expect(TestEnum3.enum_value(:c6)).to eq(43)
-    expect(TestEnum3.enum_value(:c7)).to eq(44)
-    expect(TestEnum3.enum_value(:c8)).to eq(45)
-
-    expect(TestEnum4.enum_value(:c5)).to eq(0x42)
-    expect(TestEnum4.enum_value(:c6)).to eq(0x43)
-    expect(TestEnum4.enum_value(:c7)).to eq(0x44)
-    expect(TestEnum4.enum_value(:c8)).to eq(0x45)
-
-    expect(TestEnum4.enum_value(:c29)).to eq(0x4242424242424242)
-    expect(TestEnum4.enum_value(:c30)).to eq(0x4242424242424243)
-    expect(TestEnum4.enum_value(:c31)).to eq(0x4242424242424244)
-    expect(TestEnum4.enum_value(:c32)).to eq(0x4242424242424245)
-  end
-
-  it "can have a mix of explicit and autonumbered constants" do
-    expect(TestEnum1.enum_value(:c9)).to eq(42)
-    expect(TestEnum1.enum_value(:c10)).to eq(43)
-    expect(TestEnum1.enum_value(:c11)).to eq(4242)
-    expect(TestEnum1.enum_value(:c12)).to eq(4243)
-
-    expect(TestEnum3.enum_value(:c9)).to eq(42)
-    expect(TestEnum3.enum_value(:c10)).to eq(43)
-    expect(TestEnum3.enum_value(:c11)).to eq(4242)
-    expect(TestEnum3.enum_value(:c12)).to eq(4243)
-
-    expect(TestEnum4.enum_value(:c9)).to eq(0x42)
-    expect(TestEnum4.enum_value(:c10)).to eq(0x43)
-    expect(TestEnum4.enum_value(:c11)).to eq(0x4242)
-    expect(TestEnum4.enum_value(:c12)).to eq(0x4243)
-
-    expect(TestEnum4.enum_value(:c21)).to eq(0x42)
-    expect(TestEnum4.enum_value(:c22)).to eq(0x43)
-    expect(TestEnum4.enum_value(:c23)).to eq(0x4242)
-    expect(TestEnum4.enum_value(:c24)).to eq(0x4243)
-  end
-
-  it "can have all its constants explicitely valued" do
-    expect(TestEnum1.enum_value(:c13)).to eq(42)
-    expect(TestEnum1.enum_value(:c14)).to eq(4242)
-    expect(TestEnum1.enum_value(:c15)).to eq(424242)
-    expect(TestEnum1.enum_value(:c16)).to eq(42424242)
-    
-    expect(TestEnum3.enum_value(:c13)).to eq(42)
-    expect(TestEnum3.enum_value(:c14)).to eq(4242)
-    expect(TestEnum3.enum_value(:c15)).to eq(424242)
-    expect(TestEnum3.enum_value(:c16)).to eq(42424242)
-
-    expect(TestEnum4.enum_value(:c13)).to eq(0x42)
-    expect(TestEnum4.enum_value(:c14)).to eq(0x4242)
-    expect(TestEnum4.enum_value(:c15)).to eq(0x42424242)
-    expect(TestEnum4.enum_value(:c16)).to eq(0x4242424242424242)
-
-    expect(TestEnum4.enum_value(:c25)).to eq(0x42)
-    expect(TestEnum4.enum_value(:c26)).to eq(0x4242)
-    expect(TestEnum4.enum_value(:c27)).to eq(0x42424242)
-    expect(TestEnum4.enum_value(:c28)).to eq(0x4242424242424242)
-  end
-
-  it "return the constant corresponding to a specific value" do
-    enum = TestEnum3.enum_type(:enum_type1)
-    expect(enum[0]).to be :c1
-    expect(enum[1]).to be :c2
-    expect(enum[2]).to be :c3
-    expect(enum[3]).to be :c4
-
-    enum = TestEnum3.enum_type(:enum_type2)
-    expect(enum[42]).to be :c5
-    expect(enum[43]).to be :c6
-    expect(enum[44]).to be :c7
-    expect(enum[45]).to be :c8
-
-    enum = TestEnum3.enum_type(:enum_type3)
-    expect(enum[42]).to be :c9
-    expect(enum[43]).to be :c10
-    expect(enum[4242]).to be :c11
-    expect(enum[4243]).to be :c12
-
-    enum = TestEnum3.enum_type(:enum_type4)
-    expect(enum[42]).to be :c13
-    expect(enum[4242]).to be :c14
-    expect(enum[424242]).to be :c15
-    expect(enum[42424242]).to be :c16
-
-    enum = TestEnum4.enum_type(:enum_type1)
-    expect(enum[0x42]).to eq(:c5)
-    expect(enum[0x43]).to eq(:c6)
-    expect(enum[0x44]).to eq(:c7)
-    expect(enum[0x45]).to eq(:c8)
-
-    enum = TestEnum4.enum_type(:enum_type2)
-    expect(enum[0x42]).to eq(:c9)
-    expect(enum[0x43]).to eq(:c10)
-    expect(enum[0x4242]).to eq(:c11)
-    expect(enum[0x4243]).to eq(:c12)
-
-    enum = TestEnum4.enum_type(:enum_type3)
-    expect(enum[0x42]).to eq(:c13)
-    expect(enum[0x4242]).to eq(:c14)
-    expect(enum[0x42424242]).to eq(:c15)
-    expect(enum[0x4242424242424242]).to eq(:c16)
-
-    enum = TestEnum4.enum_type(:enum_type4)
-    expect(enum[0x42]).to eq(:c17)
-    expect(enum[0x43]).to eq(:c18)
-    expect(enum[0x44]).to eq(:c19)
-    expect(enum[0x45]).to eq(:c20)
-
-    enum = TestEnum4.enum_type(:enum_type5)
-    expect(enum[0x42]).to eq(:c21)
-    expect(enum[0x43]).to eq(:c22)
-    expect(enum[0x4242]).to eq(:c23)
-    expect(enum[0x4243]).to eq(:c24)
-
-    enum = TestEnum4.enum_type(:enum_type6)
-    expect(enum[0x42]).to eq(:c25)
-    expect(enum[0x4242]).to eq(:c26)
-    expect(enum[0x42424242]).to eq(:c27)
-    expect(enum[0x4242424242424242]).to eq(:c28)
-  end
-
-  it "return nil for values that don't have a symbol" do
-    enum = TestEnum3.enum_type(:enum_type1)
-    expect(enum[-1]).to be_nil
-    expect(enum[4]).to be_nil
-
-    enum = TestEnum3.enum_type(:enum_type2)
-    expect(enum[0]).to be_nil
-    expect(enum[41]).to be_nil
-    expect(enum[46]).to be_nil
-
-    enum = TestEnum3.enum_type(:enum_type3)
-    expect(enum[0]).to be_nil
-    expect(enum[41]).to be_nil
-    expect(enum[44]).to be_nil
-    expect(enum[4241]).to be_nil
-    expect(enum[4244]).to be_nil
-
-    enum = TestEnum3.enum_type(:enum_type4)
-    expect(enum[0]).to be_nil
-    expect(enum[41]).to be_nil
-    expect(enum[43]).to be_nil
-    expect(enum[4241]).to be_nil
-    expect(enum[4243]).to be_nil
-    expect(enum[424241]).to be_nil
-    expect(enum[424243]).to be_nil
-    expect(enum[42424241]).to be_nil
-    expect(enum[42424243]).to be_nil
-
-    enum = TestEnum4.enum_type(:enum_type1)
-    expect(enum[0x0]).to be_nil
-    expect(enum[0x41]).to be_nil
-    expect(enum[0x46]).to be_nil
-
-    enum = TestEnum4.enum_type(:enum_type2)
-    expect(enum[0x0]).to be_nil
-    expect(enum[0x41]).to be_nil
-    expect(enum[0x44]).to be_nil
-    expect(enum[0x4241]).to be_nil
-    expect(enum[0x4244]).to be_nil
-
-    enum = TestEnum4.enum_type(:enum_type3)
-    expect(enum[0x0]).to be_nil
-    expect(enum[0x41]).to be_nil
-    expect(enum[0x43]).to be_nil
-    expect(enum[0x4241]).to be_nil
-    expect(enum[0x4243]).to be_nil
-    expect(enum[0x42424241]).to be_nil
-    expect(enum[0x42424243]).to be_nil
-    expect(enum[0x4242424242424241]).to be_nil
-    expect(enum[0x4242424242424243]).to be_nil
-
-    enum = TestEnum4.enum_type(:enum_type4)
-    expect(enum[0x0]).to be_nil
-    expect(enum[0x41]).to be_nil
-    expect(enum[0x46]).to be_nil
-
-    enum = TestEnum4.enum_type(:enum_type5)
-    expect(enum[0x0]).to be_nil
-    expect(enum[0x41]).to be_nil
-    expect(enum[0x44]).to be_nil
-    expect(enum[0x4241]).to be_nil
-    expect(enum[0x4244]).to be_nil
-
-    enum = TestEnum4.enum_type(:enum_type6)
-    expect(enum[0x0]).to be_nil
-    expect(enum[0x41]).to be_nil
-    expect(enum[0x43]).to be_nil
-    expect(enum[0x4241]).to be_nil
-    expect(enum[0x4243]).to be_nil
-    expect(enum[0x42424241]).to be_nil
-    expect(enum[0x42424243]).to be_nil
-    expect(enum[0x4242424242424241]).to be_nil
-    expect(enum[0x4242424242424243]).to be_nil
-  end
-
-  it "duplicate enum keys rejected" do
-    expect { enum [ :a, 0xfee1dead, :b, 0xdeadbeef, :a, 0 ] }.to raise_error
-    expect { enum FFI::Type::UINT64, [ :a, 0xfee1dead, :b, 0xdeadbeef, :a, 0 ] }.to raise_error
-  end
-end