ffi 1.9.21 → 1.9.22

data/spec/ffi/memorypointer_spec.rb

@@ -1,78 +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"))
-
-MemoryPointer = FFI::MemoryPointer
-
-describe "MemoryPointer#total" do
-  it "MemoryPointer.new(:char, 1).total == 1" do
-    expect(MemoryPointer.new(:char, 1).total).to eq 1
-  end
-
-  it "MemoryPointer.new(:short, 1).total == 2" do
-    expect(MemoryPointer.new(:short, 1).total).to eq 2
-  end
-
-  it "MemoryPointer.new(:int, 1).total == 4" do
-    expect(MemoryPointer.new(:int, 1).total).to eq 4
-  end
-
-  it "MemoryPointer.new(:long_long, 1).total == 8" do
-    expect(MemoryPointer.new(:long_long, 1).total).to eq 8
-  end
-
-  it "MemoryPointer.new(1024).total == 1024" do
-    expect(MemoryPointer.new(1024).total).to eq 1024
-  end
-end
-describe "MemoryPointer#read_array_of_long" do
-  it "foo" do
-    ptr = MemoryPointer.new(:long, 1024)
-    ptr[0].write_long 1234
-    ptr[1].write_long 5678
-    l = ptr.read_array_of_long(2)
-    expect(l[0]).to eq 1234
-    expect(l[1]).to eq 5678
-  end
-end
-describe "MemoryPointer argument" do
-  module Ptr
-    extend FFI::Library
-    ffi_lib FFI::Platform::LIBC
-    attach_function :memset, [ :pointer, :int, :ulong ], :pointer
-    attach_function :memcpy, [ :pointer, :pointer, :ulong ], :pointer
-  end
-
-  it "Pointer passed correctly" do
-    p = MemoryPointer.new :int, 1
-    ret = Ptr.memset(p, 0, p.total)
-    expect(ret).to eq p
-  end
-
-  it "Data passed to native function" do
-    p = MemoryPointer.new :int, 1
-    p2 = MemoryPointer.new :int, 1
-    p2.put_int(0, 0x5eadbeef)
-    Ptr.memcpy(p, p2, p.total)
-    expect(p.get_int(0)).to eq p2.get_int(0)
-    expect(p2.get_int(0)).not_to eql 0
-  end
-end
-describe "MemoryPointer return value" do
-  module Stdio
-    extend FFI::Library
-    ffi_lib FFI::Platform::LIBC
-    attach_function :fopen, [ :string, :string ], :pointer
-    attach_function :fclose, [ :pointer ], :int
-    attach_function :fwrite, [ :pointer, :ulong, :ulong, :string ], :ulong
-  end
-
-  it "fopen returns non-nil" do
-    fp = Stdio.fopen("/dev/null", "w")
-    expect(fp).to_not be_nil
-    expect(Stdio.fclose(fp)).to  eq 0 unless fp.nil? or fp.null? 
-  end
-end

data/spec/ffi/number_spec.rb

