libusb 0.6.4-x64-mingw32 → 0.7.0-x64-mingw32

data/lib/libusb/dev_handle.rb

@@ -372,19 +372,22 @@ module LIBUSB
     # @yieldparam [String, Integer, LIBUSB::Error] result  result of the transfer is yielded to the block,
     #   when the asynchronous transfer has finished
     # @raise [ArgumentError, LIBUSB::Error] in case of failure
-    def bulk_transfer(args={}, &block)
-      timeout = args.delete(:timeout) || 1000
-      endpoint = args.delete(:endpoint) || raise(ArgumentError, "no endpoint given")
+    def bulk_transfer(timeout: 1000,
+                      endpoint:,
+                      dataIn: nil,
+                      dataOut: nil,
+                      allow_device_memory: false,
+                      &block)
+
       endpoint = endpoint.bEndpointAddress if endpoint.respond_to? :bEndpointAddress
       if endpoint&ENDPOINT_IN != 0
-        dataIn = args.delete(:dataIn) || raise(ArgumentError, "no :dataIn given for bulk read")
+        dataIn || raise(ArgumentError, "no :dataIn given for bulk read")
       else
-        dataOut = args.delete(:dataOut) || raise(ArgumentError, "no :dataOut given for bulk write")
+        dataOut || raise(ArgumentError, "no :dataOut given for bulk write")
       end
-      raise ArgumentError, "invalid params #{args.inspect}" unless args.empty?
 
       # reuse transfer struct to speed up transfer
-      @bulk_transfer ||= BulkTransfer.new dev_handle: self, allow_device_memory: true
+      @bulk_transfer ||= BulkTransfer.new dev_handle: self, allow_device_memory: allow_device_memory
       tr = @bulk_transfer
       tr.endpoint = endpoint
       tr.timeout = timeout
@@ -440,19 +443,21 @@ module LIBUSB
     # @yieldparam [String, Integer, LIBUSB::Error] result  result of the transfer is yielded to the block,
     #   when the asynchronous transfer has finished
     # @raise [ArgumentError, LIBUSB::Error] in case of failure
-    def interrupt_transfer(args={}, &block)
-      timeout = args.delete(:timeout) || 1000
-      endpoint = args.delete(:endpoint) || raise(ArgumentError, "no endpoint given")
+    def interrupt_transfer(timeout: 1000,
+                           endpoint:,
+                           dataIn: nil,
+                           dataOut: nil,
+                           allow_device_memory: false,
+                           &block)
       endpoint = endpoint.bEndpointAddress if endpoint.respond_to? :bEndpointAddress
       if endpoint&ENDPOINT_IN != 0
-        dataIn = args.delete(:dataIn) || raise(ArgumentError, "no :dataIn given for interrupt read")
+        dataIn || raise(ArgumentError, "no :dataIn given for interrupt read")
       else
-        dataOut = args.delete(:dataOut) || raise(ArgumentError, "no :dataOut given for interrupt write")
+        dataOut || raise(ArgumentError, "no :dataOut given for interrupt write")
       end
-      raise ArgumentError, "invalid params #{args.inspect}" unless args.empty?
 
       # reuse transfer struct to speed up transfer
-      @interrupt_transfer ||= InterruptTransfer.new dev_handle: self, allow_device_memory: true
+      @interrupt_transfer ||= InterruptTransfer.new dev_handle: self, allow_device_memory: allow_device_memory
       tr = @interrupt_transfer
       tr.endpoint = endpoint
       tr.timeout = timeout
@@ -497,22 +502,27 @@ module LIBUSB
     # @yieldparam [String, Integer, LIBUSB::Error] result  result of the transfer is yielded to the block,
     #   when the asynchronous transfer has finished
     # @raise [ArgumentError, LIBUSB::Error] in case of failure
-    def control_transfer(args={}, &block)
-      bmRequestType = args.delete(:bmRequestType) || raise(ArgumentError, "param :bmRequestType not given")
-      bRequest = args.delete(:bRequest) || raise(ArgumentError, "param :bRequest not given")
-      wValue = args.delete(:wValue) || raise(ArgumentError, "param :wValue not given")
-      wIndex = args.delete(:wIndex) || raise(ArgumentError, "param :wIndex not given")
-      timeout = args.delete(:timeout) || 1000
+    def control_transfer(bmRequestType:,
+                         bRequest:,
+                         wValue:,
+                         wIndex:,
+                         timeout: 1000,
+                         dataIn: nil,
+                         dataOut: nil,
+                         allow_device_memory: false,
+                         &block)
+
       if bmRequestType&ENDPOINT_IN != 0
-        dataIn = args.delete(:dataIn) || 0
+        raise ArgumentError, "invalid param :dataOut" unless dataOut.nil?
+        dataIn ||= 0
         dataOut = ''
       else
-        dataOut = args.delete(:dataOut) || ''
+        raise ArgumentError, "invalid param :dataIn" unless dataIn.nil?
+        dataOut ||= ''
       end
