libusb 0.6.3-x86-mingw32 → 0.7.0-x86-mingw32

data/lib/libusb/libusb_recipe.rb

@@ -11,7 +11,8 @@ module LIBUSB
     def initialize
       super("libusb", LIBUSB_VERSION)
       self.target = File.join(ROOT, "ports")
-      self.files = [url: LIBUSB_SOURCE_URI, sha1: LIBUSB_SOURCE_SHA1]
+      self.files = [url: LIBUSB_SOURCE_URI, sha256: LIBUSB_SOURCE_SHA256]
+      self.patch_files = Dir[File.join(ROOT, "patches", self.name, self.version, "*.patch")].sort
       self.configure_options = []
     end
 
@@ -24,7 +25,5 @@ module LIBUSB
       self.activate
       self
     end
-
-    public :files_hashs
   end
 end

data/lib/libusb/ss_companion.rb

@@ -19,13 +19,21 @@ module LIBUSB
   # A structure representing the superspeed endpoint companion descriptor.
   #
   # This descriptor is documented in section 9.6.7 of the USB 3.0 specification. All multiple-byte fields are represented in host-endian format.
-  class SsCompanion < FFI::ManagedStruct
+  class SsCompanion < FFI::Struct
+    include ContextReference
+
     layout :bLength, :uint8,
         :bDescriptorType, :uint8,
         :bMaxBurst, :uint8,
         :bmAttributes, :uint8,
         :wBytesPerInterval, :uint16
 
+    def initialize(ctx, *args)
+      super(*args)
+
+      register_context(ctx, :libusb_free_ss_endpoint_companion_descriptor)
+    end
+
     # Size of this descriptor (in bytes)
     def bLength
       self[:bLength]
@@ -60,10 +68,5 @@ module LIBUSB
     def inspect
       "\#<#{self.class} burst: #{bMaxBurst} attrs: #{bmAttributes}>"
     end
-
-    # @private
-    def self.release(ptr)
-      Call.libusb_free_ss_endpoint_companion_descriptor(ptr)
-    end
   end
 end

data/lib/libusb/transfer.rb

@@ -28,25 +28,30 @@ module LIBUSB
     class ZeroCopyMemory < FFI::Pointer
       attr_reader :size
 
-      def initialize(dev_handle, ptr, size)
-        @dev_handle = dev_handle
+      def initialize(pDevhandle, ptr, size)
+        @pDevhandle = pDevhandle
         @size = size
         super(ptr)
       end
 
       def free(id=nil)
+        # puts format("libusb_dev_mem_free(%#x, %d)%s", address, @size||0, id ? " by GC" : '')
         return unless @size
-#         puts format("libusb_dev_mem_free(%#x, %d)%s", address, @size, id ? " by GC" : '')
-        res = Call.libusb_dev_mem_free( @dev_handle.pHandle, self, @size )
+        res = Call.libusb_dev_mem_free( @pDevhandle, self, @size )
         LIBUSB.raise_error res, "in libusb_dev_mem_free" if res!=0
         @size = nil
       end
     end
 
+    class << self
+      private :new
+    end
+
     def initialize(args={})
       @buffer = nil
       @completion_flag = Context::CompletionFlag.new
       @allow_device_memory = false
+      @dev_handle = nil
       args.each{|k,v| send("#{k}=", v) }
     end
     private :initialize
@@ -55,15 +60,29 @@ module LIBUSB
     def dev_handle=(dev)
       @dev_handle = dev
       @transfer[:dev_handle] = @dev_handle.pHandle
+      # Now that the transfer is bound to a DevHandle, it must be registered in the Context.
+      # This ensures that the Call::Transfer is freed before libusb_exit, avoiding warnings about still referenced devices.
+      ctx = dev.device.context.instance_variable_get(:@ctx)
+      @transfer.instance_variable_set(:@ctx, ctx.ref_context)
     end
 
-    # Timeout for this transfer in millseconds.
+    # The handle for the device to communicate with.
+    attr_reader :dev_handle
+
+    # Set timeout for this transfer in millseconds.
     #
     # A value of 0 indicates no timeout.
     def timeout=(value)
       @transfer[:timeout] = value
     end
 