@@ -1,247 +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 "Function with primitive integer arguments" do
-  module LibTest
-    extend FFI::Library
-    ffi_lib TestLibrary::PATH
-    attach_function :ret_s8, [ :char ], :char
-    attach_function :ret_u8, [ :uchar ], :uchar
-    attach_function :ret_s16, [ :short ], :short
-    attach_function :ret_u16, [ :ushort ], :ushort
-    attach_function :ret_s32, [ :int ], :int
-    attach_function :ret_u32, [ :uint ], :uint
-    attach_function :ret_s64, [ :long_long ], :long_long
-    attach_function :ret_u64, [ :ulong_long ], :ulong_long
-    attach_function :ret_long, [ :long ], :long
-    attach_function :ret_ulong, [ :ulong ], :ulong
-    attach_function :set_s8, [ :char ], :void
-    attach_function :get_s8, [ ], :char
-    attach_function :set_float, [ :float ], :void
-    attach_function :get_float, [ ], :float
-    attach_function :set_double, [ :double ], :void
-    attach_function :get_double, [ ], :double
-  end
-
-  it "int8.size" do
-    expect(FFI::TYPE_INT8.size).to eq(1)
-  end
-
-  it "uint8.size" do
-    expect(FFI::TYPE_UINT8.size).to eq(1)
-  end
-
-  it "int16.size" do
-    expect(FFI::TYPE_INT16.size).to eq(2)
-  end
-
-  it "uint16.size" do
-    expect(FFI::TYPE_UINT16.size).to eq(2)
-  end
-
-  it "int32.size" do
-    expect(FFI::TYPE_INT32.size).to eq(4)
-  end
-
-  it "uint32.size" do
-    expect(FFI::TYPE_UINT32.size).to eq(4)
-  end
-
-  it "int64.size" do
-    expect(FFI::TYPE_INT64.size).to eq(8)
-  end
-
-  it "uint64.size" do
-    expect(FFI::TYPE_UINT64.size).to eq(8)
-  end
-
-  it "float.size" do
-    expect(FFI::TYPE_FLOAT32.size).to eq(4)
-  end
-
-  it "double.size" do
-    expect(FFI::TYPE_FLOAT64.size).to eq(8)
-  end
-  [ 0, 127, -128, -1 ].each do |i|
-    it ":char call(:char (#{i}))" do
-      expect(LibTest.ret_s8(i)).to eq(i)
-    end
-  end
-  [ 0, 0x7f, 0x80, 0xff ].each do |i|
-    it ":uchar call(:uchar (#{i}))" do
-      expect(LibTest.ret_u8(i)).to eq(i)
-    end
-  end
-  [ 0, 0x7fff, -0x8000, -1 ].each do |i|
-    it ":short call(:short (#{i}))" do
-      expect(LibTest.ret_s16(i)).to eq(i)
-    end
-  end
-  [ 0, 0x7fff, 0x8000, 0xffff ].each do |i|
-    it ":ushort call(:ushort (#{i}))" do
-      expect(LibTest.ret_u16(i)).to eq(i)
-    end
-  end
-  [ 0, 0x7fffffff, -0x80000000, -1 ].each do |i|
-    it ":int call(:int (#{i}))" do
-      expect(LibTest.ret_s32(i)).to eq(i)
-    end
-  end
-  [ 0, 0x7fffffff, 0x80000000, 0xffffffff ].each do |i|
-    it ":uint call(:uint (#{i}))" do
-      expect(LibTest.ret_u32(i)).to eq(i)
-    end
-  end
-  [ 0, 0x7fffffffffffffff, -0x8000000000000000, -1 ].each do |i|
-    it ":long_long call(:long_long (#{i}))" do
-      expect(LibTest.ret_s64(i)).to eq(i)
-    end
-  end
-  [ 0, 0x7fffffffffffffff, 0x8000000000000000, 0xffffffffffffffff ].each do |i|
-    it ":ulong_long call(:ulong_long (#{i}))" do
-      expect(LibTest.ret_u64(i)).to eq(i)
-    end
-  end
-  if FFI::Platform::LONG_SIZE == 32
-    [ 0, 0x7fffffff, -0x80000000, -1 ].each do |i|
-      it ":long call(:long (#{i}))" do
-        expect(LibTest.ret_long(i)).to eq(i)
-      end
-    end
-    [ 0, 0x7fffffff, 0x80000000, 0xffffffff ].each do |i|
-      it ":ulong call(:ulong (#{i}))" do
-        expect(LibTest.ret_ulong(i)).to eq(i)
-      end
-    end
-  else
-    [ 0, 0x7fffffffffffffff, -0x8000000000000000, -1 ].each do |i|
-      it ":long call(:long (#{i}))" do
-        expect(LibTest.ret_long(i)).to eq(i)
-      end
-    end
-    [ 0, 0x7fffffffffffffff, 0x8000000000000000, 0xffffffffffffffff ].each do |i|
-      it ":ulong call(:ulong (#{i}))" do
-        expect(LibTest.ret_ulong(i)).to eq(i)
-      end
-    end
-    [ 0.0, 0.1, 1.1, 1.23 ].each do |f|
-      it ":float call(:double (#{f}))" do
-        LibTest.set_float(f)
-        expect((LibTest.get_float - f).abs).to be < 0.001
-      end
-    end
-    [ 0.0, 0.1, 1.1, 1.23 ].each do |f|
-      it ":double call(:double (#{f}))" do
-        LibTest.set_double(f)
-        expect((LibTest.get_double - f).abs).to be < 0.001
-      end
-    end
-  end
-end
-describe "Integer parameter range checking" do
-  [ 128, -129 ].each do |i|
-    it ":char call(:char (#{i}))" do
-      expect { expect(LibTest.ret_int8_t(i)).to eq(i) }.to raise_error
-    end
-  end
-  [ -1, 256 ].each do |i|
-    it ":uchar call(:uchar (#{i}))" do
-      expect { expect(LibTest.ret_u_int8_t(i)).to eq(i) }.to raise_error
-    end
-  end
-  [ 0x8000, -0x8001 ].each do |i|
-    it ":short call(:short (#{i}))" do
-      expect { expect(LibTest.ret_int16_t(i)).to eq(i) }.to raise_error
-    end
-  end
-  [ -1, 0x10000 ].each do |i|
-    it ":ushort call(:ushort (#{i}))" do
-      expect { expect(LibTest.ret_u_int16_t(i)).to eq(i) }.to raise_error
-    end
-  end
-  [ 0x80000000, -0x80000001 ].each do |i|
-    it ":int call(:int (#{i}))" do
-      expect { expect(LibTest.ret_int32_t(i)).to eq(i) }.to raise_error
-    end
-  end
-  [ -1, 0x100000000 ].each do |i|
-    it ":ushort call(:ushort (#{i}))" do
-      expect { expect(LibTest.ret_u_int32_t(i)).to eq(i) }.to raise_error
-    end
-  end
-end
-describe "Three different size Integer arguments" do
-  TYPE_MAP = {
-    's8' => :char, 'u8' => :uchar, 's16' => :short, 'u16' => :ushort,
-    's32' => :int, 'u32' => :uint, 's64' => :long_long, 'u64' => :ulong_long,
-    'sL' => :long, 'uL' => :ulong, 'f32' => :float, 'f64' => :double
-  }
-  TYPES = TYPE_MAP.keys
-  module LibTest
-    extend FFI::Library
-    ffi_lib TestLibrary::PATH
-    
-    
-    [ 's32', 'u32', 's64', 'u64' ].each do |rt|
-      TYPES.each do |t1|
-        TYPES.each do |t2|
-          TYPES.each do |t3|
-            begin
-              attach_function "pack_#{t1}#{t2}#{t3}_#{rt}",
-                [ TYPE_MAP[t1], TYPE_MAP[t2], TYPE_MAP[t3], :buffer_out ], :void
-            rescue FFI::NotFoundError
-            end
-          end
-        end
-      end
-    end
-  end
-
-  PACK_VALUES = {
-    's8' => [ 0x12  ],
-    'u8' => [ 0x34  ],
-    's16' => [ 0x5678 ],
-    'u16' => [ 0x9abc ],
-    's32' => [ 0x7654321f ],
-    'u32' => [ 0xfee1babe ],
-    'sL' => [ 0x1f2e3d4c ],
-    'uL' => [ 0xf7e8d9ca ],
-    's64' => [ 0x1eafdeadbeefa1b2 ],
-#    'f32' => [ 1.234567 ],
-    'f64' => [ 9.87654321 ]
-  }
-
-  def verify(p, off, t, v)
-    if t == 'f32'
-      expect(p.get_float32(off)).to eq(v)
-    elsif t == 'f64'
-      expect(p.get_float64(off)).to eq(v)
-    else
-      expect(p.get_int64(off)).to eq(v)
-    end
-  end
-
-  PACK_VALUES.keys.each do |t1|
-    PACK_VALUES.keys.each do |t2|
-      PACK_VALUES.keys.each do |t3|
-        PACK_VALUES[t1].each do |v1|
-          PACK_VALUES[t2].each do |v2|
-            PACK_VALUES[t3].each do |v3|
-              it "call(#{TYPE_MAP[t1]} (#{v1}), #{TYPE_MAP[t2]} (#{v2}), #{TYPE_MAP[t3]} (#{v3}))" do
-                p = FFI::Buffer.new :long_long, 3
-                LibTest.send("pack_#{t1}#{t2}#{t3}_s64", v1, v2, v3, p)
-                verify(p, 0, t1, v1)
-                verify(p, 8, t2, v2)
-                verify(p, 16, t3, v3)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/ffi/platform_spec.rb

