libusb 0.3.3-x64-mingw32

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 "test/unit"
+require "libusb/compat"
+
+class TestLibusbCompatMassStorage < Test::Unit::TestCase
+  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,181 @@
+# 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 "test/unit"
+require "libusb"
+
+class TestLibusbDescriptors < Test::Unit::TestCase
+  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_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_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

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 "test/unit"
+require "libusb"
+require "libusb/eventmachine"
+require "eventmachine"
+
+class TestLibusbEventMachine < Test::Unit::TestCase
+  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,37 @@
+# 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 "test/unit"
+require "libusb"
+
+class TestLibusbGc < Test::Unit::TestCase
+  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
+end

data/test/test_libusb_iso_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 "test/unit"
+require "libusb"
+
+class TestLibusbIsoTransfer < Test::Unit::TestCase
+  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_raise(LIBUSB::ERROR_IO, "the randomly choosen device will probably not handle iso transfer") do
+      tr.submit!
+    end
+  end
+end