Merge pull request #6697 from ahorek/ffi1_15_1

headius · web-flow · commit 02b783dc8c59 · 2021-06-04T17:59:35.000-05:00
[ffi] update to 1.15.1
diff --git a/lib/pom.rb b/lib/pom.rb
@@ -22,7 +22,7 @@ def log(message=nil)
     ['cmath', '1.0.0'],
     ['csv', '3.1.2'],
     ['e2mmap', '0.1.0'],
-    ['ffi', '1.14.2'],
+    ['ffi', '1.15.1'],
     ['fileutils', '1.4.1'],
     ['forwardable', '1.2.0'],
     ['ipaddr', '1.2.2'],
diff --git a/lib/pom.xml b/lib/pom.xml
@@ -99,7 +99,7 @@ DO NOT MODIFIY - GENERATED CODE
     <dependency>
       <groupId>rubygems</groupId>
       <artifactId>ffi</artifactId>
-      <version>1.14.2</version>
+      <version>1.15.1</version>
       <type>gem</type>
       <scope>provided</scope>
       <exclusions>
@@ -564,7 +564,7 @@ DO NOT MODIFIY - GENERATED CODE
           <include>specifications/cmath-1.0.0*</include>
           <include>specifications/csv-3.1.2*</include>
           <include>specifications/e2mmap-0.1.0*</include>
-          <include>specifications/ffi-1.14.2*</include>
+          <include>specifications/ffi-1.15.1*</include>
           <include>specifications/fileutils-1.4.1*</include>
           <include>specifications/forwardable-1.2.0*</include>
           <include>specifications/ipaddr-1.2.2*</include>
@@ -603,7 +603,7 @@ DO NOT MODIFIY - GENERATED CODE
           <include>gems/cmath-1.0.0*/**/*</include>
           <include>gems/csv-3.1.2*/**/*</include>
           <include>gems/e2mmap-0.1.0*/**/*</include>
-          <include>gems/ffi-1.14.2*/**/*</include>
+          <include>gems/ffi-1.15.1*/**/*</include>
           <include>gems/fileutils-1.4.1*/**/*</include>
           <include>gems/forwardable-1.2.0*/**/*</include>
           <include>gems/ipaddr-1.2.2*/**/*</include>
@@ -642,7 +642,7 @@ DO NOT MODIFIY - GENERATED CODE
           <include>cache/cmath-1.0.0*</include>
           <include>cache/csv-3.1.2*</include>
           <include>cache/e2mmap-0.1.0*</include>
-          <include>cache/ffi-1.14.2*</include>
+          <include>cache/ffi-1.15.1*</include>
           <include>cache/fileutils-1.4.1*</include>
           <include>cache/forwardable-1.2.0*</include>
           <include>cache/ipaddr-1.2.2*</include>
diff --git a/spec/ffi/async_callback_spec.rb b/spec/ffi/async_callback_spec.rb
@@ -19,19 +19,35 @@ module LibTest
     skip "not yet supported on TruffleRuby" if RUBY_ENGINE == "truffleruby"
     v = 0xdeadbeef
     called = false
-    cb = Proc.new {|i| v = i; called = true }
+    cb = Proc.new {|i| v = i; called = Thread.current }
     LibTest.testAsyncCallback(cb, 0x7fffffff)
-    expect(called).to be true
+    expect(called).to be_kind_of(Thread)
+    expect(called).to_not eq(Thread.current)
     expect(v).to eq(0x7fffffff)
   end
 
   it "called a second time" do
     skip "not yet supported on TruffleRuby" if RUBY_ENGINE == "truffleruby"
-    v = 0xdeadbeef
-    called = false
-    cb = Proc.new {|i| v = i; called = true }
-    LibTest.testAsyncCallback(cb, 0x7fffffff)
-    expect(called).to be true
-    expect(v).to eq(0x7fffffff)
+    v = 1
+    th1 = th2 = false
+    LibTest.testAsyncCallback(2) { |i| v += i; th1 = Thread.current }
+    LibTest.testAsyncCallback(3) { |i| v += i; th2 = Thread.current }
+    expect(th1).to be_kind_of(Thread)
+    expect(th2).to be_kind_of(Thread)
+    expect(th1).to_not eq(Thread.current)
+    expect(th2).to_not eq(Thread.current)
+    expect(th1).to_not eq(th2)
+    expect(v).to eq(6)
+  end
+
+  it "sets the name of the thread that runs the callback" do
+    skip "not yet supported on TruffleRuby" if RUBY_ENGINE == "truffleruby"
+    skip "not yet supported on JRuby" if RUBY_ENGINE == "jruby"
+
+    callback_runner_thread = nil
+
+    LibTest.testAsyncCallback(proc { callback_runner_thread = Thread.current }, 0)
+
+    expect(callback_runner_thread.name).to eq("FFI Callback Runner")
   end
 end
