ffi 0.3.1 → 0.4.0

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

data/spec/ffi/managed_struct_spec.rb

@@ -1,4 +1,5 @@
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+require 'java' if RUBY_PLATFORM =~ /java/
 
 describe "Managed Struct" do
   include FFI
@@ -33,7 +34,11 @@ describe "Managed Struct" do
         loop = 5
         while loop > 0 && @@count < count
           loop -= 1
-          GC.start
+          if RUBY_PLATFORM =~ /java/
+            java.lang.System.gc
+          else
+            GC.start
+          end
           sleep 0.05 if @@count < count
         end
       end

data/spec/ffi/number_spec.rb

@@ -20,6 +20,36 @@ describe "Function with primitive integer arguments" do
     attach_function :set_double, [ :double ], :void
     attach_function :get_double, [ ], :double
   end
+  it "int8.size" do
+    FFI::TYPE_INT8.size.should == 1
+  end
+  it "uint8.size" do
+    FFI::TYPE_UINT8.size.should == 1
+  end
+  it "int16.size" do
+    FFI::TYPE_INT16.size.should == 2
+  end
+  it "uint16.size" do
+    FFI::TYPE_UINT16.size.should == 2
+  end
+  it "int32.size" do
+    FFI::TYPE_INT32.size.should == 4
+  end
+  it "uint32.size" do
+    FFI::TYPE_UINT32.size.should == 4
+  end
+  it "int64.size" do
+    FFI::TYPE_INT64.size.should == 8
+  end
+  it "uint64.size" do
+    FFI::TYPE_UINT64.size.should == 8
+  end
+  it "float.size" do
+    FFI::TYPE_FLOAT32.size.should == 4
+  end
+  it "double.size" do
+    FFI::TYPE_FLOAT64.size.should == 8
+  end
   [ 0, 127, -128, -1 ].each do |i|
     it ":char call(:char (#{i}))" do
       LibTest.ret_s8(i).should == i

data/spec/ffi/pointer_spec.rb

@@ -1,5 +1,7 @@
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
 require 'delegate'
+require 'java' if RUBY_PLATFORM =~ /java/
+
 module LibTest
   attach_function :ptr_ret_int32_t, [ :pointer, :int ], :int
   attach_function :ptr_from_address, [ FFI::Platform::ADDRESS_SIZE == 32 ? :uint : :ulong_long ], :pointer
@@ -25,7 +27,6 @@ describe "Pointer" do
   end
   class PointerDelegate < DelegateClass(FFI::Pointer)
     def initialize(ptr)
-      super
       @ptr = ptr
     end
     def to_ptr
@@ -84,7 +85,22 @@ describe "Pointer" do
         array[j].address.should == address
       end
     end
+    
+  end
 
+  describe 'NULL' do
+    it 'should be obtained using Pointer::NULL constant' do
+      null_ptr = FFI::Pointer::NULL
+      null_ptr.null?.should be_true
+    end
+    it 'should be obtained passing address 0 to constructor' do
+      FFI::Pointer.new(0).null?.should be_true
+    end
+    it 'should raise an error when attempting read/write operations on it' do
+      null_ptr = FFI::Pointer::NULL
+      lambda { null_ptr.read_int }.should raise_error(FFI::NullPointerError)
+      lambda { null_ptr.write_int(0xff1) }.should raise_error(FFI::NullPointerError)
+    end
   end
 
 end
@@ -106,7 +122,11 @@ describe "AutoPointer" do
       loop = 5
       while @@count < count && loop > 0
         loop -= 1
-        GC.start
+        if RUBY_PLATFORM =~ /java/
+          java.lang.System.gc
+        else
+          GC.start
+        end
         sleep 0.05 unless @@count == count
       end
       @@count = 0
@@ -115,15 +135,17 @@ describe "AutoPointer" do
       self.method(:release).to_proc
     end
   end
-
+  class AutoPointerSubclass < FFI::AutoPointer
+    def self.release(ptr); end
+  end
   it "cleanup via default release method" do