+    # Get timeout for this transfer in millseconds.
+    #
+    # A value of 0 indicates no timeout.
+    def timeout
+      @transfer[:timeout]
+    end
+
     # Set the address of a valid endpoint to communicate with.
     def endpoint=(endpoint)
       endpoint = endpoint.bEndpointAddress if endpoint.respond_to? :bEndpointAddress
@@ -148,7 +167,7 @@ module LIBUSB
           ptr = Call.libusb_dev_mem_alloc( @dev_handle.pHandle, len )
 #           puts format("libusb_dev_mem_alloc(%d) => %#x", len, ptr.address)
           unless ptr.null?
-            buffer = ZeroCopyMemory.new(@dev_handle, ptr, len)
+            buffer = ZeroCopyMemory.new(@dev_handle.pHandle, ptr, len)
             ObjectSpace.define_finalizer(self, buffer.method(:free))
           end
         end
@@ -225,6 +244,8 @@ module LIBUSB
     #
     # Inspect {#status} to check for transfer errors.
     def submit_and_wait
+      raise ArgumentError, "#{self.class}#dev_handle not set" unless @dev_handle
+
       @completion_flag.completed = false
       submit! do |tr2|
         @completion_flag.completed = true
@@ -235,7 +256,7 @@ module LIBUSB
           @dev_handle.device.context.handle_events nil, @completion_flag
         rescue ERROR_INTERRUPTED
           next
-        rescue LIBUSB::Error
+        rescue Exception
           cancel!
           until @completion_flag.completed?
             @dev_handle.device.context.handle_events nil, @completion_flag
@@ -256,6 +277,10 @@ module LIBUSB
   end
 
   class BulkTransfer < Transfer
+    def self.new(*)
+      super
+    end
+
     def initialize(args={})
       @transfer = Call::Transfer.new Call.libusb_alloc_transfer(0)
       @transfer[:type] = TRANSFER_TYPE_BULK
@@ -272,6 +297,10 @@ module LIBUSB
     #
     # Available since libusb-1.0.19.
     class BulkStreamTransfer < Transfer
+      def self.new(*)
+        super
+      end
+
       def initialize(args={})
         @transfer = Call::Transfer.new Call.libusb_alloc_transfer(0)
         @transfer[:type] = TRANSFER_TYPE_BULK_STREAM
@@ -299,6 +328,10 @@ module LIBUSB
   end
 
   class ControlTransfer < Transfer
+    def self.new(*)
+      super
+    end
+
     def initialize(args={})
       @transfer = Call::Transfer.new Call.libusb_alloc_transfer(0)
       @transfer[:type] = TRANSFER_TYPE_CONTROL
@@ -308,6 +341,10 @@ module LIBUSB
   end
 
   class InterruptTransfer < Transfer
+    def self.new(*)
+      super
+    end
+
     def initialize(args={})
       @transfer = Call::Transfer.new Call.libusb_alloc_transfer(0)
       @transfer[:type] = TRANSFER_TYPE_INTERRUPT
@@ -339,6 +376,10 @@ module LIBUSB
   end
 
   class IsochronousTransfer < Transfer
+    def self.new(*)
+      super
+    end
+
     def initialize(num_packets, args={})
       @ptr = Call.libusb_alloc_transfer(num_packets)
       @transfer = Call::Transfer.new @ptr

data/lib/libusb/version_gem.rb

@@ -15,5 +15,5 @@
 
 module LIBUSB
   # Library version of libusb for Ruby
-  VERSION = "0.6.3"
+  VERSION = "0.7.0"
 end

data/lib/libusb.rb

@@ -20,6 +20,7 @@ module LIBUSB
   autoload :VERSION, 'libusb/version_gem'
   autoload :Version, 'libusb/version_struct'
   autoload :Configuration, 'libusb/configuration'