diff --git a/spec/ffi/callback_spec.rb b/spec/ffi/callback_spec.rb
@@ -49,6 +49,8 @@ class S8F32S32 < FFI::Struct
       callback :cbVrU32, [ ], :uint
       callback :cbVrL, [ ], :long
       callback :cbVrUL, [ ], :ulong
+      callback :cbVrF, [ ], :float
+      callback :cbVrD, [ ], :double
       callback :cbVrS64, [ ], :long_long
       callback :cbVrU64, [ ], :ulong_long
       callback :cbVrP, [], :pointer
@@ -70,6 +72,8 @@ class S8F32S32 < FFI::Struct
       attach_function :testCallbackVrU16, :testClosureVrS, [ :cbVrU16 ], :ushort
       attach_function :testCallbackVrS32, :testClosureVrI, [ :cbVrS32 ], :int
       attach_function :testCallbackVrU32, :testClosureVrI, [ :cbVrU32 ], :uint
+      attach_function :testCallbackVrF, :testClosureVrF, [ :cbVrF ], :float
+      attach_function :testCallbackVrD, :testClosureVrD, [ :cbVrD ], :double
       attach_function :testCallbackVrL, :testClosureVrL, [ :cbVrL ], :long
       attach_function :testCallbackVrZ, :testClosureVrZ, [ :cbVrZ ], :bool
       attach_function :testCallbackVrUL, :testClosureVrL, [ :cbVrUL ], :ulong
@@ -86,7 +90,6 @@ class S8F32S32 < FFI::Struct
       attach_variable :pVrS8, :gvar_pointer, :pointer
       attach_function :testGVarCallbackVrS8, :testClosureVrB, [ :pointer ], :char
       attach_function :testOptionalCallbackCrV, :testOptionalClosureBrV, [ :cbCrV, :char ], :void
-
     end
 
     it "returning :char (0)" do
@@ -261,6 +264,14 @@ class S8F32S32 < FFI::Struct
       expect(LibTest.testCallbackVrZ { true }).to be true
     end
 
+    it "returning float" do
+      expect(LibTest.testCallbackVrF { 1.234567890123456789 }).to be_within(1E-7).of(1.234567890123456789)
+    end
+
+    it "returning double" do
+      expect(LibTest.testCallbackVrD { 1.234567890123456789 }).to be_within(1E-15).of(1.234567890123456789)
+    end
+
     it "returning :pointer (nil)" do
       expect(LibTest.testCallbackVrP { nil }).to be_null
     end
diff --git a/spec/ffi/fixtures/ClosureTest.c b/spec/ffi/fixtures/ClosureTest.c
@@ -6,13 +6,38 @@
 
 #include <stdlib.h>
 #include <stdbool.h>
+#include <stdarg.h>
 #ifndef _WIN32
 # include <pthread.h>
 #else
 # include <windows.h>
 # include <process.h>
 #endif
 
+double testClosureVrDva(double d, ...) {
+    va_list args;
+    double (*closure)(void);
+
+    va_start(args, d);
+    closure = va_arg(args, double (*)(void));
+    va_end(args);
+
+    return d + closure();
+}
+
+long testClosureVrILva(int i, long l, ...) {
+    va_list args;
+    int (*cl1)(int);
+    long (*cl2)(long);
+
+    va_start(args, l);
+    cl1 = va_arg(args, int (*)(int));
+    cl2 = va_arg(args, long (*)(long));
+    va_end(args);
+
+    return cl1(i) + cl2(l);
+}
+
 #define R(T, rtype) rtype testClosureVr##T(rtype (*closure)(void)) { \
     return closure != NULL ? (*closure)() : (rtype) 0; \
 }
diff --git a/spec/ffi/fixtures/FunctionTest.c b/spec/ffi/fixtures/FunctionTest.c
@@ -6,6 +6,7 @@
 
 #ifdef _WIN32
 #include <windows.h>
+#include <process.h>
 #endif
 
 #ifndef _WIN32
@@ -115,17 +116,26 @@ static void* asyncThreadCall(void *data)
     return NULL;
 }
 
+#ifdef _WIN32
+static void
+asyncThreadCall_win32(void *arg)
+{
+    asyncThreadCall(arg);
+}
+#endif
+
 void testAsyncCallback(void (*fn)(int), int value)
 {
-#ifndef _WIN32
-    pthread_t t;
     struct async_data d;
     d.fn = fn;
     d.value = value;
+#ifndef _WIN32
+    pthread_t t;
     pthread_create(&t, NULL, asyncThreadCall, &d);
     pthread_join(t, NULL);
 #else
-    (*fn)(value);
+    HANDLE hThread = (HANDLE) _beginthread(asyncThreadCall_win32, 0, &d);
+    WaitForSingleObject(hThread, INFINITE);
 #endif
 }
 
