libusb 0.7.0-x64-mingw-ucrt

data/test/test_libusb.rb

@@ -0,0 +1,42 @@
+# 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 TestLibusb < Minitest::Test
+  def test_has_capability
+    assert LIBUSB.has_capability?(:CAP_HAS_CAPABILITY)
+  end
+
+  def test_version_parts
+    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
+    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
+    assert_match(/^\d+\.\d+\.\d+/, LIBUSB::VERSION)
+  end
+end

data/test/test_libusb_bos.rb

@@ -0,0 +1,140 @@
+# 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 TestLibusbBos < Minitest::Test
+  include LIBUSB
+
+  attr_accessor :usb
+
+  def setup
+    @usb = Context.new
+    @usb.debug = 0
+  end
+
+  def test_bos
+    did_bos = false
+    did_cap = false
+    usb.devices.each do |dev|
+      # devices with USB version >= 0x201 could support bos
+      # devices with USB version >= 0x210 must support bos
+      if dev.bcdUSB >= 0x210
+        dev.open do |devh|
+          bos = devh.bos
+          did_bos = true
+
+          assert_equal 5, bos.bLength
+          assert_equal 0x0f, bos.bDescriptorType
+          assert_operator 5, :<=, bos.wTotalLength
+          assert_operator 0, :<=, bos.bNumDeviceCaps
+
+          caps = bos.device_capabilities
+          assert_equal bos.bNumDeviceCaps, caps.length
+          cap_types = bos.device_capability_types
+          assert_equal bos.bNumDeviceCaps, cap_types.length
+
+          cap_types.each do |cap_type|
+            assert_operator [
+                :BT_WIRELESS_USB_DEVICE_CAPABILITY,
+                :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
+
+
+          caps.each do |cap|
+            did_cap = true
+
+            assert_operator 4, :<=, cap.bLength
+            assert_equal LIBUSB::DT_DEVICE_CAPABILITY, cap.bDescriptorType
+            assert_kind_of String, cap.dev_capability_data, "should provide binary capability data"
+            assert_kind_of String, cap.inspect, "should respond to inspect"
+            assert_operator 1, :<=, cap.dev_capability_data.length, "dev_capability_data should be at least one byte"
+
+            case cap
+              when Bos::DeviceCapability
+                assert_kind_of Integer, cap.bDevCapabilityType
+
+              when Bos::Usb20Extension
+                assert_equal 2, cap.bDevCapabilityType
+                assert_operator 0, :<=, cap.bmAttributes
+                assert_operator [true, false], :include?, cap.bm_lpm_support?
+
+              when Bos::SsUsbDeviceCapability
+                assert_equal 3, cap.bDevCapabilityType
+                assert_operator 0, :<=, cap.bmAttributes
+                assert_operator [true, false], :include?, cap.bm_ltm_support?
+                assert_operator 0, :<=, cap.wSpeedSupported
+                assert_kind_of Array, cap.supported_speeds
+                assert_operator 0, :<=, cap.bFunctionalitySupport
+                assert_operator 0, :<=, cap.bU1DevExitLat
+                assert_operator 0, :<=, cap.bU2DevExitLat
+
+              when Bos::ContainerId
+                assert_equal 4, cap.bDevCapabilityType
+                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
+          end
+        end
+      end
+    end
+    skip "no device with BOS available" unless did_bos
+    skip "no device with BOS capability available" unless did_cap
+  end
+
+  def test_no_bos
+    did_failing_bos = false
+
+    # devices with USB version < 0x201 shouldn't support bos
+    if dev=usb.devices.find{|dev| dev.bcdUSB < 0x201 }
+      dev.open do |devh|
+        assert_raises LIBUSB::ERROR_PIPE do
+          devh.bos
+        end
+        did_failing_bos = true
+      end
+    end
+    skip "no device without BOS available" unless did_failing_bos
+  end
+end

data/test/test_libusb_bulk_stream_transfer.rb

@@ -0,0 +1,61 @@
+# 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 TestLibusbBulkStreamTransfer < Minitest::Test
+  include LIBUSB
+
+  def setup
+    c = Context.new
+    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
+
+  def teardown
+    @dev.close if @dev
+  end
+
+  def test_alloc_streams
+    skip "no device found with bulk stream support" unless @dev
+
+    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
+    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_compat.rb

@@ -0,0 +1,78 @@
+# 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/compat"
+
+class TestLibusbCompat < Minitest::Test
+  include USB
+
+  attr_accessor :usb
+
+  def test_find
+    devlist = USB.devices
+    assert_kind_of Array, devlist, "Bus#find should return an Array"
+    assert_kind_of Device, devlist.first, "Bus#find should return Devices"
+    devlist.each do |dev|
+      assert_match( /Device/, dev.inspect, "Device#inspect should work")
+    end
+  end
+
+  def test_constants
+    assert_equal 7, USB_CLASS_PRINTER, "Printer class id should be defined"
+    assert_equal 32, USB_TYPE_CLASS, "type class should be defined"
+  end
+
+  def test_descriptors
+    USB.devices.each do |dev|
+      assert_match(/Device/, dev.inspect, "Device#inspect should work")
+      dev.configurations.each do |config_desc|
+        assert_match(/Configuration/, config_desc.inspect, "Configuration#inspect should work")
+        assert dev.configurations.include?(config_desc), "Device#configurations should include this one"
+
+        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), "Configuration#interfaces should include this one"
+
+          interface.settings.each do |if_desc|
+            assert_match(/Setting/, if_desc.inspect, "Setting#inspect should work")
+
+            assert dev.settings.include?(if_desc), "Device#settings should include this one"
+            assert config_desc.settings.include?(if_desc), "Configuration#settings should include this one"
+            assert interface.settings.include?(if_desc), "Interface#settings should include this one"
+
+            if_desc.endpoints.each do |ep|
+              assert_match(/Endpoint/, ep.inspect, "Endpoint#inspect should work")
+
+              assert dev.endpoints.include?(ep), "Device#endpoints should include this one"
+              assert config_desc.endpoints.include?(ep), "Configuration#endpoints should include this one"
+              assert interface.endpoints.include?(ep), "Interface#endpoints should include this one"
+              assert if_desc.endpoints.include?(ep), "Setting#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_operator 0, :<=, ep.wMaxPacketSize, "packet size should be > 0"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/test/test_libusb_compat_mass_storage.rb

