libusb 0.6.0-x86-linux

data/libusb.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "libusb/version_gem"
+require "libusb/dependencies"
+
+Gem::Specification.new do |s|
+  s.name        = "libusb"
+  s.version     = LIBUSB::VERSION
+  s.authors     = ["Lars Kanis"]
+  s.email       = ["lars@greiz-reinsdorf.de"]
+  s.homepage    = "http://github.com/larskanis/libusb"
+  s.summary     = %q{Access USB devices from Ruby via libusb-1.0}
+  s.description = %q{LIBUSB is a Ruby binding that gives Ruby programmers access to arbitrary USB devices}
+  s.licenses    = ['LGPL-3.0']
+  s.rdoc_options = %w[--main README.md --charset=UTF-8]
+
+  s.files         = `git ls-files`.split("\n")
+  s.files         << "ports/archives/libusb-#{LIBUSB::LIBUSB_VERSION}.tar.bz2"
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  s.extensions    = ['ext/extconf.rb']
+
+  s.required_ruby_version = Gem::Requirement.new(">= 1.9.3")
+  s.add_runtime_dependency 'ffi', '~> 1.0'
+  s.add_runtime_dependency 'mini_portile2', LIBUSB::MINI_PORTILE_VERSION
+  s.add_development_dependency 'rake-compiler', '~> 0.9'
+  s.add_development_dependency 'rake-compiler-dock', '~> 0.2'
+  s.add_development_dependency 'bundler', '~> 1.0'
+end

data/test/test_libusb_bos.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"
+
+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,
+              ], :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"
+
+              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,50 @@
+# 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
+    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_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
+
+    assert_raises(ERROR_NOT_SUPPORTED) do
+      @dev.free_streams( [0x01,0x82] )
+    end
+  end
+
+  def test_bulk_stream_transfer
+    tr = BulkStreamTransfer.new dev_handle: @dev, stream_id: 123, buffer: ' '*100
+    assert_equal 123, tr.stream_id, "stream_id should match"
+  end
+end

data/test/test_libusb_capability.rb

@@ -0,0 +1,23 @@
+# 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 TestLibusbCapability < Minitest::Test
+  def test_version_parts
+    assert LIBUSB.has_capability?(:CAP_HAS_CAPABILITY)
+  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_descriptors.rb

@@ -0,0 +1,212 @@
+# 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 dev.device_speed == :SPEED_SUPER
+          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|
+      dev.settings.each do |if_desc|
+        if if_desc.bInterfaceClass == CLASS_HUB
+          devs1 << dev
+        end
+      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], :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
+        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"
+        end
+      end
+    end
+  end
+end