ffi 1.9.10-x64-mingw32 → 1.9.11-x64-mingw32

data/spec/ffi/fixtures/FunctionTest.c

@@ -6,14 +6,17 @@
 
 #ifdef _WIN32
 #include <windows.h>
-#define sleep(x) Sleep(x)
 #endif
 
 #ifndef _WIN32
 #include <unistd.h>
 #include <pthread.h>
+#include <stdarg.h>
+#include <stdlib.h>
 #endif
 
+#include "PipeHelper.h"
+
 int testAdd(int a, int b)
 {
     return a + b;
@@ -24,10 +27,79 @@ int testFunctionAdd(int a, int b, int (*f)(int, int))
     return f(a, b);
 };
 
-void testBlocking(int seconds) {
-    sleep(seconds);
+struct testBlockingData {
+    FD_TYPE pipe1[2];
+    FD_TYPE pipe2[2];
 };
 
+struct testBlockingData *testBlockingOpen()
+{
+    struct testBlockingData *self = malloc(sizeof(struct testBlockingData));
+
+    if( pipeHelperCreatePipe(self->pipe1) == -1 ) return NULL;
+    if( pipeHelperCreatePipe(self->pipe2) == -1 ) return NULL;
+    return self;
+}
+
+char testBlockingWR(struct testBlockingData *self, char c) {
+    if( pipeHelperWriteChar(self->pipe1[1], c) != 1)
+        return 0;
+    return pipeHelperReadChar(self->pipe2[0], 10);
+}
+
+char testBlockingRW(struct testBlockingData *self, char c) {
+    char d = pipeHelperReadChar(self->pipe1[0], 10);
+    if( pipeHelperWriteChar(self->pipe2[1], c) != 1)
+        return 0;
+    return d;
+}
+
+void testBlockingClose(struct testBlockingData *self) {
+    pipeHelperClosePipe(self->pipe1[0]);
+    pipeHelperClosePipe(self->pipe1[1]);
+    pipeHelperClosePipe(self->pipe2[0]);
+    pipeHelperClosePipe(self->pipe2[1]);
+    free(self);
+}
+
+static int sum_varargs(va_list args) {
+    char sum = 0;
+    int arg;
+    while ((arg = va_arg(args, int)) != 0) {
+        sum += arg;
+    }
+    va_end(args);
+    return sum;
+}
+
+/* Write c to pipe1 and return the value read from pipe2, or 0 if there’s
+ * an error such as a timeout, or if c does not equal the sum of the
+ * zero-terminated list of char arguments. */
+char testBlockingWRva(struct testBlockingData *self, char c, ...) {
+    va_list args;
+    va_start(args, c);
+    if (sum_varargs(args) != c) {
+        return 0;
+    }
+
+    if( pipeHelperWriteChar(self->pipe1[1], c) != 1)
+        return 0;
+    return pipeHelperReadChar(self->pipe2[0], 10);
+}
+
+char testBlockingRWva(struct testBlockingData *self, char c, ...) {
+    va_list args;
+    va_start(args, c);
+    if (sum_varargs(args) != c) {
+        return 0;
+    }
+
+    char d = pipeHelperReadChar(self->pipe1[0], 10);
+    if( pipeHelperWriteChar(self->pipe2[1], c) != 1)
+        return 0;
+    return d;
+}
+
 struct async_data {
     void (*fn)(int);
     int value;
@@ -55,4 +127,16 @@ void testAsyncCallback(void (*fn)(int), int value)
 #else
     (*fn)(value);
 #endif
-} 
+}
+
+#if defined(_WIN32) && !defined(_WIN64)
+struct StructUCDP {
+  unsigned char a1;
+  double a2;
+  void *a3;
+};
+
+void __stdcall testStdcallManyParams(long *a1, char a2, short int a3, int a4, __int64 a5,
+            struct StructUCDP a6, struct StructUCDP *a7, float a8, double a9) {
+}
+#endif