+  autoload :ContextReference, 'libusb/context_reference'
   autoload :DevHandle, 'libusb/dev_handle'
   autoload :Device, 'libusb/device'
   autoload :Endpoint, 'libusb/endpoint'
@@ -32,27 +33,114 @@ module LIBUSB
     autoload klass, 'libusb/transfer'
   end
 
-  if Call.respond_to?(:libusb_get_version)
-    # Get version of the underlying libusb library.
-    # Available since libusb-1.0.10.
-    # @return [Version]  version object
-    def self.version
-      Version.new(Call.libusb_get_version)
+  class << self
+    if Call.respond_to?(:libusb_get_version)
+      # Get version of the underlying libusb library.
+      # Available since libusb-1.0.10.
+      # @return [Version]  version object
+      def version
+        Version.new(Call.libusb_get_version)
+      end
+    end
+
+    if Call.respond_to?(:libusb_has_capability)
+      # Check at runtime if the loaded library has a given capability.
+      # Available since libusb-1.0.9.
+      # @param [Symbol] capability  the {Call::Capabilities Capabilities} symbol to check for
+      # @return [Boolean]  +true+ if the running library has the capability, +false+ otherwise
+      def has_capability?(capability)
+        r = Call.libusb_has_capability(capability)
+        return r != 0
+      end
+    else
+      def has_capability?(capability)
+        false
+      end
+    end
+
+    private def expect_option_args(exp, is)
+      raise ArgumentError, "wrong number of arguments (given #{is+1}, expected #{exp+1})" if is != exp
     end
-  end
 
-  if Call.respond_to?(:libusb_has_capability)
-    # Check at runtime if the loaded library has a given capability.
-    # Available since libusb-1.0.9.
-    # @param [Symbol] capability  the {Call::Capabilities Capabilities} symbol to check for
-    # @return [Boolean]  +true+ if the running library has the capability, +false+ otherwise
-    def self.has_capability?(capability)
-      r = Call.libusb_has_capability(capability)
-      return r != 0
+    private def wrap_log_cb(block, mode)
+      if block
+        cb_proc = proc do |p_ctx, lev, str|
+          ctx = case p_ctx
+            when FFI::Pointer::NULL then nil
+            else p_ctx.to_i
+          end
+          block.call(ctx, lev, str)
+        end
+      end
+
+      # Avoid garbage collection of the proc, since only the function pointer is given to libusb
+      if Call::LogCbMode.to_native(mode, nil) & LOG_CB_GLOBAL != 0
+        @log_cb_global_proc = cb_proc
+      end
+      if Call::LogCbMode.to_native(mode, nil) & LOG_CB_CONTEXT != 0
+        @log_cb_context_proc = cb_proc
+      end
+      cb_proc
+    end
+
+    private def option_args_to_ffi(option, args, ctx)
+      case option
+        when :OPTION_LOG_LEVEL, LIBUSB::OPTION_LOG_LEVEL
+          expect_option_args(1, args.length)
+          [:libusb_log_level, args[0]]
+        when :OPTION_USE_USBDK, LIBUSB::OPTION_USE_USBDK
+          expect_option_args(0, args.length)
+          []
+        when :OPTION_NO_DEVICE_DISCOVERY, LIBUSB::OPTION_NO_DEVICE_DISCOVERY
+          expect_option_args(0, args.length)
+          []
+        when :OPTION_LOG_CB, LIBUSB::OPTION_LOG_CB
+          expect_option_args(1, args.length)
+          cb_proc = ctx.send(:wrap_log_cb, args[0], LOG_CB_CONTEXT)
+          [:libusb_log_cb, cb_proc]
+        else
+          raise ArgumentError, "unknown option #{option.inspect}"
+      end
     end
