libusb 0.7.0-x64-mingw-ucrt

data/test/test_libusb_descriptors.rb

@@ -0,0 +1,245 @@
+# 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 TestLibusbDescriptors < Minitest::Test
+  include LIBUSB
+
+  attr_accessor :usb
+
+  def setup
+    @usb = Context.new
+    @usb.debug = 0
+  end
+
+  def test_descriptors
+    usb.devices.each do |dev|
+      assert_match(/Device/, dev.inspect, "Device#inspect should work")
+
+      assert_kind_of Integer, dev.bLength
+      assert_equal 1, dev.bDescriptorType
+      assert_kind_of Integer, dev.bcdUSB
+      assert_kind_of Integer, dev.bDeviceClass
+      assert_kind_of Integer, dev.bDeviceSubClass
+      assert_kind_of Integer, dev.bDeviceProtocol
+      assert_kind_of Integer, dev.bMaxPacketSize0
+      assert_kind_of Integer, dev.idVendor
+      assert_kind_of Integer, dev.idProduct
+      assert_kind_of Integer, dev.bcdDevice
+      assert_kind_of Integer, dev.iManufacturer
+      assert_kind_of Integer, dev.iProduct
+      assert_kind_of Integer, dev.iSerialNumber
+      assert_kind_of Integer, dev.bNumConfigurations
+
+      dev.configurations.each do |config_desc|
+        assert_match(/Configuration/, config_desc.inspect, "ConfigDescriptor#inspect should work")
+        assert dev.configurations.include?(config_desc), "Device#configurations should include this one"
+
+        assert_kind_of Integer, config_desc.bLength
+        assert_equal 2, config_desc.bDescriptorType
+        assert_kind_of Integer, config_desc.wTotalLength
+        assert_equal config_desc.interfaces.length, config_desc.bNumInterfaces
+        assert_kind_of Integer, config_desc.bConfigurationValue
+        assert_kind_of Integer, config_desc.iConfiguration
+        assert_kind_of Integer, config_desc.bmAttributes
+        assert_kind_of Integer, config_desc.bMaxPower
+        assert_kind_of Integer, config_desc.maxPower # deprecated
+        assert_kind_of String, config_desc.extra if config_desc.extra
+
+        config_desc.interfaces.each do |interface|
+          assert_match(/Interface/, interface.inspect, "Interface#inspect should work")
+
+          assert dev.interfaces.include?(interface), "Device#interfaces should include this one"
+          assert config_desc.interfaces.include?(interface), "ConfigDescriptor#interfaces should include this one"
+
+          interface.alt_settings.each do |if_desc|
+            assert_match(/Setting/, if_desc.inspect, "InterfaceDescriptor#inspect should work")
+
+            assert dev.settings.include?(if_desc), "Device#settings should include this one"
+            assert config_desc.settings.include?(if_desc), "ConfigDescriptor#settings should include this one"
+            assert interface.alt_settings.include?(if_desc), "Inteerface#alt_settings should include this one"
+
+            assert_kind_of Integer, if_desc.bLength
+            assert_equal 4, if_desc.bDescriptorType
+            assert_kind_of Integer, if_desc.bInterfaceNumber
+            assert_kind_of Integer, if_desc.bAlternateSetting
+            assert_equal if_desc.endpoints.length, if_desc.bNumEndpoints
+            assert_kind_of Integer, if_desc.bInterfaceClass
+            assert_kind_of Integer, if_desc.bInterfaceSubClass
+            assert_kind_of Integer, if_desc.bInterfaceProtocol
+            assert_kind_of Integer, if_desc.iInterface
+            assert_kind_of String, if_desc.extra if if_desc.extra
+
+            if_desc.endpoints.each do |ep|
+              assert_match(/Endpoint/, ep.inspect, "EndpointDescriptor#inspect should work")
+
+              assert dev.endpoints.include?(ep), "Device#endpoints should include this one"
+              assert config_desc.endpoints.include?(ep), "ConfigDescriptor#endpoints should include this one"
+              assert interface.endpoints.include?(ep), "Inteerface#endpoints should include this one"
+              assert if_desc.endpoints.include?(ep), "InterfaceDescriptor#endpoints should include this one"
+
+              assert_equal if_desc, ep.setting, "backref should be correct"
+              assert_equal interface, ep.interface, "backref should be correct"
+              assert_equal config_desc, ep.configuration, "backref should be correct"
+              assert_equal dev, ep.device, "backref should be correct"
+
+              assert_kind_of Integer, ep.bLength
+              assert_equal 5, ep.bDescriptorType
+              assert_kind_of Integer, ep.bEndpointAddress
+              assert_kind_of Integer, ep.bmAttributes
+              assert_operator 0, :<=, ep.wMaxPacketSize, "packet size should be > 0"
+              assert_kind_of Integer, ep.bInterval
+              assert_kind_of Integer, ep.bRefresh
+              assert_kind_of Integer, ep.bSynchAddress
+              assert_kind_of String, ep.extra if ep.extra
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def test_ss_companion
+    did_cc_companion = false
+    did_failing_cc_companion = false
+
+    usb.devices.each do |dev|
+      dev.endpoints.each do |ep|
+        if [:SPEED_SUPER, :SPEED_SUPER_PLUS].include?(dev.device_speed)
+          ss = ep.ss_companion
+          assert_match(/SsCompanion/, ss.inspect, "SsCompanion#inspect should work")
+
+          assert_kind_of Integer, ss.bLength
+          assert_equal LIBUSB::DT_SS_ENDPOINT_COMPANION, ss.bDescriptorType
+          assert_kind_of Integer, ss.bMaxBurst
+          assert_kind_of Integer, ss.bmAttributes
+          assert_kind_of Integer, ss.wBytesPerInterval
+          did_cc_companion = true
+        elsif !did_failing_cc_companion
+          assert_raises ERROR_NOT_FOUND do
+            ep.ss_companion
+          end
+          did_failing_cc_companion = true
+        end
+      end
+    end
+
+    skip "no device with cc_companion available" unless did_cc_companion
+    skip "no device without cc_companion available" unless did_failing_cc_companion
+  end
+
+  def test_constants
+    assert_equal 7, CLASS_PRINTER, "Printer class id should be defined"
+    assert_equal 48, ISO_USAGE_TYPE_MASK, "iso usage type should be defined"
+  end
+
+  def test_device_filter_mass_storages
+    devs1 = []
+    usb.devices.each do |dev|
+      dev.settings.each do |if_desc|
+        if if_desc.bInterfaceClass == CLASS_MASS_STORAGE &&
+              ( if_desc.bInterfaceSubClass == 0x01 ||
+                if_desc.bInterfaceSubClass == 0x06 ) &&
+              if_desc.bInterfaceProtocol == 0x50
+
+          devs1 << dev
+        end
+      end
+    end
+
+    devs2 =  usb.devices( bClass: CLASS_MASS_STORAGE, bSubClass: 0x01, bProtocol: 0x50 )
+    devs2 += usb.devices( bClass: CLASS_MASS_STORAGE, bSubClass: 0x06, bProtocol: 0x50 )
+    assert_equal devs1.sort, devs2.sort, "devices and devices with filter should deliver the same device"
+
+    devs3 =  usb.devices( bClass: [CLASS_MASS_STORAGE], bSubClass: [0x01,0x06], bProtocol: [0x50] )
+    assert_equal devs1.sort, devs3.sort, "devices and devices with array-filter should deliver the same device"
+  end
+
+  def test_device_filter_hubs
+    devs1 = []
+    usb.devices.each do |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
+
+  def test_device_methods
+    usb.devices.each do |dev|
+      ep = dev.endpoints.first
+      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.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, :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
+        assert_kind_of Array, path, "#{dev.inspect} should have a port_path"
+        path.each do |port|
+          assert_operator port, :>, 0, "#{dev.inspect} should have proper port_path entries"
+        end
+        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