@@ -1,114 +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 "FFI::Platform::LIBSUFFIX" do
-  case OS
-  when "linux"
-    it "returns 'so'" do
-      expect(FFI::Platform::LIBSUFFIX).to eq('so')
-    end
-  when "windows"
-    it "returns 'dll'" do
-      expect(FFI::Platform::LIBSUFFIX).to eq('dll')
-    end
-  when "darwin"
-    it "returns 'dylib'" do
-      expect(FFI::Platform::LIBSUFFIX).to eq('dylib')
-    end
-  end
-end
-
-describe "FFI::Platform::IS_WINDOWS" do
-  case OS
-  when "linux"
-    it "returns false" do
-      expect(FFI::Platform::IS_WINDOWS).to be false
-    end
-  when "windows"
-    it "returns true" do
-      expect(FFI::Platform::IS_WINDOWS).to be true
-    end
-  when "darwin"
-    it "returns false" do
-      expect(FFI::Platform::IS_WINDOWS).to be false
-    end
-  end
-end
-
-describe "FFI::Platform::ARCH" do
-  it "returns the architecture type" do
-    expect(FFI::Platform::ARCH).to eq(CPU)
-  end
-end
-
-describe "FFI::Platform::OS" do
-  case OS
-  when "linux"
-    it "returns 'linux' as a string" do
-      expect(FFI::Platform::OS).to eq('linux')
-    end
-  when "windows"
-    it "returns 'windows' as a string" do
-      expect(FFI::Platform::OS).to eq('windows')
-    end
-  when "darwin"
-    it "returns 'darwin' as a string" do
-      expect(FFI::Platform::OS).to eq('darwin')
-    end
-  end
-end
-
-describe "FFI::Platform.windows?" do
-  case OS
-  when "linux"
-    it "returns false" do
-      expect(FFI::Platform.windows?).to be false
-    end
-  when "windows"
-    it "returns true" do
-      expect(FFI::Platform.windows?).to be true
-    end
-  when "darwin"
-    it "returns false" do
-      expect(FFI::Platform.windows?).to be false
-    end
-  end
-end
-
-describe "FFI::Platform.mac?" do
-  case OS
-  when "linux"
-    it "returns false" do
-      expect(FFI::Platform.mac?).to be false
-    end
-  when "windows"
-    it "returns false" do
-      expect(FFI::Platform.mac?).to be false
-    end
-  when "darwin"
-    it "returns true" do
-      expect(FFI::Platform.mac?).to be true
-    end
-  end
-end
-
-describe "FFI::Platform.unix?" do
-  case OS
-  when "linux"
-    it "returns true" do
-      expect(FFI::Platform.unix?).to be true
-    end
-  when "windows"
-    it "returns false" do
-      expect(FFI::Platform.unix?).to be false
-    end
-  when "darwin"
-    it "returns true" do
-      expect(FFI::Platform.unix?).to be true
-    end
-  end
-end