-      raise ArgumentError, "invalid params #{args.inspect}" unless args.empty?
 
       # reuse transfer struct to speed up transfer
-      @control_transfer ||= ControlTransfer.new dev_handle: self, allow_device_memory: true
+      @control_transfer ||= ControlTransfer.new dev_handle: self, allow_device_memory: allow_device_memory
       tr = @control_transfer
       tr.timeout = timeout
       if dataIn

data/lib/libusb/device.rb

@@ -21,24 +21,27 @@ module LIBUSB
   # Devices of the system can be obtained with {Context#devices} .
   class Device
     include Comparable
+    include ContextReference
 
     # @return [Context] the context this device belongs to.
     attr_reader :context
 
     def initialize context, pDev
       @context = context
-      def pDev.unref_device(id)
-        Call.libusb_unref_device(self)
-      end
-      ObjectSpace.define_finalizer(self, pDev.method(:unref_device))
-      Call.libusb_ref_device(pDev)
       @pDev = pDev
+      register_context(context.instance_variable_get(:@ctx), :libusb_unref_device)
+      Call.libusb_ref_device(pDev)
 
       @pDevDesc = Call::DeviceDescriptor.new
       res = Call.libusb_get_device_descriptor(@pDev, @pDevDesc)
       LIBUSB.raise_error res, "in libusb_get_device_descriptor" if res!=0
     end
 
+    # The pointer for ContextReference
+    private def pointer
+      @pDev
+    end
+
     # Open the device and obtain a device handle.
     #
     # A handle allows you to perform I/O on the device in question.
@@ -160,6 +163,44 @@ module LIBUSB
       res
     end
 
+    if Call.respond_to?(:libusb_get_max_alt_packet_size)
+
+      # Calculate the maximum packet size which a specific endpoint is capable of
+      # sending or receiving in the duration of 1 microframe
+      #
+      # Only the active configuration is examined. The calculation is based on the
+      # wMaxPacketSize field in the endpoint descriptor as described in section
+      # 9.6.6 in the USB 2.0 specifications.
+      #
+      # If acting on an isochronous or interrupt endpoint, this function will
+      # multiply the value found in bits 0:10 by the number of transactions per
+      # microframe (determined by bits 11:12). Otherwise, this function just
+      # returns the numeric value found in bits 0:10. For USB 3.0 device, it
+      # will attempts to retrieve the Endpoint Companion Descriptor to return
+      # wBytesPerInterval.
+      #
+      # This function is useful for setting up isochronous transfers, for example
+      # you might pass the return value from this function to
+      # +IsochronousTransfer.packet_lengths=+ in order to set the length field of every
+      # isochronous packet in a transfer.
+      #
+      # Available since libusb-1.0.27.
+      #
+      # @param [Interface, Fixnum] interface  the interface or its bInterfaceNumber of the interface the endpoint belongs to
+      # @param [Setting, Fixnum] alternate_setting  the alternate setting or its bAlternateSetting
+      # @param [Endpoint, Fixnum] endpoint  (address of) the endpoint in question
+      # @return [Fixnum]  the maximum packet size which can be sent/received on this endpoint
+      # @see max_iso_packet_size
+      def max_alt_packet_size(interface, alternate_setting, endpoint)
+        interface = interface.bInterfaceNumber if interface.respond_to? :bInterfaceNumber
+        alternate_setting = alternate_setting.bAlternateSetting if alternate_setting.respond_to? :bAlternateSetting
+        endpoint = endpoint.bEndpointAddress if endpoint.respond_to? :bEndpointAddress
+        res = Call.libusb_get_max_alt_packet_size(@pDev, interface, alternate_setting, endpoint)
+        LIBUSB.raise_error res, "in libusb_get_max_alt_packet_size" unless res>=0
+        res
+      end
+    end
+
     # Calculate the maximum packet size which a specific endpoint is capable is
     # sending or receiving in the duration of 1 microframe.
     #
@@ -179,6 +220,7 @@ module LIBUSB
     #
     # @param [Endpoint, Fixnum] endpoint  (address of) the endpoint in question
     # @return [Fixnum] the maximum packet size which can be sent/received on this endpoint
+    # @see max_alt_packet_size
     def max_iso_packet_size(endpoint)
       endpoint = endpoint.bEndpointAddress if endpoint.respond_to? :bEndpointAddress
       res = Call.libusb_get_max_iso_packet_size(@pDev, endpoint)
@@ -310,7 +352,7 @@ module LIBUSB
     def manufacturer
       return @manufacturer if defined? @manufacturer
       @manufacturer = try_string_descriptor_ascii(self.iManufacturer)
-      @manufacturer.strip! if @manufacturer
+      @manufacturer = @manufacturer.strip if @manufacturer
       @manufacturer
     end
 
@@ -319,7 +361,7 @@ module LIBUSB
     def product
       return @product if defined? @product
       @product = try_string_descriptor_ascii(self.iProduct)
-      @product.strip! if @product
+      @product = @product.strip if @product
       @product
     end
 