data/test/test_libusb_event_machine.rb

@@ -0,0 +1,118 @@
+# 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"
+require "libusb/eventmachine"
+require "eventmachine"
+
+class TestLibusbEventMachine < Minitest::Test
+  include LIBUSB
+  BOMS_GET_MAX_LUN = 0xFE
+
+  attr_accessor :context
+  attr_accessor :device
+  attr_accessor :devh
+  attr_accessor :endpoint_in
+  attr_accessor :endpoint_out
+
+  def setup
+    @context = Context.new
+    @context.debug = 3
+
+    @device = context.devices( bClass: CLASS_MASS_STORAGE, bSubClass: [0x06,0x01], bProtocol: 0x50 ).last
+    skip "no mass storage device found" unless @device
+
+    @endpoint_in = @device.endpoints.find{|ep| ep.bEndpointAddress&ENDPOINT_IN != 0 }
+    @endpoint_out = @device.endpoints.find{|ep| ep.bEndpointAddress&ENDPOINT_IN == 0 }
+    @devh = @device.open
+
+    if RUBY_PLATFORM=~/linux/i && devh.kernel_driver_active?(0)
+      devh.detach_kernel_driver(0)
+    end
+    devh.claim_interface(0)
+
+    # clear any pending data
+    devh.clear_halt(endpoint_in)
+  end
+
+  def teardown
+  end
+
+  def em_run
+    EventMachine.run do
+      @context.eventmachine_register
+
+      EventMachine.add_shutdown_hook do
+        @devh.release_interface(0) if @devh
+        @devh.close if @devh
+        @context.eventmachine_unregister
+      end
+
+      yield
+    end
+  end
+
+
+  def test_bulk_transfer
+    em_run do
+      ticks = 0
+      tr = devh.eventmachine_bulk_transfer(
+          endpoint: @endpoint_in,
+          timeout: 1500,
+          dataIn: 123 )
+#       puts "started usb transfer #{tr}"
+
+      tr.callback do |data|
+#         puts "recved: #{data.inspect}"
+
+        assert false, "the bulk transfer shouldn't succeed"
+        EventMachine.stop
+      end
+      tr.errback do |text|
+#         puts "recv-err: #{text}"
+        assert true, "the bulk transfer should fail"
+
+        assert_operator ticks, :>=, 4
+        EventMachine.stop
+      end
+
+      EventMachine.add_periodic_timer(0.333) do
+        ticks += 1
+      end
+    end
+  end
+
+  def test_event_loop
+    em_run do
+      tr = devh.eventmachine_control_transfer(
+        bmRequestType: ENDPOINT_IN|REQUEST_TYPE_CLASS|RECIPIENT_INTERFACE,
+        bRequest: BOMS_GET_MAX_LUN,
+        wValue: 0, wIndex: 0, dataIn: 1 )
+
+#       puts "started usb transfer #{tr}"
+      tr.callback do |data|
+#         puts "recved: #{data.inspect}"
+        assert true, "the control transfer should succeed"
+        EventMachine.stop
+      end
+      tr.errback do |text|
+#         puts "recv-err: #{text}"
+        assert false, "the control transfer shouldn't fail"
+        EventMachine.stop
+      end
+    end
+  end
+end