-  else
-    def self.has_capability?(capability)
-      false
+
+    if Call.respond_to?(:libusb_set_option)
+      # Set an default option in the libusb library.
+      #
+      # Use this function to configure a specific option within the library.
+      # See {Call::Options option list}.
+      #
+      # Some options require one or more arguments to be provided.
+      # Consult each option's documentation for specific requirements.
+      #
+      # The option will be added to a list of default options that will be applied to all subsequently created contexts.
+      #
+      # Available since libusb-1.0.22, LIBUSB_API_VERSION >= 0x01000106
+      #
+      # @param [Symbol, Fixnum] option
+      # @param args  Zero or more arguments depending on +option+
+      #
+      # Available since libusb-1.0.22
+      def set_option(option, *args)
+        ffi_args = option_args_to_ffi(option, args, self)
+        res = Call.libusb_set_option(nil, option, *ffi_args)
+        LIBUSB.raise_error res, "in libusb_set_option" if res<0
+      end
+
+      # Convenience function to set default options in the libusb library.
+      #
+      # Use this function to configure any number of options within the library.
+      # It takes a Hash the same way as given to {Context.initialize}.
+      # See also {Call::Options option list}.
+      #
+      # Available since libusb-1.0.22, LIBUSB_API_VERSION >= 0x01000106
+      #
+      # @param [Hash{Call::Options => Object}] options   Option hash
+      # @see set_option
+      def set_options(options={})
+        options.each do |k, v|
+          set_option(k, *Array(v))
+        end
+      end
     end
   end
 end

data/libusb.gemspec

@@ -20,11 +20,9 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
   s.extensions    = ['ext/extconf.rb']
+  s.metadata["yard.run"] = "yri"
 
-  s.required_ruby_version = Gem::Requirement.new(">= 1.9.3")
+  s.required_ruby_version = Gem::Requirement.new(">= 2.5.0")
   s.add_runtime_dependency 'ffi', '~> 1.0'
   s.add_runtime_dependency 'mini_portile2', LIBUSB::MINI_PORTILE_VERSION
-  s.add_development_dependency 'rake-compiler', '~> 1.0'
-  s.add_development_dependency 'rake-compiler-dock', '~> 0.2'
-  s.add_development_dependency 'bundler', '~> 1.0'
 end

data/test/{test_libusb_version.rb → test_libusb.rb}

@@ -16,22 +16,24 @@
 require "minitest/autorun"
 require "libusb"
 
-class TestLibusbVersion < Minitest::Test
-  def setup
-    @v = LIBUSB.version
+class TestLibusb < Minitest::Test
+  def test_has_capability
+    assert LIBUSB.has_capability?(:CAP_HAS_CAPABILITY)
   end
 
   def test_version_parts
-    assert_operator @v.major, :>=, 0
-    assert_operator @v.minor, :>=, 0
-    assert_operator @v.micro, :>=, 0
-    assert_operator @v.nano, :>=, 0
-    assert_kind_of String, @v.rc
+    v = LIBUSB.version
+    assert_operator v.major, :>=, 0
+    assert_operator v.minor, :>=, 0
+    assert_operator v.micro, :>=, 0
+    assert_operator v.nano, :>=, 0
+    assert_kind_of String, v.rc
   end
 
   def test_version_string