@@ -0,0 +1,81 @@
+# 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/compat"
+
+class TestLibusbCompatMassStorage < Minitest::Test
+  include USB
+
+  attr_accessor :devh
+
+  BOMS_RESET = 0xFF
+  BOMS_GET_MAX_LUN = 0xFE
+
+  def setup
+    devs = []
+    USB.each_device_by_class(USB_CLASS_MASS_STORAGE, 0x01, 0x50){|dev| devs << dev }
+    USB.each_device_by_class(USB_CLASS_MASS_STORAGE, 0x06, 0x50){|dev| devs << dev }
+
+    dev = devs.last
+    skip "no mass storage device found" unless dev
+    devh = dev.open
+    if RUBY_PLATFORM=~/linux/i
+      data = " "*1000
+      begin
+        devh.usb_get_driver_np 0, data
+      rescue Errno::ENODATA
+        data = "nodata exception".ljust(1000, "\0")
+      end
+      assert_match(/\w+/, data, "There should be a driver or an exception")
+      begin
+        # second param is needed because of a bug in ruby-usb
+        devh.usb_detach_kernel_driver_np 0, 123
+      rescue RuntimeError => e
+        assert_match(/ERROR_NOT_FOUND/, e.to_s, "Raise proper exception, if no kernel driver is active")
+      end
+    end
+
+    endpoint_in = dev.endpoints.find{|ep| ep.bEndpointAddress&USB_ENDPOINT_IN != 0 }
+    endpoint_out = dev.endpoints.find{|ep| ep.bEndpointAddress&USB_ENDPOINT_IN == 0 }
+
+    devh.set_configuration 1
+    devh.set_configuration dev.configurations.first
+    devh.claim_interface dev.settings.first
+    devh.clear_halt(endpoint_in)
+    devh.clear_halt(endpoint_out.bEndpointAddress)
+    @devh = devh
+  end
+
+  def teardown
+    if devh
+      devh.release_interface 0
+      devh.usb_close
+    end
+  end
+
+  def test_mass_storage_reset
+    res = devh.usb_control_msg(USB_ENDPOINT_OUT|USB_TYPE_CLASS|USB_RECIP_INTERFACE,
+                BOMS_RESET, 0, 0, "", 2000)
+    assert_equal 0, res, "BOMS_RESET response should be 0 byte"
+  end
+
+  def test_read_max_lun
+    bytes = [].pack('x1')
+    devh.usb_control_msg(USB_ENDPOINT_IN|USB_TYPE_CLASS|USB_RECIP_INTERFACE,
+                BOMS_GET_MAX_LUN, 0, 0, bytes, 100)
+    assert [0].pack("C")==bytes || [1].pack("C")==bytes, "BOMS_GET_MAX_LUN response is usually 0 or 1"
+  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