data/spec/ffi/fixtures/PipeHelper.h

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2015 Lars Kanis. All rights reserved.
+ *
+ * For licensing, see LICENSE.SPECS
+ */
+
+#ifndef PIPEHELPER_H
+#define PIPEHELPER_H
+
+#ifdef _WIN32
+#define FD_TYPE HANDLE
+#else
+#define FD_TYPE int
+#endif
+
+int pipeHelperCreatePipe(FD_TYPE pipefd[2]);
+char pipeHelperReadChar(FD_TYPE fd, int timeout);
+int pipeHelperWriteChar(FD_TYPE fd, char c);
+void pipeHelperClosePipe(FD_TYPE fd);
+
+#endif

data/spec/ffi/fixtures/PipeHelperPosix.c

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2015 Lars Kanis. All rights reserved.
+ *
+ * For licensing, see LICENSE.SPECS
+ */
+
+#ifndef _WIN32
+#include <unistd.h>
+#include <sys/time.h>
+#include "PipeHelper.h"
+
+int pipeHelperCreatePipe(FD_TYPE pipefd[2])
+{
+    return pipe(pipefd);
+}
+
+char pipeHelperReadChar(FD_TYPE fd, int timeout)
+{
+    char d;
+    struct timeval time = {timeout, 0}; // timeout after x seconds
+    fd_set read_fds;
+    FD_ZERO(&read_fds);
+    FD_SET(fd, &read_fds);
+
+    if(select(fd + 1, &read_fds, NULL, NULL, &time) <= 0)
+        return 0;
+
+    if( read(fd, &d, 1) != 1)
+        return 0;
+    return d;
+}
+
+int pipeHelperWriteChar(FD_TYPE fd, char c)
+{
+    return write(fd, &c, 1);
+}
+
+void pipeHelperClosePipe(FD_TYPE fd) {
+    close(fd);
+}
+#endif

data/spec/ffi/fixtures/PipeHelperWindows.c

@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2007 Wayne Meissner. All rights reserved.
+ *
+ * For licensing, see LICENSE.SPECS
+ */
+
+#ifdef _WIN32
+#include <windows.h>
+#include "PipeHelper.h"
+
+int pipeHelperCreatePipe(FD_TYPE pipefd[2])
+{
+    char name[ MAX_PATH ];
+    static int pipe_idx = 0;
+    sprintf( name, "\\\\.\\Pipe\\pipeHelper-%u-%i",
+             (unsigned int)GetCurrentProcessId(), pipe_idx++ );
+
+    pipefd[0] = CreateNamedPipe( name, PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED,
+                         PIPE_TYPE_BYTE | PIPE_WAIT,
+                         1,             // Number of pipes
+                         5,         // Out buffer size
+                         5,         // In buffer size
+                         60 * 1000,    // Timeout in ms
+                         NULL );
+    if(pipefd[0] == INVALID_HANDLE_VALUE)
+        return -1;
+
+    pipefd[1] = CreateFile( name, GENERIC_WRITE, 0, NULL,
+                        OPEN_EXISTING,
+                        FILE_ATTRIBUTE_NORMAL,
+                        NULL);
+
+    if(pipefd[1] == INVALID_HANDLE_VALUE) {
+        CloseHandle( pipefd[0] );
+        return -1;
+    }
+    return 0;
+}
+
+char pipeHelperReadChar(FD_TYPE fd, int timeout)
+{
+    char d;
+    OVERLAPPED ovl;
+    ZeroMemory(&ovl, sizeof(ovl));
+    ovl.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+    if( ReadFile(fd, &d, 1, NULL, &ovl) == 0) {
+        DWORD recvd = 0;;
+        DWORD res = WaitForSingleObject(ovl.hEvent, timeout * 1000);
+        if( res != WAIT_OBJECT_0 ) {
+            CloseHandle(ovl.hEvent);
+            return 0;
+        }
+        if( GetOverlappedResult(fd, &ovl, &recvd, FALSE) == 0 ) {
+            CloseHandle(ovl.hEvent);
+            return 0;
+        }
+    }
+    CloseHandle(ovl.hEvent);
+    return d;
+}
+
+int pipeHelperWriteChar(FD_TYPE fd, char c)
+{
+    DWORD written;
+    return WriteFile(fd, &c, 1, &written, NULL) == 0 ? 0 : 1;
+}
+
+void pipeHelperClosePipe(FD_TYPE fd) {
+    CloseHandle(fd);
+}
+
+#endif

data/spec/ffi/function_spec.rb