@@ -328,7 +370,7 @@ module LIBUSB
     def serial_number
       return @serial_number if defined? @serial_number
       @serial_number = try_string_descriptor_ascii(self.iSerialNumber)
-      @serial_number.strip! if @serial_number
+      @serial_number = @serial_number.strip if @serial_number
       @serial_number
     end
 

data/lib/libusb/endpoint.rb

@@ -181,13 +181,14 @@ module LIBUSB
       # @return [SsCompanion]
       def ss_companion
         ep_comp = FFI::MemoryPointer.new :pointer
+        ctx = device.context.instance_variable_get(:@ctx)
         res = Call.libusb_get_ss_endpoint_companion_descriptor(
-          device.context.instance_variable_get(:@ctx),
+          ctx,
           pointer,
           ep_comp
         )
         LIBUSB.raise_error res, "in libusb_get_ss_endpoint_companion_descriptor" if res!=0
-        SsCompanion.new ep_comp.read_pointer
+        SsCompanion.new ctx, ep_comp.read_pointer
       end
     end
   end

data/lib/libusb/eventmachine.rb

@@ -62,6 +62,10 @@ class Context
     @eventmachine_attached_fds.each do |fd, watcher|
       watcher.detach
     end
+
+    # Deregister callbacks
+    on_pollfd_added
+    on_pollfd_removed
   end
 
   class EMPollfdHandler < EventMachine::Connection
@@ -118,7 +122,7 @@ class DevHandle
     include EM::Deferrable
 
     def initialize(opts, dev_handle, transfer_method)
-      dev_handle.send(transfer_method, opts) do |res|
+      dev_handle.send(transfer_method, **opts) do |res|
         EM.next_tick do
           if res.kind_of?(LIBUSB::Error)
             fail res
@@ -134,7 +138,7 @@ class DevHandle
   #
   # @see Context#eventmachine_register
   #   DevHandle#interrupt_transfer
-  def eventmachine_interrupt_transfer(opts={})
+  def eventmachine_interrupt_transfer(**opts)
     eventmachine_transfer(opts, :interrupt_transfer)
   end
 
@@ -151,7 +155,7 @@ class DevHandle
   #
   # @see Context#eventmachine_register
   #   DevHandle#bulk_transfer
-  def eventmachine_bulk_transfer(opts={})
+  def eventmachine_bulk_transfer(**opts)
     eventmachine_transfer(opts, :bulk_transfer)
   end
 
@@ -171,7 +175,7 @@ class DevHandle
   #
   # @see Context#eventmachine_register
   #   DevHandle#control_transfer
-  def eventmachine_control_transfer(opts={})
+  def eventmachine_control_transfer(**opts)
     eventmachine_transfer(opts, :control_transfer)
   end
 

data/lib/libusb/gem_helper.rb

@@ -66,7 +66,7 @@ module LIBUSB
       yield if block_given?
     rescue
       Bundler.ui.error "Untagging #{version_tag} due to error."
-      sh_with_code "git tag -d #{version_tag}"
+      sh "git tag -d #{version_tag}"
       raise
     end
 
@@ -87,9 +87,9 @@ module LIBUSB
 
       self.ruby_platform = ruby_platform
       self.recipe = LIBUSB::LibusbRecipe.new
-      recipe.host = host_platform
-      recipe.configure_options << "--host=#{recipe.host}"
-      recipe.configure_options << "CC=#{recipe.host}-gcc -static-libgcc" if recipe.host =~ /mingw/
+      recipe.host = ruby_platform
+      recipe.configure_options << "--host=#{host_platform}"
+      recipe.configure_options << "CC=#{host_platform}-gcc -static-libgcc" if recipe.host =~ /mingw/
       self.libusb_dll = Pathname.new(recipe.path) + libusb_dllname
 
       file libusb_dll do
@@ -98,8 +98,11 @@ module LIBUSB
 
       task "libusb_dll:#{ruby_platform}" => libusb_dll
 
-      desc 'Cross compile libusb for win32'
-      task :cross => [ "libusb_dll:#{ruby_platform}" ] do |t|
+      desc 'Cross compile libusb for all targets'
+      task :cross => "cross:#{ruby_platform}"
+
+      desc "Cross compile libusb for #{ruby_platform}"
+      task "cross:#{ruby_platform}" => [ "libusb_dll:#{ruby_platform}" ] do |t|
         spec = Gem::Specification::load("libusb.gemspec").dup
         spec.platform = Gem::Platform.new(ruby_platform)
         spec.extensions = []

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,16 +28,16 @@ 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
@@ -60,6 +60,10 @@ 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
 
     # The handle for the device to communicate with.
@@ -163,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
@@ -252,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

data/lib/libusb/version_gem.rb

@@ -15,5 +15,5 @@
 
 module LIBUSB
   # Library version of libusb for Ruby
-  VERSION = "0.6.4"
+  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

@@ -22,11 +22,7 @@ Gem::Specification.new do |s|
   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'
-  s.add_development_dependency 'yard', '~> 0.6'
 end

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