-    assert_match(/^\d+\.\d+\.\d+/, @v.to_s)
-    assert_match(/^#<LIBUSB::Version \d+\.\d+\.\d+/, @v.inspect)
+    v = LIBUSB.version
+    assert_match(/^\d+\.\d+\.\d+/, v.to_s)
+    assert_match(/^#<LIBUSB::Version \d+\.\d+\.\d+/, v.inspect)
   end
 
   def test_gem_version_string

data/test/test_libusb_bos.rb

@@ -53,6 +53,23 @@ class TestLibusbBos < Minitest::Test
                 :BT_USB_2_0_EXTENSION,
                 :BT_SS_USB_DEVICE_CAPABILITY,
                 :BT_CONTAINER_ID,
+                :BT_WIRELESS_USB_DEVICE_CAPABILITY,
+                :BT_USB_2_0_EXTENSION,
+                :BT_SS_USB_DEVICE_CAPABILITY,
+                :BT_CONTAINER_ID,
+                :BT_PLATFORM_DESCRIPTOR,
+                :BT_POWER_DELIVERY_CAPABILITY,
+                :BT_BATTERY_INFO_CAPABILITY,
+                :BT_PD_CONSUMER_PORT_CAPABILITY,
+                :BT_PD_PROVIDER_PORT_CAPABILITY,
+                :BT_SUPERSPEED_PLUS,
+                :BT_PRECISION_TIME_MEASUREMENT,
+                :BT_Wireless_USB_Ext,
+                :BT_BILLBOARD,
+                :BT_AUTHENTICATION,
+                :BT_BILLBOARD_EX,
+                :BT_CONFIGURATION_SUMMARY,
+                :BT_FWStatus_Capability,
               ], :include?, cap_type
           end
 
@@ -90,6 +107,11 @@ class TestLibusbBos < Minitest::Test
                 assert_operator 0, :<=, cap.bReserved
                 assert_operator 16, :==, cap.container_id.bytesize, "container_id should be 16 bytes long"
 
+              when Bos::PlatformDescriptor
+                assert_operator 0, :<=, cap.bReserved
+                assert_operator 16, :==, cap.platformCapabilityUUID.bytesize, "container_id should be 16 bytes long"
+                assert_kind_of String, cap.capabilityData
+
               else
                 refute true, "invalid device capability class"
             end

data/test/test_libusb_bulk_stream_transfer.rb

@@ -21,11 +21,18 @@ class TestLibusbBulkStreamTransfer < Minitest::Test
 
   def setup
     c = Context.new
-    begin
-      @dev = c.devices.first.open
-    rescue LIBUSB::ERROR_ACCESS
-      @dev = nil
-      skip "error opening device"
+    c.devices.each do |dev|
+      if [:SPEED_SUPER, :SPEED_SUPER_PLUS].include?(dev.device_speed)
+        dev.endpoints.each do |ep|
+          if ep.transfer_type == :bulk
+            ss = ep.ss_companion
+            if ss.bmAttributes & 0x1f > 0
+              @dev = dev.open
+              break
+            end
+          end
+        end
+      end
     end
   end
 
@@ -34,17 +41,21 @@ class TestLibusbBulkStreamTransfer < Minitest::Test
   end
 
   def test_alloc_streams
-    assert_raises(ERROR_NOT_SUPPORTED, "TODO: test with a OS that supports bulk streams and against a real device") do
-      nr_allocated = @dev.alloc_streams( 2, @dev.device.endpoints )
-    end
+    skip "no device found with bulk stream support" unless @dev
 
-    assert_raises(ERROR_NOT_SUPPORTED) do
-      @dev.free_streams( [0x01,0x82] )
-    end
+    nr_allocated = @dev.alloc_streams( 2, @dev.device.endpoints )
+    assert_equal 2, nr_allocated
+
+    # TODO: test with a OS that supports bulk streams and against a real device
+
+    @dev.free_streams( [0x01,0x82] )
   end
 
   def test_bulk_stream_transfer
-    tr = BulkStreamTransfer.new dev_handle: @dev, stream_id: 123, buffer: ' '*100
+    c = Context.new
+    dev = c.devices.first.open
+    tr = BulkStreamTransfer.new dev_handle: dev, stream_id: 123, buffer: ' '*100
     assert_equal 123, tr.stream_id, "stream_id should match"
+    dev.close
   end
 end

data/test/test_libusb_context.rb

@@ -0,0 +1,88 @@
+# This file is part of Libusb for Ruby.
+#
+# Libusb for Ruby is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Libusb for Ruby is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with Libusb for Ruby.  If not, see <http://www.gnu.org/licenses/>.
+
+require "minitest/autorun"
+require "libusb"
+
+class TestLibusbContext < Minitest::Test
+  def setup
+    @c = LIBUSB::Context.new
+  end
+
+  def teardown
+    @c.exit if @c
+  end
+
+  def test_set_option
+    @c.set_option LIBUSB::OPTION_LOG_LEVEL, LIBUSB::LOG_LEVEL_NONE
+    @c.set_option LIBUSB::OPTION_LOG_LEVEL, LIBUSB::LOG_LEVEL_ERROR
+    @c.set_option LIBUSB::OPTION_LOG_LEVEL, LIBUSB::LOG_LEVEL_WARNING
+    @c.set_option LIBUSB::OPTION_LOG_LEVEL, LIBUSB::LOG_LEVEL_INFO
+    @c.set_option LIBUSB::OPTION_LOG_LEVEL, LIBUSB::LOG_LEVEL_DEBUG
+    @c.set_option :OPTION_LOG_LEVEL, :LOG_LEVEL_NONE
+  end
+
+  def test_set_debug
+    @c.debug = 4
+    @c.debug = 0
+  end
+
+  def test_left_references
+    @test_devs = @c.devices
+    assert_raises(LIBUSB::RemainingReferencesError) do
+      @c.exit
+    end
+    @c = nil
+  end
+
+  def test_double_exit
+    @c.exit
+  end
+
+  def test_log_callback
+    skip "only supported on Linux" unless RUBY_PLATFORM=~/linux/
+    skip "libusb version older than 1.0.27" if Gem::Version.new(LIBUSB.version) < Gem::Version.new("1.0.27")
+
+    LIBUSB.set_options OPTION_LOG_CB: [nil], OPTION_LOG_LEVEL: LIBUSB::LOG_LEVEL_NONE
+    begin
+      called = Hash.new { |h, k| h[k] = [] }
+      LIBUSB.set_options OPTION_LOG_CB: proc{|*a| called[:global] << a }, OPTION_LOG_LEVEL: LIBUSB::LOG_LEVEL_DEBUG
+
+      c = LIBUSB::Context.new OPTION_LOG_CB: proc{|*a| called[:ctx1] << a }, OPTION_NO_DEVICE_DISCOVERY: nil
+      c.devices
+      c.set_log_cb(LIBUSB::LOG_CB_CONTEXT){|*a| called[:ctx2] << a }
+      c.devices
+
+      #pp called
+      assert_nil called[:global][0][0]
+      assert_equal :LOG_LEVEL_DEBUG, called[:global][0][1], called[:global][0][2]
+      assert_match(/libusb_init_context/, called[:global].join)
+      assert_match(/no device discovery/, called[:global].join)
+
+      assert_operator called[:ctx1].size, :>, called[:ctx2].size
+      assert_equal c, called[:ctx1][-1][0]
+      assert_equal :LOG_LEVEL_DEBUG, called[:ctx1][-1][1]
+      assert_match(/libusb_get_device_list/, called[:ctx1][-1][2])
+      assert_match(/no device discovery/, called[:ctx1].join)
+
+      assert_equal c, called[:ctx2][-1][0]
+      assert_equal :LOG_LEVEL_DEBUG, called[:ctx2][-1][1]
+      assert_match(/libusb_get_device_list/, called[:ctx2][-1][2])
+
+    ensure
+      LIBUSB.set_options OPTION_LOG_CB: [nil], OPTION_LOG_LEVEL: LIBUSB::LOG_LEVEL_NONE
+    end
+  end
+end

data/test/test_libusb_descriptors.rb

@@ -119,7 +119,7 @@ class TestLibusbDescriptors < Minitest::Test
 
     usb.devices.each do |dev|
       dev.endpoints.each do |ep|
-        if dev.device_speed == :SPEED_SUPER
+        if [:SPEED_SUPER, :SPEED_SUPER_PLUS].include?(dev.device_speed)
           ss = ep.ss_companion
           assert_match(/SsCompanion/, ss.inspect, "SsCompanion#inspect should work")
 
@@ -172,14 +172,19 @@ class TestLibusbDescriptors < Minitest::Test
   def test_device_filter_hubs
     devs1 = []
     usb.devices.each do |dev|
-      dev.settings.each do |if_desc|
-        if if_desc.bInterfaceClass == CLASS_HUB
-          devs1 << dev
+      if dev.bDeviceClass==CLASS_PER_INTERFACE
+        dev.settings.each do |if_desc|
+          if if_desc.bInterfaceClass==CLASS_HUB
+            devs1 << dev
+          end
         end
+      else
+        devs1 << dev if dev.bDeviceClass == CLASS_HUB
       end
     end
 
     devs2 = usb.devices( bClass: CLASS_HUB )
+
     assert_equal devs1.sort, devs2.sort, "devices and devices with filter should deliver the same device"
   end
 
@@ -189,11 +194,11 @@ class TestLibusbDescriptors < Minitest::Test
       if ep
         assert_operator dev.max_packet_size(ep), :>, 0, "#{dev.inspect} should have a usable packet size"
         assert_operator dev.max_packet_size(ep.bEndpointAddress), :>, 0, "#{dev.inspect} should have a usable packet size"
-        assert_operator dev.max_iso_packet_size(ep), :>, 0, "#{dev.inspect} should have a usable iso packet size"
-        assert_operator dev.max_iso_packet_size(ep.bEndpointAddress), :>, 0, "#{dev.inspect} should have a usable iso packet size"
+        assert_operator dev.max_iso_packet_size(ep), :>=, 0, "#{dev.inspect} should have a usable iso packet size"
+        assert_operator dev.max_iso_packet_size(ep.bEndpointAddress), :>=, 0, "#{dev.inspect} should have a usable iso packet size"
         assert_operator dev.bus_number, :>=, 0, "#{dev.inspect} should have a bus_number"
         assert_operator dev.device_address, :>=, 0, "#{dev.inspect} should have a device_address"
-        assert_operator([:SPEED_UNKNOWN, :SPEED_LOW, :SPEED_FULL, :SPEED_HIGH, :SPEED_SUPER], :include?, dev.device_speed, "#{dev.inspect} should have a device_speed")
+        assert_operator([:SPEED_UNKNOWN, :SPEED_LOW, :SPEED_FULL, :SPEED_HIGH, :SPEED_SUPER, :SPEED_SUPER_PLUS], :include?, dev.device_speed, "#{dev.inspect} should have a device_speed")
         path = dev.port_numbers
         assert_kind_of Array, path, "#{dev.inspect} should have port_numbers"
         path = dev.port_path
@@ -201,12 +206,40 @@ class TestLibusbDescriptors < Minitest::Test
         path.each do |port|
           assert_operator port, :>, 0, "#{dev.inspect} should have proper port_path entries"
         end
-        assert_equal path[-1], dev.port_number, "#{dev.inspect} should have a port number out of the port_path"
-        if parent=dev.parent
-          assert_kind_of Device, parent, "#{dev.inspect} should have a parent"
-          assert_equal path[-2], parent.port_number, "#{dev.inspect} should have a parent port number out of the port_path"
+        if path.empty?
+          assert_nil dev.port_number
+        else
+          assert_equal path[-1], dev.port_number, "#{dev.inspect} should have a port number out of the port_path"
+          if parent=dev.parent
+            assert_kind_of Device, parent, "#{dev.inspect} should have a parent"
+            assert_equal path[-2], parent.port_number, "#{dev.inspect} should have a parent port number out of the port_path" if parent.port_number
+          end
         end
       end
     end
   end
+
+  def test_wrap_sys_device
+    skip unless RUBY_PLATFORM =~ /linux/
+    d = usb.devices[0]
+    File.open(format("/dev/bus/usb/%03d/%03d", d.bus_number, d.device_address), "w+") do |io|
+      devh = usb.wrap_sys_device(io)
+      devh.kernel_driver_active?(0)
+      devh.close
+
+      usb.wrap_sys_device(io) do |devh|
+        devh.kernel_driver_active?(0)
+      end
+    end
+  end
+
+  def test_wrap_sys_device_failure
+    skip unless RUBY_PLATFORM =~ /linux/
+    d = usb.devices[0]
+    assert_raises(LIBUSB::ERROR_OTHER) do
+      File.open(format("/dev/bus/usb/%03d/%03d", d.bus_number, d.device_address), "r") do |io|
+        usb.wrap_sys_device(io).kernel_driver_active?(0)
+      end
+    end
+  end
 end