data/spec/ffi/pointer_spec.rb

@@ -1,285 +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"))
-require 'delegate'
-
-module PointerTestLib
-  extend FFI::Library
-  ffi_lib TestLibrary::PATH
-  begin
-    attach_function :ptr_ret_int32_t, [ :pointer, :int ], :int
-  rescue FFI::NotFoundError
-    # NetBSD uses #define instead of typedef for these
-    attach_function :ptr_ret_int32_t, :ptr_ret___int32_t, [ :pointer, :int ], :int
-  end
-  attach_function :ptr_from_address, [ FFI::Platform::ADDRESS_SIZE == 32 ? :uint : :ulong_long ], :pointer
-  attach_function :ptr_set_pointer, [ :pointer, :int, :pointer ], :void
-  attach_function :ptr_ret_pointer, [ :pointer, :int ], :pointer
-end
-describe "Pointer" do
-  include FFI
-  class ToPtrTest
-    def initialize(ptr)
-      @ptr = ptr
-    end
-    def to_ptr
-      @ptr
-    end
-  end
-
-  it "Any object implementing #to_ptr can be passed as a :pointer parameter" do
-    memory = FFI::MemoryPointer.new :long_long
-    magic = 0x12345678
-    memory.put_int32(0, magic)
-    tp = ToPtrTest.new(memory)
-    expect(PointerTestLib.ptr_ret_int32_t(tp, 0)).to eq(magic)
-  end
-  class PointerDelegate < DelegateClass(FFI::Pointer)
-    def initialize(ptr)
-      @ptr = ptr
-    end
-    def to_ptr
-      @ptr
-    end
-  end
-
-  it "A DelegateClass(Pointer) can be passed as a :pointer parameter" do
-    memory = FFI::MemoryPointer.new :long_long
-    magic = 0x12345678
-    memory.put_int32(0, magic)
-    ptr = PointerDelegate.new(memory)
-    expect(PointerTestLib.ptr_ret_int32_t(ptr, 0)).to eq(magic)
-  end
-
-  it "Fixnum cannot be used as a Pointer argument" do
-    expect { PointerTestLib.ptr_ret_int32(0, 0) }.to raise_error
-  end
-
-  it "Bignum cannot be used as a Pointer argument" do
-    expect { PointerTestLib.ptr_ret_int32(0xfee1deadbeefcafebabe, 0) }.to raise_error
-  end
-
-  it "#to_ptr" do
-    memory = FFI::MemoryPointer.new :pointer
-    expect(memory.to_ptr).to eq(memory)
-
-    expect(FFI::Pointer::NULL.to_ptr).to eq(FFI::Pointer::NULL)
-  end
-
-  describe "pointer type methods" do
-
-    it "#read_pointer" do
-      memory = FFI::MemoryPointer.new :pointer
-      PointerTestLib.ptr_set_pointer(memory, 0, PointerTestLib.ptr_from_address(0xdeadbeef))
-      expect(memory.read_pointer.address).to eq(0xdeadbeef)
-    end
-
-    it "#write_pointer" do
-      memory = FFI::MemoryPointer.new :pointer
-      memory.write_pointer(PointerTestLib.ptr_from_address(0xdeadbeef))
-      expect(PointerTestLib.ptr_ret_pointer(memory, 0).address).to eq(0xdeadbeef)
-    end
-
-    it "#read_array_of_pointer" do
-      values = [0x12345678, 0xfeedf00d, 0xdeadbeef]
-      memory = FFI::MemoryPointer.new :pointer, values.size
-      values.each_with_index do |address, j|
-        PointerTestLib.ptr_set_pointer(memory, j * FFI.type_size(:pointer), PointerTestLib.ptr_from_address(address))
-      end
-      array = memory.read_array_of_pointer(values.size)
-      values.each_with_index do |address, j|
-        expect(array[j].address).to eq(address)
-      end
-    end
-    
-  end
-
-  describe 'NULL' do
-    it 'should be obtained using Pointer::NULL constant' do
-      null_ptr = FFI::Pointer::NULL
-      expect(null_ptr).to be_null
-    end
-    it 'should be obtained passing address 0 to constructor' do
-      expect(FFI::Pointer.new(0)).to be_null
-    end
-    it 'should raise an error when attempting read/write operations on it' do
-      null_ptr = FFI::Pointer::NULL
-      expect { null_ptr.read_int }.to raise_error(FFI::NullPointerError)
-      expect { null_ptr.write_int(0xff1) }.to raise_error(FFI::NullPointerError)
-    end
-    it 'returns true when compared with nil' do
-      expect((FFI::Pointer::NULL == nil)).to be true
-    end
-  end
-
-  it "Pointer.size returns sizeof pointer on platform" do
-    expect(FFI::Pointer.size).to eq((FFI::Platform::ADDRESS_SIZE / 8))
-  end
-
-  describe "#slice" do
-    before(:each) do
-      @mptr = FFI::MemoryPointer.new(:char, 12)
-      @mptr.put_uint(0, 0x12345678)
-      @mptr.put_uint(4, 0xdeadbeef)
-    end
-
-    it "contents of sliced pointer matches original pointer at offset" do
-      expect(@mptr.slice(4, 4).get_uint(0)).to eq(0xdeadbeef)
-    end
-
-    it "modifying sliced pointer is reflected in original pointer" do
-      @mptr.slice(4, 4).put_uint(0, 0xfee1dead)
-      expect(@mptr.get_uint(4)).to eq(0xfee1dead)
-    end
-
-    it "access beyond bounds should raise IndexError" do
-      expect { @mptr.slice(4, 4).get_int(4) }.to raise_error(IndexError)
-    end
-  end
-
-  describe "#type_size" do
-    it "should be same as FFI.type_size(type)" do
-      expect(FFI::MemoryPointer.new(:int, 1).type_size).to eq(FFI.type_size(:int))
-    end
-  end
-end
-
-describe "AutoPointer" do
-  loop_count = 30
-  wiggle_room = 5 # GC rarely cleans up all objects. we can get most of them, and that's enough to determine if the basic functionality is working.
-  magic = 0x12345678
-
-  class AutoPointerTestHelper
-    @@count = 0
-    def self.release
-      @@count += 1 if @@count > 0
-    end
-    def self.reset
-      @@count = 0
-    end
-    def self.gc_everything(count)
-      loop = 5
-      while @@count < count && loop > 0
-        loop -= 1
-        TestLibrary.force_gc
-        sleep 0.05 unless @@count == count
-      end
-      @@count = 0
-    end
-    def self.finalizer
-      self.method(:release).to_proc
-    end
-  end
-  class AutoPointerSubclass < FFI::AutoPointer
-    def self.release(ptr); end
-  end
-
-  # see #427
-  it "cleanup via default release method", :broken => true do
-    expect(AutoPointerSubclass).to receive(:release).at_least(loop_count-wiggle_room).times
-    AutoPointerTestHelper.reset
-    loop_count.times do
-      # note that if we called
-      # AutoPointerTestHelper.method(:release).to_proc inline, we'd
-      # have a reference to the pointer and it would never get GC'd.
-      AutoPointerSubclass.new(PointerTestLib.ptr_from_address(magic))
-    end
-    AutoPointerTestHelper.gc_everything loop_count
-  end
-
-  # see #427
-  it "cleanup when passed a proc", :broken => true do
-    #  NOTE: passing a proc is touchy, because it's so easy to create a memory leak.
-    #
-    #  specifically, if we made an inline call to
-    #
-    #      AutoPointerTestHelper.method(:release).to_proc
-    #
-    #  we'd have a reference to the pointer and it would
-    #  never get GC'd.
-    expect(AutoPointerTestHelper).to receive(:release).at_least(loop_count-wiggle_room).times
-    AutoPointerTestHelper.reset
-    loop_count.times do
-      FFI::AutoPointer.new(PointerTestLib.ptr_from_address(magic),
-                           AutoPointerTestHelper.finalizer)
-    end
-    AutoPointerTestHelper.gc_everything loop_count
-  end
-
-  # see #427
-  it "cleanup when passed a method", :broken => true do
-    expect(AutoPointerTestHelper).to receive(:release).at_least(loop_count-wiggle_room).times
-    AutoPointerTestHelper.reset
-    loop_count.times do
-      FFI::AutoPointer.new(PointerTestLib.ptr_from_address(magic),
-                           AutoPointerTestHelper.method(:release))
-    end
-    AutoPointerTestHelper.gc_everything loop_count
-  end
-
-  it "can be used as the return type of a function" do
-    expect do
-      Module.new do
-        extend FFI::Library
-        ffi_lib TestLibrary::PATH
-        class CustomAutoPointer < FFI::AutoPointer
-          def self.release(ptr); end
-        end
-        attach_function :ptr_from_address, [ FFI::Platform::ADDRESS_SIZE == 32 ? :uint : :ulong_long ], CustomAutoPointer
-      end
-    end.not_to raise_error
-  end
-
-  describe "#new" do
-    it "MemoryPointer argument raises TypeError" do
-      expect { FFI::AutoPointer.new(FFI::MemoryPointer.new(:int))}.to raise_error(::TypeError)
-    end
-    it "AutoPointer argument raises TypeError" do
-      expect { AutoPointerSubclass.new(AutoPointerSubclass.new(PointerTestLib.ptr_from_address(0))) }.to raise_error(::TypeError)
-    end
-    it "Buffer argument raises TypeError" do
-      expect { FFI::AutoPointer.new(FFI::Buffer.new(:int))}.to raise_error(::TypeError)
-    end
-
-  end
-
-  describe "#autorelease?" do
-    ptr_class = Class.new(FFI::AutoPointer) do
-      def self.release(ptr); end
-    end
-
-    it "should be true by default" do
-      expect(ptr_class.new(FFI::Pointer.new(0xdeadbeef)).autorelease?).to be true
-    end
-
-    it "should return false when autorelease=(false)" do
-      ptr = ptr_class.new(FFI::Pointer.new(0xdeadbeef))
-      ptr.autorelease = false
-      expect(ptr.autorelease?).to be false
-    end
-  end
-
-  describe "#type_size" do
-    ptr_class = Class.new(FFI::AutoPointer) do
-      def self.release(ptr); end
-    end
-
-    it "type_size of AutoPointer should match wrapped Pointer" do
-      aptr = ptr_class.new(FFI::Pointer.new(:int, 0xdeadbeef))
-      expect(aptr.type_size).to eq(FFI.type_size(:int))
-    end
-    
-    it "[] offset should match wrapped Pointer" do
-      mptr = FFI::MemoryPointer.new(:int, 1024)
-      aptr = ptr_class.new(FFI::Pointer.new(:int, mptr))
-      aptr[0].write_uint(0xfee1dead)
-      aptr[1].write_uint(0xcafebabe)
-      expect(mptr[0].read_uint).to eq(0xfee1dead)
-      expect(mptr[1].read_uint).to eq(0xcafebabe)
-    end
-  end
-end
-