-    FFI::AutoPointer.should_receive(:release).at_least(loop_count-wiggle_room).times
+    AutoPointerSubclass.should_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.
-      ap = FFI::AutoPointer.new(LibTest.ptr_from_address(magic))
+      ap = AutoPointerSubclass.new(LibTest.ptr_from_address(magic))
     end
     AutoPointerTestHelper.gc_everything loop_count
   end
@@ -157,14 +179,17 @@ describe "AutoPointer" do
   end
 end
 describe "AutoPointer#new" do
+  class AutoPointerSubclass < FFI::AutoPointer
+    def self.release(ptr); end
+  end
   it "MemoryPointer argument raises ArgumentError" do
-    lambda { FFI::AutoPointer.new(FFI::MemoryPointer.new(:int))}.should raise_error(ArgumentError)
+    lambda { FFI::AutoPointer.new(FFI::MemoryPointer.new(:int))}.should raise_error(::TypeError)
   end
   it "AutoPointer argument raises ArgumentError" do
-    lambda { FFI::AutoPointer.new(FFI::AutoPointer.new(LibTest.ptr_from_address(0))) }.should raise_error(ArgumentError)
+    lambda { AutoPointerSubclass.new(AutoPointerSubclass.new(LibTest.ptr_from_address(0))) }.should raise_error(::TypeError)
   end
   it "Buffer argument raises ArgumentError" do
-    lambda { FFI::AutoPointer.new(FFI::Buffer.new(:int))}.should raise_error(ArgumentError)
+    lambda { FFI::AutoPointer.new(FFI::Buffer.new(:int))}.should raise_error(::TypeError)
   end
 
 end

data/spec/ffi/rbx/memory_pointer_spec.rb

@@ -18,12 +18,6 @@ describe "MemoryPointer" do
     m.read_string.should == "FFI is Awesome"
   end
   
-  it "reads back a string from an Array of ints" do
-    m = FFI::MemoryPointer.new(:int, 4)
-    m.write_array_of_int([541673030, 1092645737, 1869833591, 538994029])
-    m.read_string(16).should == "FFI is Awesome  "
-  end
-  
   it "makes a pointer for a certain number of bytes" do
     m = FFI::MemoryPointer.new(8)
     m.write_array_of_int([1,2])

data/spec/ffi/spec_helper.rb

@@ -1,7 +1,11 @@
 require 'rubygems'
+require 'rbconfig'
 require 'spec'
 
-$:.unshift File.join(File.dirname(__FILE__), "..", "..", "lib"), File.join(File.dirname(__FILE__), "..", "..", "build", RUBY_VERSION) if ENV["MRI_FFI"]
+if ENV["MRI_FFI"]
+  $:.unshift File.join(File.dirname(__FILE__), "..", "..", "lib"),
+    File.join(File.dirname(__FILE__), "..", "..", "build", "#{Config::CONFIG['host_cpu''arch']}", "ffi_c", RUBY_VERSION)
+end
 require "ffi"
 
 module TestLibrary

data/spec/ffi/string_spec.rb

@@ -1,12 +1,13 @@
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
 describe "String tests" do
   include FFI
-  module LibTest
+  module StrLibTest
     extend FFI::Library
     ffi_lib TestLibrary::PATH
     attach_function :ptr_ret_pointer, [ :pointer, :int], :string
     attach_function :string_equals, [ :string, :string ], :int
     attach_function :string_dummy, [ :string ], :void
+    attach_function :string_null, [ ], :string
   end
   it "MemoryPointer#get_string returns a tainted string" do
     mp = MemoryPointer.new 1024
@@ -19,13 +20,13 @@ describe "String tests" do
     sp = MemoryPointer.new 1024
     sp.put_string(0, "test")
     mp.put_pointer(0, sp)
-    str = LibTest.ptr_ret_pointer(mp, 0)
+    str = StrLibTest.ptr_ret_pointer(mp, 0)
     str.should == "test"
     str.tainted?.should == true
   end
   it "Poison null byte raises error" do
     s = "123\0abc"
-    lambda { LibTest.string_equals(s, s) }.should raise_error
+    lambda { StrLibTest.string_equals(s, s) }.should raise_error
   end
   it "Tainted String parameter should throw a SecurityError" do
     $SAFE = 1