@@ -12,7 +12,7 @@ describe FFI::Function do
     attach_function :testFunctionAdd, [:int, :int, :pointer], :int
   end
   before do
-    @libtest = FFI::DynamicLibrary.open(TestLibrary::PATH, 
+    @libtest = FFI::DynamicLibrary.open(TestLibrary::PATH,
                                         FFI::DynamicLibrary::RTLD_LAZY | FFI::DynamicLibrary::RTLD_GLOBAL)
   end
 
@@ -22,7 +22,7 @@ describe FFI::Function do
   end
 
   it 'raises an error when passing a wrong signature' do
-    expect { FFI::Function.new([], :int).new { } }.to raise_error TypeError 
+    expect { FFI::Function.new([], :int).new { } }.to raise_error TypeError
   end
 
   it 'returns a native pointer' do
@@ -63,15 +63,20 @@ describe FFI::Function do
   end
 
   it 'can wrap a blocking function' do
-    fp = FFI::Function.new(:void, [ :int ], @libtest.find_function('testBlocking'), :blocking => true)
-    threads = 10.times.map do |x|
-      Thread.new do
-        time = Time.now
-        fp.call(2)
-        expect(Time.now - time).to be >= 2
-      end
+    fpOpen = FFI::Function.new(:pointer, [ ], @libtest.find_function('testBlockingOpen'))
+    fpRW = FFI::Function.new(:char, [ :pointer, :char ], @libtest.find_function('testBlockingRW'), :blocking => true)
+    fpWR = FFI::Function.new(:char, [ :pointer, :char ], @libtest.find_function('testBlockingWR'), :blocking => true)
+    fpClose = FFI::Function.new(:void, [ :pointer ], @libtest.find_function('testBlockingClose'))
+    handle = fpOpen.call
+    expect(handle).not_to be_null
+    begin
+      thWR = Thread.new { fpWR.call(handle, 63) }
+      thRW = Thread.new { fpRW.call(handle, 64) }
+      expect(thWR.value).to eq(64)
+      expect(thRW.value).to eq(63)
+    ensure
+      fpClose.call(handle)
     end
-    threads.each { |t| t.join }
   end
 
   it 'autorelease flag is set to true by default' do

data/spec/ffi/rbx/attach_function_spec.rb

@@ -5,29 +5,30 @@
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
 
-class Timeval < FFI::Struct
-  layout :tv_sec, :ulong, 0, :tv_usec, :ulong, 4  
-end
-
-module LibC
-  extend FFI::Library
-  ffi_lib FFI::Library::LIBC
+unless FFI::Platform.windows?
+  class Timeval < FFI::Struct
+    layout :tv_sec, :ulong, 0, :tv_usec, :ulong, 4
+  end
 
-  attach_function :gettimeofday, [:pointer, :pointer], :int
-end
+  module LibC
+    extend FFI::Library
+    ffi_lib FFI::Library::LIBC
 
-describe FFI::Library, "#attach_function" do
-  it "correctly returns a value for gettimeofday" do
-    t = Timeval.new
-    time = LibC.gettimeofday(t.pointer, nil)
-    expect(time).to be_kind_of(Integer)
+    attach_function :gettimeofday, [:pointer, :pointer], :int
   end
-  
-  it "correctly populates a struct for gettimeofday" do
-    t = Timeval.new
-    LibC.gettimeofday(t.pointer, nil)
-    expect(t[:tv_sec]).to be_kind_of(Numeric)
-    expect(t[:tv_usec]).to be_kind_of(Numeric)
+
+  describe FFI::Library, "#attach_function" do
+    it "correctly returns a value for gettimeofday" do
+      t = Timeval.new
+      time = LibC.gettimeofday(t.pointer, nil)
+      expect(time).to be_kind_of(Integer)
+    end
+
+    it "correctly populates a struct for gettimeofday" do
+      t = Timeval.new
+      LibC.gettimeofday(t.pointer, nil)
+      expect(t[:tv_sec]).to be_kind_of(Numeric)
+      expect(t[:tv_usec]).to be_kind_of(Numeric)
+    end
   end
 end
-

data/spec/ffi/struct_spec.rb

@@ -7,7 +7,7 @@ require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
 
 describe "Struct aligns fields correctly" do
   it "char, followed by an int" do
-    pending("not supported in 1.8") if RUBY_VERSION =~ /1.8.*/
+    pending("not supported in 1.8") if RUBY_VERSION =~ /^1\.8\..*/
     class CIStruct < FFI::Struct
       layout :c => :char, :i => :int
     end
@@ -15,7 +15,7 @@ describe "Struct aligns fields correctly" do
   end
 
   it "short, followed by an int" do
-    pending("not supported in 1.8") if RUBY_VERSION =~ /1.8.*/
+    pending("not supported in 1.8") if RUBY_VERSION =~ /^1\.8\..*/
     class SIStruct < FFI::Struct
       layout :s => :short, :i => :int
     end
@@ -23,7 +23,7 @@ describe "Struct aligns fields correctly" do
   end
 
   it "int, followed by an int" do
-    pending("not supported in 1.8") if RUBY_VERSION =~ /1.8.*/
+    pending("not supported in 1.8") if RUBY_VERSION =~ /^1\.8\..*/
     class IIStruct < FFI::Struct
       layout :i1 => :int, :i => :int
     end
@@ -31,7 +31,7 @@ describe "Struct aligns fields correctly" do
   end
 
   it "long long, followed by an int" do
-    pending("not supported in 1.8") if RUBY_VERSION =~ /1.8.*/
+    pending("not supported in 1.8") if RUBY_VERSION =~ /^1\.8\..*/
     class LLIStruct < FFI::Struct
       layout :l => :long_long, :i => :int
     end

data/spec/ffi/variadic_spec.rb

@@ -13,6 +13,11 @@ describe "Function with variadic arguments" do
     enum :enum_type2, [:c3, 42, :c4]
     attach_function :pack_varargs, [ :buffer_out, :string, :varargs ], :void
     attach_function :pack_varargs2, [ :buffer_out, :enum_type1, :string, :varargs ], :enum_type1
+
+    attach_function :testBlockingOpen, [ ], :pointer
+    attach_function :testBlockingRWva, [ :pointer, :char, :varargs ], :char, :blocking => true
+    attach_function :testBlockingWRva, [ :pointer, :char, :varargs ], :char, :blocking => true
+    attach_function :testBlockingClose, [ :pointer ], :void
   end
 
   it "takes enum arguments" do
@@ -27,6 +32,20 @@ describe "Function with variadic arguments" do
     expect(LibTest.pack_varargs2(buf, :c1, "ii", :int, :c3, :int, :c4)).to eq(:c2)
   end
 
+  it 'can wrap a blocking function with varargs' do
+    pending("not supported in 1.8") if RUBY_VERSION =~ /^1\.8\..*/
+    handle = LibTest.testBlockingOpen
+    expect(handle).not_to be_null
+    begin
+      thWR = Thread.new { LibTest.testBlockingWRva(handle, 63, :int, 40, :int, 23, :int, 0) }
+      thRW = Thread.new { LibTest.testBlockingRWva(handle, 64, :int, 40, :int, 24, :int, 0) }
+      expect(thWR.value).to eq(64)
+      expect(thRW.value).to eq(63)
+    ensure
+      LibTest.testBlockingClose(handle)
+    end
+  end
+
   [ 0, 127, -128, -1 ].each do |i|
     it "call variadic with (:char (#{i})) argument" do
       buf = FFI::Buffer.new :long_long

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ffi
 version: !ruby/object:Gem::Version
-  version: 1.9.10
+  version: 1.9.11
 platform: x64-mingw32
 authors:
 - Wayne Meissner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-02 00:00:00.000000000 Z
+date: 2016-07-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.2
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -515,6 +515,9 @@ files:
 - spec/ffi/fixtures/GlobalVariable.c
 - spec/ffi/fixtures/LastErrorTest.c
 - spec/ffi/fixtures/NumberTest.c
+- spec/ffi/fixtures/PipeHelper.h
+- spec/ffi/fixtures/PipeHelperPosix.c
+- spec/ffi/fixtures/PipeHelperWindows.c
 - spec/ffi/fixtures/PointerTest.c
 - spec/ffi/fixtures/ReferenceTest.c
 - spec/ffi/fixtures/StringTest.c