diff --git a/spec/ffi/fork_spec.rb b/spec/ffi/fork_spec.rb
@@ -8,32 +8,59 @@
 if Process.respond_to?(:fork)
   describe "Callback in conjunction with fork()" do
 
-    module LibTest
+    libtest = Module.new do
       extend FFI::Library
       ffi_lib TestLibrary::PATH
 
       callback :cbVrL, [ ], :long
       attach_function :testCallbackVrL, :testClosureVrL, [ :cbVrL ], :long
+      AsyncIntCallback = callback [ :int ], :void
+      attach_function :testAsyncCallback, [ AsyncIntCallback, :int ], :void, blocking: true
     end
 
     it "works with forked process and GC" do
-      expect(LibTest.testCallbackVrL { 12345 }).to eq(12345)
+      expect(libtest.testCallbackVrL { 12345 }).to eq(12345)
       fork do
-        expect(LibTest.testCallbackVrL { 12345 }).to eq(12345)
+        expect(libtest.testCallbackVrL { 12345 }).to eq(12345)
+        Process.exit 42
       end
-      expect(LibTest.testCallbackVrL { 12345 }).to eq(12345)
+      expect(libtest.testCallbackVrL { 12345 }).to eq(12345)
       GC.start
+
+      expect(Process.wait2[1].exitstatus).to eq(42)
     end
 
     it "works with forked process and free()" do
       cbf = FFI::Function.new(FFI::Type::LONG, []) { 234 }
 
       fork do
         cbf.free
+        Process.exit 43
       end
 
-      expect(LibTest.testCallbackVrL(cbf)).to eq(234)
+      expect(libtest.testCallbackVrL(cbf)).to eq(234)
       cbf.free
+
+      expect(Process.wait2[1].exitstatus).to eq(43)
+    end
+
+    def run_async_callback(libtest)
+      recv = nil
+      libtest.testAsyncCallback(proc { |r| recv = r }, 23)
+      expect(recv).to eq(23)
+    end
+
+    it "async thread dispatch works after forking" do
+      run_async_callback(libtest)
+
+      fork do
+        run_async_callback(libtest)
+        Process.exit 44
+      end
+
+      run_async_callback(libtest)
+
+      expect(Process.wait2[1].exitstatus).to eq(44)
     end
   end
 end
diff --git a/spec/ffi/function_spec.rb b/spec/ffi/function_spec.rb
@@ -21,6 +21,15 @@ module LibTest
     expect(fn.call).to eql 5
   end
 
+  context 'when called with a block' do
+    it 'creates a thread for dispatching callbacks and sets its name' do
+      skip 'this is MRI-specific' if RUBY_ENGINE == 'truffleruby' || RUBY_ENGINE == 'jruby'
+      FFI::Function.new(:int, []) { 5 } # Trigger initialization
+
+      expect(Thread.list.map(&:name)).to include('FFI Callback Dispatcher')
+    end
+  end
+
   it 'raises an error when passing a wrong signature' do
     expect { FFI::Function.new([], :int).new { } }.to raise_error TypeError
   end
diff --git a/spec/ffi/variadic_spec.rb b/spec/ffi/variadic_spec.rb
@@ -13,11 +13,16 @@ module LibTest
     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
+    callback :cbVrD, [ ], :double
+    callback :cbVrI, [:int], :int
+    callback :cbVrL, [:long], :long
 
     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
+    attach_function :testCallbackVrDva, :testClosureVrDva, [ :double, :varargs ], :double
+    attach_function :testCallbackVrILva, :testClosureVrILva, [ :int, :long, :varargs ], :long
   end
 
   it "takes enum arguments" do
@@ -77,6 +82,17 @@ module LibTest
     end
   end
 
+  it "call variadic with callback argument" do
+    pr = proc { 42.0 }
+    expect(LibTest.testCallbackVrDva(3.0, :cbVrD, pr)).to be_within(0.0000001).of(45.0)
+  end
+
+  it "call variadic with several callback arguments" do
+    pr1 = proc { |i| i + 1 }
+    pr2 = proc { |l| l + 2 }
+    expect(LibTest.testCallbackVrILva(5, 6, :cbVrI, pr1, :cbVrL, pr2)).to eq(14)
+  end
+
   module Varargs
     PACK_VALUES = {
       'c' => [ 0x12  ],