@@ -37,6 +38,66 @@ describe "String tests" do
     end
   end if false
   it "casts nil as NULL pointer" do
-    LibTest.string_dummy(nil)
+    StrLibTest.string_dummy(nil)
+  end
+  it "return nil for NULL char*" do
+    StrLibTest.string_null.should == nil
+  end
+  it "reads an array of strings until encountering a NULL pointer" do
+    strings = ["foo", "bar", "baz", "testing", "ffi"]
+    ptrary = MemoryPointer.new(:pointer, 6)
+    ary = strings.inject([]) do |a, str|
+      f = MemoryPointer.new(1024)
+      f.put_string(0, str)
+      a << f
+    end
+    ary.insert(3, nil)
+    ptrary.write_array_of_pointer(ary)
+    ptrary.get_array_of_string(0).should == ["foo", "bar", "baz"]
+  end
+  it "reads an array of strings of the size specified, substituting nil when a pointer is NULL" do
+    strings = ["foo", "bar", "baz", "testing", "ffi"]
+    ptrary = MemoryPointer.new(:pointer, 6)
+    ary = strings.inject([]) do |a, str|
+      f = MemoryPointer.new(1024)
+      f.put_string(0, str)
+      a << f
+    end
+    ary.insert(2, nil)
+    ptrary.write_array_of_pointer(ary)
+    ptrary.get_array_of_string(0, 4).should == ["foo", "bar", nil, "baz"]
+  end
+  it "reads an array of strings, taking a memory offset parameter" do
+    strings = ["foo", "bar", "baz", "testing", "ffi"]
+    ptrary = MemoryPointer.new(:pointer, 5)
+    ary = strings.inject([]) do |a, str|
+      f = MemoryPointer.new(1024)
+      f.put_string(0, str)
+      a << f
+    end
+    ptrary.write_array_of_pointer(ary)
+    ptrary.get_array_of_string(2 * FFI.type_size(:pointer), 3).should == ["baz", "testing", "ffi"]
+  end
+  it "raises an IndexError when trying to read an array of strings out of bounds" do
+    strings = ["foo", "bar", "baz", "testing", "ffi"]
+    ptrary = MemoryPointer.new(:pointer, 5)
+    ary = strings.inject([]) do |a, str|
+      f = MemoryPointer.new(1024)
+      f.put_string(0, str)
+      a << f
+    end
+    ptrary.write_array_of_pointer(ary)
+    lambda { ptrary.get_array_of_string(0, 6) }.should raise_error
+  end
+  it "raises an IndexError when trying to read an array of strings using a negative offset" do
+    strings = ["foo", "bar", "baz", "testing", "ffi"]
+    ptrary = MemoryPointer.new(:pointer, 5)
+    ary = strings.inject([]) do |a, str|
+      f = MemoryPointer.new(1024)
+      f.put_string(0, str)
+      a << f
+    end
+    ptrary.write_array_of_pointer(ary)
+    lambda { ptrary.get_array_of_string(-1) }.should raise_error
   end
 end

data/spec/ffi/struct_callback_spec.rb

@@ -0,0 +1,41 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+describe FFI::Struct, ' with inline callback functions' do
+  it 'should be able to define inline callback field' do
+    module CallbackMember
+      extend FFI::Library
+      ffi_lib TestLibrary::PATH
+      class TestStruct < FFI::Struct
+        layout \
+          :add, callback([ :int, :int ], :int),
+          :sub, callback([ :int, :int ], :int)
+        end
+      attach_function :struct_call_add_cb, [TestStruct, :int, :int], :int
+      attach_function :struct_call_sub_cb, [TestStruct, :int, :int], :int
+    end
+  end
+  it 'should take methods as callbacks' do
+    module CallbackMember
+      extend FFI::Library
+      ffi_lib TestLibrary::PATH
+      class TestStruct < FFI::Struct
+        layout \
+          :add, callback([ :int, :int ], :int),
+          :sub, callback([ :int, :int ], :int)
+        end
+      attach_function :struct_call_add_cb, [TestStruct, :int, :int], :int
+      attach_function :struct_call_sub_cb, [TestStruct, :int, :int], :int
+    end
+    module StructCallbacks
+      def self.add a, b
+        a+b
+      end
+    end
+
+    ts = CallbackMember::TestStruct.new
+    ts[:add] = StructCallbacks.method(:add)
+
+    CallbackMember.struct_call_add_cb(ts, 1, 2).should == 3
+  end
+end
+

