libusb 0.6.0-x86-linux

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,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 "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
+end

data/test/test_libusb_hotplug.rb

@@ -0,0 +1,127 @@
+# 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
+    @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,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 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
+end

data/test/test_libusb_mass_storage.rb

@@ -0,0 +1,268 @@
+# 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/>.
+#
+# This test requires a connected, but not mounted mass storage device with
+# read/write access allowed. Based on the following specifications:
+#   http://www.usb.org/developers/devclass_docs/usbmassbulk_10.pdf
+#   http://en.wikipedia.org/wiki/SCSI_command
+#
+
+require "minitest/autorun"
+require "libusb"
+
+class TestLibusbMassStorage < Minitest::Test
+  include LIBUSB
+
+  class CSWError < RuntimeError; end
+  BOMS_RESET = 0xFF
+  BOMS_GET_MAX_LUN = 0xFE
+
+  attr_accessor :usb
+  attr_accessor :device
+  attr_accessor :dev
+  attr_accessor :endpoint_in
+  attr_accessor :endpoint_out
+
+  def setup
+    @usb = Context.new
+    @usb.debug = 3
+    @asynchron = false
+
+    @device = usb.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 }
+    @dev = @device.open
+
+    if RUBY_PLATFORM=~/linux/i && dev.kernel_driver_active?(0)
+      dev.detach_kernel_driver(0)
+    end
+    dev.claim_interface(0)
+
+    # clear any pending data
+    dev.clear_halt(endpoint_in)
+  end
+
+  def teardown
+    dev.release_interface(0) if dev
+    dev.close if dev
+  end
+
+  def do_transfer(method, args)
+    if @asynchron
+      stop = false
+      transfer = dev.send(method, args) do |tr|
+        stop = true
+        assert_equal transfer, tr, "block argument should be the transfer instance"
+#         p transfer.status
+      end
+
+      transfer.submit
+      usb.handle_events
+      until stop
+        sleep 0.001
+        usb.handle_events
+      end
+      transfer.result
+    else
+      dev.send(method, args)
+    end
+  end
+  def control_transfer(args)
+    do_transfer(:control_transfer, args)
+  end
+  def bulk_transfer(args)
+    do_transfer(:bulk_transfer, args)
+  end
+
+  def send_mass_storage_command(cdb, data_length, direction=ENDPOINT_IN)
+    @tag ||= 0
+    @tag += 1
+    expected_tag = @tag
+    lun = 0
+
+    cbw = ['USBC', expected_tag, data_length, direction, lun, cdb.length, cdb].pack('a*VVCCCa*')
+    cbw = cbw.ljust(31, "\0")
+
+    num_bytes = bulk_transfer(endpoint: endpoint_out, dataOut: cbw)
+    assert_equal 31, num_bytes, "31 bytes CBW should be sent"
+
+    recv = bulk_transfer(endpoint: endpoint_in, dataIn: data_length)
+
+    get_mass_storage_status(expected_tag)
+    return recv
+  end
+
+  def get_mass_storage_status(expected_tag)
+    retries = 5
+    buffer = begin
+      bulk_transfer(endpoint: endpoint_in, dataIn: 13)
+    rescue LIBUSB::ERROR_PIPE
+      if (retries-=1)>=0
+        dev.clear_halt(endpoint_in)
+        retry
+      end
+      raise
+    end
+    assert_equal 13, buffer.bytesize, "CSW should be 13 bytes long"
+
+    dCSWSignature, dCSWTag, dCSWDataResidue, bCSWStatus = buffer.unpack('a4VVC')
+
+    assert_equal 'USBS', dCSWSignature, "CSW should start with USBS"
+    assert_kind_of Integer, dCSWDataResidue
+    assert_equal expected_tag, dCSWTag, "CSW-tag should be like CBW-tag"
+    raise CSWError, "CSW returned error #{bCSWStatus}" unless bCSWStatus==0
+    buffer
+  end
+
+  def send_inquiry
+    expected_length = 0x24 # INQUIRY_LENGTH
+    cdb = [ 0x12, 0, 0, # Inquiry
+            expected_length, 0,
+            ].pack('CCCnC')
+
+    send_mass_storage_command( cdb, expected_length )
+  end
+
+  def get_capacity
+    expected_length = 0x08 # READ_CAPACITY_LENGTH
+    cdb = [ 0x25, # Read Capacity
+            ].pack('Cx9')
+
+    cap = send_mass_storage_command( cdb, expected_length )
+
+    max_lba, block_size = cap.unpack('NN')
+    device_size = (max_lba + 1) * block_size / (1024*1024*1024.0);
+    printf("   Max LBA: %08X, Block Size: %08X (%.2f GB)\n", max_lba, block_size, device_size);
+  end
+
+  def read_block(start, nr_blocks)
+    expected_length = 0x200 * nr_blocks
+    cdb = [ 0x28, 0, # Read(10)
+            start, 0,
+            nr_blocks, 0,
+            ].pack('CCNCnC')
+    send_mass_storage_command( cdb, expected_length )
+  end
+
+  def invalid_command
+    expected_length = 0x100
+    cdb = [ 0x26, 0, # invalid command
+            ].pack('CC')
+    send_mass_storage_command( cdb, expected_length )
+  end
+
+  def mass_storage_reset
+    res = control_transfer(
+      bmRequestType: ENDPOINT_OUT|REQUEST_TYPE_CLASS|RECIPIENT_INTERFACE,
+      bRequest: BOMS_RESET,
+      wValue: 0, wIndex: 0)
+    assert_equal 0, res, "BOMS_RESET response should be 0 byte"
+
+    res = control_transfer(
+      bmRequestType: ENDPOINT_OUT|REQUEST_TYPE_CLASS|RECIPIENT_INTERFACE,
+      bRequest: BOMS_RESET,
+      wValue: 0, wIndex: 0, dataOut: '')
+    assert_equal 0, res, "BOMS_RESET response should be 0 byte"
+  end
+
+  def read_max_lun
+    res = control_transfer(
+      bmRequestType: ENDPOINT_IN|REQUEST_TYPE_CLASS|RECIPIENT_INTERFACE,
+      bRequest: BOMS_GET_MAX_LUN,
+      wValue: 0, wIndex: 0, dataIn: 1)
+    assert [0].pack("C")==res || [1].pack("C")==res, "BOMS_GET_MAX_LUN response is usually 0 or 1"
+  end
+
+  def test_read_access
+    send_inquiry
+    get_capacity
+
+    data = read_block(0, 1)
+    assert_equal 512, data.length, "Read block should be 512 bytes"
+
+    # closing device handle shouldn't matter, in the meantime
+    dev.close
+    @dev = @device.open
+    dev.claim_interface(0)
+
+    data = read_block(0, 2)
+    assert_equal 1024, data.length, "Read block should be 1024 bytes"
+  end
+#   def test_read_access_async
+#     @asynchron = true
+#     test_read_access
+#   end
+
+  def test_read_failed
+    count = 0
+    th = Thread.new do
+      loop do
+        count+=1
+        sleep 0.01
+      end
+    end
+    assert_raises(LIBUSB::ERROR_TIMEOUT) do
+      begin
+        bulk_transfer(endpoint: endpoint_in, dataIn: 123)
+      rescue LIBUSB::ERROR_TIMEOUT => err
+        assert_kind_of String, err.transferred
+        raise
+      end
+    end
+
+    th.kill
+    dev.clear_halt(endpoint_in)
+    dev.clear_halt(endpoint_out)
+    assert_operator 20, :<=, count, "libusb_handle_events should not block a parallel Thread"
+  end
+#   def test_read_failed_async
+#     @asynchron = true
+#     test_read_failed
+#   end
+
+  def test_max_lun
+    read_max_lun
+  end
+#   def test_max_lun_async
+#     @asynchron = true
+#     read_max_lun
+#   end
+
+  def test_mass_storage_reset
+    mass_storage_reset
+  end
+#   def test_mass_storage_reset_async
+#     @asynchron = true
+#     mass_storage_reset
+#   end
+
+  def test_read_long
+    1000.times do |bl|
+      data = read_block(bl, 1)
+      assert_equal 512, data.length, "Read block should be 512 bytes"
+    end
+  end
+
+  def test_wrong_argument
+    assert_raises(ArgumentError){ dev.bulk_transfer(endpoint: endpoint_in, dataOut: "data") }
+    assert_raises(ArgumentError){ dev.interrupt_transfer(endpoint: endpoint_in, dataOut: "data") }
+    assert_raises(ArgumentError){ dev.control_transfer(
+      bmRequestType: ENDPOINT_OUT|REQUEST_TYPE_CLASS|RECIPIENT_INTERFACE,
+      bRequest: BOMS_RESET,
+      wValue: 0, wIndex: 0, dataIn: 123) }
+  end
+end