data/test/test_libusb_gc.rb

@@ -0,0 +1,52 @@
+# 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/>.
+#
+# These tests should be started with valgrind to check for
+# invalid memmory access.
+
+require "minitest/autorun"
+require "libusb"
+
+class TestLibusbGc < Minitest::Test
+  include LIBUSB
+
+  def get_some_endpoint
+    Context.new.devices.each do |dev|
+      return dev.endpoints.last unless dev.endpoints.empty?
+    end
+  end
+
+  def test_descriptors
+    ep = get_some_endpoint
+    ps = ep.wMaxPacketSize
+    GC.start
+    assert_equal ps, ep.wMaxPacketSize, "GC should not free EndpointDescriptor"
+  end
+
+  def test_log_cb
+    LIBUSB.set_options OPTION_LOG_CB: proc{}, OPTION_LOG_LEVEL: LIBUSB::LOG_LEVEL_DEBUG
+
+    c = LIBUSB::Context.new OPTION_LOG_CB: proc{}, OPTION_NO_DEVICE_DISCOVERY: nil
+    GC.start
+    c.devices
+    c.set_log_cb(LIBUSB::LOG_CB_CONTEXT){}
+    c.devices
+    GC.start
+    c.devices
+
+  ensure
+    LIBUSB.set_options OPTION_LOG_CB: [nil], OPTION_LOG_LEVEL: LIBUSB::LOG_LEVEL_NONE
+  end
+end

data/test/test_libusb_hotplug.rb