data/spec/ffi/struct_initialize_spec.rb

@@ -0,0 +1,30 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+describe FFI::Struct, ' with an initialize function' do
+  it "should call the initialize function" do
+    class StructWithInitialize < FFI::Struct
+      layout :string, :string
+      attr_accessor :magic
+      def initialize
+        super
+        self.magic = 42
+      end
+    end
+    StructWithInitialize.new.magic.should == 42
+  end
+end
+
+describe FFI::ManagedStruct, ' with an initialize function' do
+  it "should call the initialize function" do
+    class ManagedStructWithInitialize < FFI::ManagedStruct
+      layout :string, :string
+      attr_accessor :magic
+      def initialize
+        super MemoryPointer.new(:pointer).put_int(0, 0x1234).get_pointer(0)
+        self.magic = 42
+      end
+      def self.release;end
+    end
+    ManagedStructWithInitialize.new.magic.should == 42
+  end
+end

data/spec/ffi/struct_spec.rb

@@ -1,6 +1,5 @@
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
 describe "Struct tests" do
-  include FFI
   StructTypes = {
     's8' => :char,
     's16' => :short,
@@ -29,54 +28,54 @@ describe "Struct tests" do
   end
   it "Struct#[:pointer]" do
     magic = 0x12345678
-    mp = MemoryPointer.new :long
+    mp = FFI::MemoryPointer.new :long
     mp.put_long(0, magic)
-    smp = MemoryPointer.new :pointer
+    smp = FFI::MemoryPointer.new :pointer
     smp.put_pointer(0, mp)
     s = PointerMember.new smp
     s[:pointer].should == mp
   end
   it "Struct#[:pointer].nil? for NULL value" do
     magic = 0x12345678
-    mp = MemoryPointer.new :long
+    mp = FFI::MemoryPointer.new :long
     mp.put_long(0, magic)
-    smp = MemoryPointer.new :pointer
+    smp = FFI::MemoryPointer.new :pointer
     smp.put_pointer(0, nil)
     s = PointerMember.new smp
     s[:pointer].null?.should == true
   end
   it "Struct#[:pointer]=" do
     magic = 0x12345678
-    mp = MemoryPointer.new :long
+    mp = FFI::MemoryPointer.new :long
     mp.put_long(0, magic)
-    smp = MemoryPointer.new :pointer
+    smp = FFI::MemoryPointer.new :pointer
     s = PointerMember.new smp
     s[:pointer] = mp
     smp.get_pointer(0).should == mp
   end
   it "Struct#[:pointer]=struct" do
     magic = 0x12345678
-    smp = MemoryPointer.new :pointer
+    smp = FFI::MemoryPointer.new :pointer
     s = PointerMember.new smp
     lambda { s[:pointer] = s }.should_not raise_error
   end
   it "Struct#[:pointer]=nil" do
-    smp = MemoryPointer.new :pointer
+    smp = FFI::MemoryPointer.new :pointer
     s = PointerMember.new smp
     s[:pointer] = nil
     smp.get_pointer(0).null?.should == true
   end
   it "Struct#[:string]" do
     magic = "test"
-    mp = MemoryPointer.new 1024
+    mp = FFI::MemoryPointer.new 1024
     mp.put_string(0, magic)
-    smp = MemoryPointer.new :pointer
+    smp = FFI::MemoryPointer.new :pointer
     smp.put_pointer(0, mp)
     s = StringMember.new smp
     s[:string].should == magic
   end
   it "Struct#[:string].nil? for NULL value" do
-    smp = MemoryPointer.new :pointer
+    smp = FFI::MemoryPointer.new :pointer
     smp.put_pointer(0, nil)
     s = StringMember.new smp
     s[:string].nil?.should == true
@@ -85,9 +84,9 @@ describe "Struct tests" do
     class PairLayout < FFI::Struct
       layout :a, :int, :b, :long_long
     end
-    ll_off = (FFI::Platform::ADDRESS_SIZE == 32 ? 4 : 8)
+    ll_off = (FFI::TYPE_UINT64.alignment == 4 ? 4 : 8)
     PairLayout.size.should == (ll_off + 8)
-    mp = MemoryPointer.new(PairLayout.size)
+    mp = FFI::MemoryPointer.new(PairLayout.size)
     s = PairLayout.new mp
     s[:a] = 0x12345678
     mp.get_int(0).should == 0x12345678
@@ -98,8 +97,8 @@ describe "Struct tests" do
     class PairLayout < FFI::Struct
       layout :a, :int, 0, :b, :long_long, 4
     end
-    PairLayout.size.should == (FFI::Platform::ADDRESS_SIZE == 32 ? 12 : 16)
-    mp = MemoryPointer.new(PairLayout.size)
+    PairLayout.size.should == (FFI::TYPE_UINT64.alignment == 4 ? 12 : 16)
+    mp = FFI::MemoryPointer.new(PairLayout.size)
     s = PairLayout.new mp
     s[:a] = 0x12345678
     mp.get_int(0).should == 0x12345678
@@ -110,8 +109,8 @@ describe "Struct tests" do
     class MixedLayout < FFI::Struct
       layout :a, :int, :b, :long_long, 4
     end
-    MixedLayout.size.should == (FFI::Platform::ADDRESS_SIZE == 32 ? 12 : 16)
-    mp = MemoryPointer.new(MixedLayout.size)
+    MixedLayout.size.should == (FFI::TYPE_UINT64.alignment == 4 ? 12 : 16)
+    mp = FFI::MemoryPointer.new(MixedLayout.size)
     s = MixedLayout.new mp
     s[:a] = 0x12345678
     mp.get_int(0).should == 0x12345678
@@ -124,9 +123,9 @@ describe "Struct tests" do
       class HashLayout < FFI::Struct
         layout :a => :int, :b => :long_long
       end
-      ll_off = (FFI::Platform::ADDRESS_SIZE == 32 ? 4 : 8)
+      ll_off = (FFI::TYPE_UINT64.alignment == 4? 4 : 8)
       HashLayout.size.should == (ll_off + 8)
-      mp = MemoryPointer.new(HashLayout.size)
+      mp = FFI::MemoryPointer.new(HashLayout.size)
       s = HashLayout.new mp
       s[:a] = 0x12345678
       mp.get_int(0).should == 0x12345678
@@ -393,7 +392,6 @@ describe FFI::Struct, ' with an array field'  do
   before do
     @s = LibTest::StructWithArray.new
   end
-  it 'should align correctly array field'
   it 'should correctly calculate StructWithArray size (in bytes)' do
     LibTest::StructWithArray.size.should == 24
   end
@@ -451,3 +449,28 @@ describe 'BuggedStruct' do
     end.should == [[:visible, 0], [:x, 4], [:y, 8], [:rx, 12], [:ry, 14], [:order, 16], [:size, 17]]
   end
 end
+
+describe "Struct allocation" do
+  it "MemoryPointer.new(Struct, 2)" do
+    class S < FFI::Struct
+      layout :i, :uint
+    end
+    p = FFI::MemoryPointer.new(S, 2)
+    p.total.should == 8
+    p.type_size.should == 4
+    p.put_uint(4, 0xdeadbeef)
+    S.new(p[1])[:i].should == 0xdeadbeef
+    p[1].address.should == (p[0].address + 4)
+  end
+
+  it "Buffer.new(Struct, 2)" do
+    class S < FFI::Struct
+      layout :i, :uint
+    end
+    p = FFI::Buffer.new(S, 2)
+    p.total.should == 8
+    p.type_size.should == 4
+    p.put_uint(4, 0xdeadbeef)
+    S.new(p[1])[:i].should == 0xdeadbeef
+  end
+end