@@ -0,0 +1,129 @@
+# 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 TestLibusbHotplug < Minitest::Test
+  include LIBUSB
+
+  attr_reader :ctx
+
+  def setup
+    @ctx = Context.new
+  end
+
+  def teardown
+    # No need to release the LIBUSB::Context any longer.
+    # It is cleaned up by the GC.
+    # @ctx.exit
+  end
+
+  def test_enumerate
+    devs = []
+    ctx.on_hotplug_event flags: HOTPLUG_ENUMERATE do |dev, event|
+      devs << dev
+      assert_equal :HOTPLUG_EVENT_DEVICE_ARRIVED, event
+      :repeat
+    end
+    # Not really necessary, but just to be sure that the callback was called:
+    ctx.handle_events 0
+
+    assert_equal ctx.devices.sort, devs.sort
+  end
+
+  def test_enumerate_with_left
+    devs = []
+    ctx.on_hotplug_event flags: HOTPLUG_ENUMERATE, events: HOTPLUG_EVENT_DEVICE_LEFT do |dev, event|
+      devs << dev
+      assert_equal :HOTPLUG_EVENT_DEVICE_ARRIVED, event
+      :repeat
+    end
+    # Not really necessary, but just to be sure that the callback was called:
+    ctx.handle_events 0
+
+    assert_equal [], devs.sort, "Enumerate should not send any LEFT events"
+  end
+
+  def test_deregister
+    handle1 = ctx.on_hotplug_event{ assert false, "Callback should not be called" }
+    handle2 = ctx.on_hotplug_event{ assert false, "Callback should not be called" }
+    handle1.deregister
+    handle2.deregister
+    ctx.handle_events 0
+  end
+
+  def test_wrong_yieldreturn
+    ex = assert_raises(ArgumentError) do
+      ctx.on_hotplug_event flags: :HOTPLUG_ENUMERATE do |dev, event|
+      end
+    end
+
+    assert_match(/:finish.*:repeat/, ex.to_s, "Should give a useful hint")
+  end
+
+  def test_context
+    handle = ctx.on_hotplug_event do |dev, event|
+    end
+    assert_equal ctx, handle.context, "The callback handle should have it's context"
+  end
+
+  def test_real_device_plugging_and_yieldreturn_and_gc_and_deregister
+    # This callback should be triggered once
+    devs = []
+    ctx.on_hotplug_event do |dev, event|
+      devs << [dev, event]
+      :finish
+    end
+
+    # This callback should be triggered twice
+    devs2 = []
+    ctx.on_hotplug_event do |dev, event|
+      devs2 << [dev, event]
+      puts format("  %p: %p", event, dev)
+      :repeat
+    end
+
+    # This callback should never be triggered
+    handle = ctx.on_hotplug_event{ assert false, "Deregistered callback should never be called" }
+
+    # GC shouldn't free any relevant callbacks or blocks
+    GC.start
+
+    print "\nPlease add and remove an USB device (2*5 sec): "
+    handle.deregister
+    ctx.handle_events 0
+    ctx.handle_events 5000
+    ctx.handle_events 5000
+
+    skip "no hotplug action taken" if devs.empty? && devs2.empty?
+    assert_equal 1, devs.length, "Should be deregistered after the first event"
+    assert_equal 2, devs2.length, "Should have received two events"
+    assert_operator devs2.map(&:last), :include?, :HOTPLUG_EVENT_DEVICE_ARRIVED, "Should have received ARRIVED"
+    assert_operator devs2.map(&:last), :include?, :HOTPLUG_EVENT_DEVICE_LEFT, "Should have received LEFT"
+  end
+
+  def test_interrupt_event_handler
+    th = Thread.new do
+      ctx.handle_events 5000
+    end
+
+    sleep 0.1 # Workaround a bug in libusb-1,0.21
+    st = Time.now
+    ctx.interrupt_event_handler
+    th.join
+    assert_operator Time.now-st, :<, 5.0
+  end
+end

data/test/test_libusb_iso_transfer.rb

@@ -0,0 +1,56 @@
+# 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 TestLibusbIsoTransfer < Minitest::Test
+  include LIBUSB
+
+  def setup
+    c = Context.new
+    begin
+      @dev = c.devices.first.open
+    rescue LIBUSB::ERROR_ACCESS
+      @dev = nil
+      skip "error opening device"
+    end
+  end
+
+  def teardown
+    @dev.close if @dev
+  end
+
+  def test_iso_transfer
+    tr = IsochronousTransfer.new 10, dev_handle: @dev
+    assert_equal 10, tr.num_packets, "number of packets should match"
+
+    tr.buffer = " "*130
+    tr.packet_lengths = 13
+    tr[7].length = 12
+    assert_equal 12, tr[7].length, "packet length should be set"
+    assert_equal 13, tr[8].length, "packet length should be set"
+
+    assert_raises(LIBUSB::ERROR_IO, "the randomly choosen device will probably not handle iso transfer") do
+      tr.submit!
+    end
+  end
+
+  def test_max_alt_packet_size
+    d = Context.new.devices[0]
+    size = d.max_alt_packet_size d.interfaces[0], d.settings[0], d.endpoints[0]
+    assert_operator 0, :<=, size
+  end
+end