tem_ruby 0.11.3 → 0.11.4

data/lib/tem/transport/jcop_remote_protocol.rb

@@ -1,59 +0,0 @@
-# :nodoc: namespace
-module Tem::Transport
-  
-# Mixin implementing the JCOP simulator protocol.
-#
-# The (pretty informal) protocol specification is contained in the JavaDocs for
-# the class com.ibm.jc.terminal.RemoteJCTerminal and should be easy to find by
-# http://www.google.com/search?q=%22com.ibm.jc.terminal.RemoteJCTerminal%22  
-module JcopRemoteProtocol
-  # Encodes and sends a JCOP simulator message to a TCP socket.
-  #
-  # The message must contain the following keys:
-  #   type:: Integer expressing the message type (e.g. 1 = APDU exchange)
-  #   node:: Integer expressing the node address (e.g. 0 for most purposes)
-  #   data:: message payload, as an array of Integers ranging from 0 to 255
-  def send_message(socket, message)
-    raw_message = [message[:type], message[:node], message[:data].length].
-                  pack('CCn') + message[:data].pack('C*')
-    socket.send raw_message, 0
-  end
-  
-  # Reads and decodes a JCOP simulator message from a TCP socket.
-  # 
-  # :call_seq:
-  #   client.read_message(socket) -> Hash or nil
-  #
-  # If the other side of the TCP socket closes the connection, this method
-  # returns nil. Otherwise, a Hash is returned, with the format required by the
-  # JcopRemoteProtocol#send_message.
-  def recv_message(socket)
-    header = ''
-    while header.length < 4
-      begin
-        partial = socket.recv 4 - header.length
-      rescue  # Abrupt hangups result in exceptions that we catch here.        
-        return nil
-      end
-      return false if partial.length == 0
-      header += partial
-    end
-    message_type, node_address, data_length = *header.unpack('CCn')
-    raw_data = ''
-    while raw_data.length < data_length
-      begin
-        partial = socket.recv data_length - raw_data.length
-      rescue  # Abrupt hangups result in exceptions that we catch here.
-        return nil
-      end
-      return false if partial.length == 0
-      raw_data += partial
-    end
-    
-    return false unless raw_data.length == data_length
-    data = raw_data.unpack('C*')
-    return { :type => message_type, :node => node_address, :data => data }
-  end
-end  # module JcopRemoteProtocol
-
-end  # namespace Tem::Transport

data/lib/tem/transport/jcop_remote_server.rb

@@ -1,171 +0,0 @@
-require 'socket'
-
-# :nodoc: namespace
-module Tem::Transport
-  
-# Stubs out the methods that can be implemented by the serving logic in a
-# JCOP remote server. Serving logic classes should mix in this module, to
-# avoid having unimplemented methods.
-module JcopRemoteServingStubs
-  # Called when a client connection accepted.
-  #
-  # This method serves as a notification to the serving logic implementation.
-  # Its return value is discarded.
-  def connection_start
-    nil
-  end
-  
-  # Called when a client connection is closed.
-  #
-  # This method serves as a notification to the serving logic implementation.
-  # Its return value is discarded.
-  def connection_end
-    nil
-  end
-  
-  # Serving logic handling an APDU exchange.
-  #
-  # :call-seq:
-  #   logic.exchange_apdu(apdu) -> array
-  #
-  # The |apdu| parameter is the request APDU, formatted as an array of
-  # integers between 0 and 255. The method should return the response APDU,
-  # formatted in a similar manner.  
-  def exchange_apdu(apdu)
-    # Dumb implementation that always returns OK.
-    [0x90, 0x00]
-  end
-end  # module JcopRemoteServingStubs
-    
-
-# A server for the JCOP simulator protocol.
-#
-# The JCOP simulator protocol is generally useful when talking to a real JCOP
-# simulator. This server is only handy for testing, and for forwarding
-# connections (JCOP's Eclipse plug-in makes the simulator listen to 127.0.0.1,
-# and sometimes you want to use it from another box).
-class JcopRemoteServer
-  include JcopRemoteProtocol  
-  
-  # Creates a new JCOP server.
-  #
-  # The options hash supports the following keys:
-  #   port:: the port to serve on
-  #   ip:: the IP of the interface to serve on (defaults to all interfaces)
-  #   reusable:: if set, the serving port can be shared with another
-  #              application (REUSEADDR flag will be set on the socket)
-  #
-  # If the |serving_logic| parameter is nil, a serving logic implementation
-  # must be provided when calling JcopRemoteServer#run. The server will crash
-  # otherwise.
-  def initialize(options, serving_logic = nil)
-    @logic = serving_logic
-    @running = false
-    @options = options
-    @mutex = Mutex.new
-  end
-  
-  # Runs the serving loop indefinitely.
-  #
-  # This method serves incoming conenctions until #stop is called.
-  #
-  # If |serving_logic| contains a non-nil value, it overrides any previously
-  # specified serving logic implementation. If no implementation is specified
-  # when the server is instantiated via JcopRemoteServer#new, one must be
-  # passed into |serving_logic|.
-  def run(serving_logic = nil)
-    @mutex.synchronize do
-      @logic ||= serving_logic
-      @serving_socket = serving_socket @options
-      @running = true
-    end
-    loop do
-      break unless @mutex.synchronize { @running }
-      begin
-        client_socket, client_address = @serving_socket.accept
-      rescue
-        # An exception will occur if the socket is closed
-        break
-      end
-      @logic.connection_start
-      loop do        
-        break unless @mutex.synchronize { @running }
-        break unless process_request client_socket
-      end
-      client_socket.close rescue nil
-      @logic.connection_end  # implemented by subclass
-    end
-    @mutex.synchronize do
-      @serving_socket.close if @serving_socket
-      @serving_socket = nil
-    end
-  end
-
-  # Stops the serving loop.
-  def stop
-    @mutex.synchronize do
-      if @running
-        @serving_socket.close rescue nil
-        @serving_socket = nil
-        @running = false
-      end
-    end
-    
-    # TODO(costan): figure out a way to let serving logic reach this directly.
-  end
-  
-  
-  # Creates a socket listening to incoming connections to this server.
-  # 
-  # :call-seq:
-  #   server.establish_socket(options) -> Socket
-  #
-  # The |options| parameter supports the same keys as the options parameter
-  # of JcopRemoteServer#new.
-  #
-  # Returns a Socket configured to accept incoming connections. 
-  def serving_socket(options)
-    port = options[:port] || 0
-    interface_ip = options[:ip] || '0.0.0.0'
-    serving_address = Socket.pack_sockaddr_in port, interface_ip
-    
-    socket = Socket.new Socket::AF_INET, Socket::SOCK_STREAM,
-                        Socket::PF_UNSPEC
-    
-    if options[:reusable]
-      socket.setsockopt Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true
-    end
-    socket.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, true      
-    socket.bind serving_address
-    socket.listen 5
-    socket
-  end
-  private :serving_socket
-
-  # Performs a request/response cycle.
-  #
-  # :call-seq:
-  #   server.process_request(socket) -> Boolean
-  #
-  # Returns true if the server should do another request/response cycle, or
-  # false if this client indicated it's done talking to the server.
-  def process_request(socket)
-    return false unless request = recv_message(socket)
-    
-    case request[:type]
-    when 0
-      # Wait for card; no-op, because that should have happen when the client
-      # connected.
-      send_message socket, :type => 0, :node => 0, :data => [3, 1, 4, 1, 5, 9]
-    when 1
-      # ATR exchange; the class' bread and butter
-      response = @logic.exchange_apdu request[:data]
-      send_message socket, :type => 1, :node => 0, :data => response
-    else
-      send_message socket, :type => request[:type], :node => 0, :data => []
-    end
-  end
-  private :process_request    
-end  # module JcopRemoteServer
-
-end  # namespace Tem::Transport

data/lib/tem/transport/jcop_remote_transport.rb

@@ -1,65 +0,0 @@
-require 'socket'
-
-# :nodoc: namespace
-module Tem::Transport
-  
-# Implements the transport layer for a JCOP simulator instance.
-class JcopRemoteTransport
-  include JavaCardMixin
-  include JcopRemoteProtocol
-  
-  # Creates a new unconnected transport for a JCOP simulator serving TCP/IP.
-  #
-  # The options parameter must have the following keys:
-  #   host:: the DNS name or IP of the host running the JCOP simulator
-  #   port:: the TCP/IP port of the JCOP simulator server
-  def initialize(options)
-    @host, @port = options[:host], options[:port]
-    @socket = nil
-  end
-  
-  # 
-  def exchange_apdu(apdu)
-    send_message @socket, :type => 1, :node => 0, :data => apdu
-    recv_message(@socket)[:data]
-  end  
-
-  # Makes a transport-level connection to the TEM.
-  def connect
-    begin
-      Socket.getaddrinfo(@host, @port, Socket::AF_INET,
-                         Socket::SOCK_STREAM).each do |addr_info|
-        begin
-          @socket = Socket.new(addr_info[4], addr_info[5], addr_info[6])
-          @socket.connect Socket.pack_sockaddr_in(addr_info[1], addr_info[3])
-          break
-        rescue
-          @socket = nil
-        end
-      end  
-      raise 'Connection refused' unless @socket
-      
-      # Wait for the card to be inserted.
-      send_message @socket, :type => 0, :node => 0, :data => [0, 1, 0, 0]
-      recv_message @socket  # ATR should come here, but who cares      
-    rescue Exception
-      @socket = nil
-      raise
-    end
-  end
-
-  # Breaks down the transport-level connection to the TEM.
-  def disconnect
-    if @socket
-      @socket.close
-      @socket = nil
-    end
-  end
-  
-  def to_s
-    "#<JCOP Remote Terminal: disconnected>" if @socket.nil?
-    "#<JCOP Remote Terminal: #{@host}:#{@port}>"
-  end  
-end  # class JcopRemoteTransport 
-
-end  # module Tem::Transport

data/lib/tem/transport/pcsc_transport.rb

@@ -1,87 +0,0 @@
-require 'rubygems'
-require 'smartcard'
-
-# :nodoc: namespace
-module Tem::Transport
-  
-class PcscTransport
-  include JavaCardMixin
-  PCSC = Smartcard::PCSC
-  
-  def initialize(options)
-    @options = options
-    @context = nil
-    @card = nil
-  end
-
-  def exchange_apdu(apdu)
-    xmit_apdu_string = apdu.pack('C*')
-    result_string = @card.transmit xmit_apdu_string, @xmit_ioreq, @recv_ioreq
-    return result_string.unpack('C*')
-  end
-  
-  def connect
-    @context = PCSC::Context.new(PCSC::SCOPE_SYSTEM) if @context.nil?
-    
-    if @options[:reader_name]
-      @reader_name = @options[:reader_name]
-    else
-      # get the first reader      
-      readers = @context.list_readers nil
-      @reader_name = readers[@options[:reader_index] || 0]
-    end
-    
-    # get the reader's status
-    reader_states = PCSC::ReaderStates.new(1)
-    reader_states.set_reader_name_of!(0, @reader_name)
-    reader_states.set_current_state_of!(0, PCSC::STATE_UNKNOWN)
-    @context.get_status_change reader_states, 100
-    reader_states.acknowledge_events!
-    
-    # prompt for card insertion unless that already happened
-    if (reader_states.current_state_of(0) & PCSC::STATE_PRESENT) == 0
-      puts "Please insert TEM card in reader #{@reader_name}\n"
-      while (reader_states.current_state_of(0) & PCSC::STATE_PRESENT) == 0 do
-        @context.get_status_change reader_states, PCSC::INFINITE_TIMEOUT
-        reader_states.acknowledge_events!
-      end
-      puts "Card detected\n"
-    end
-    
-    # connect to card
-    @card = PCSC::Card.new @context, @reader_name, PCSC::SHARE_EXCLUSIVE,
-                           PCSC::PROTOCOL_ANY
-    
-    # build the transmit / receive IoRequests
-    status = @card.status
-    @xmit_ioreq = @@xmit_iorequest[status[:protocol]]
-    if RUBY_PLATFORM =~ /win/ and (not RUBY_PLATFORM =~ /darwin/)
-      @recv_ioreq = nil
-    else
-      @recv_ioreq = PCSC::IoRequest.new
-    end
-  end
-  
-  def disconnect
-    unless @card.nil?
-      @card.disconnect PCSC::DISPOSITION_LEAVE
-      @card = nil
-    end
-    unless @context.nil?
-      @context.release
-      @context = nil
-    end
-  end  
-
-  def to_s
-    "#<PC/SC Terminal: disconnected>" if @card.nil?
-    "#<PC/SC Terminal: #{@reader_name}>"
-  end
-  
-  @@xmit_iorequest = {
-    Smartcard::PCSC::PROTOCOL_T0 => Smartcard::PCSC::IOREQUEST_T0,
-    Smartcard::PCSC::PROTOCOL_T1 => Smartcard::PCSC::IOREQUEST_T1,
-  }
-end  # class PcscTransport
-
-end  # module Tem::Transport

data/lib/tem/transport/transport.rb

@@ -1,10 +0,0 @@
-# The transport module contains classes responsible for transferring low-level
-# commands issed by the high-level TEM methods to actual TEMs, which can be
-# connected to the system in various ways.  
-module Tem::Transport
-
-  # Shortcut for Tem::Transport::AutoConfigurator#auto_transport
-  def self.auto_transport
-    Tem::Transport::AutoConfigurator.auto_transport
-  end
-end

data/test/transport/test_auto_configurator.rb

@@ -1,114 +0,0 @@
-require 'test/unit'
-
-require 'rubygems'
-require 'flexmock/test_unit'
-
-require 'tem_ruby'
-
-class AutoConfiguratorTest < Test::Unit::TestCase
-  AutoConfigurator = Tem::Transport::AutoConfigurator
-  PcscTransport = Tem::Transport::PcscTransport
-  JcopRemoteTransport = Tem::Transport::JcopRemoteTransport
-    
-  def setup
-    @env_var = AutoConfigurator::ENVIRONMENT_VARIABLE_NAME 
-  end
-
-  def test_env_configuration_blank
-    flexmock(ENV).should_receive(:[]).with(@env_var).and_return(nil)
-    assert_equal nil, AutoConfigurator.env_configuration
-  end
-  def test_env_configuration_remote_port
-    flexmock(ENV).should_receive(:[]).with(@env_var).and_return(':6996')
-    conf = AutoConfigurator.env_configuration
-    assert_equal JcopRemoteTransport, conf[:class]
-    assert_equal({:host => '127.0.0.1', :port => 6996}, conf[:opts])
-  end  
-  def test_env_configuration_remote_noport
-    flexmock(ENV).should_receive(:[]).with(@env_var).and_return(':')
-    conf = AutoConfigurator.env_configuration
-    assert_equal JcopRemoteTransport, conf[:class]
-    assert_equal({:host => '127.0.0.1', :port => 8050}, conf[:opts])
-  end
-  def test_env_configuration_remote_host_port
-    flexmock(ENV).should_receive(:[]).with(@env_var).
-                  and_return('@moonstone:6996')
-    conf = AutoConfigurator.env_configuration
-    assert_equal JcopRemoteTransport, conf[:class]
-    assert_equal({:host => 'moonstone', :port => 6996}, conf[:opts])
-  end
-  def test_env_configuration_remote_host_noport    
-    flexmock(ENV).should_receive(:[]).with(@env_var).and_return('@moonstone')
-    conf = AutoConfigurator.env_configuration
-    assert_equal JcopRemoteTransport, conf[:class]
-    assert_equal({:host => 'moonstone', :port => 8050}, conf[:opts])
-  end
-  def test_env_configuration_remote_ipv6_port
-    flexmock(ENV).should_receive(:[]).with(@env_var).
-                  and_return('@ff80::0080:6996')
-    conf = AutoConfigurator.env_configuration
-    assert_equal JcopRemoteTransport, conf[:class]
-    assert_equal({:host => 'ff80::0080', :port => 6996}, conf[:opts])
-  end
-  def test_env_configuration_remote_ipv6_noport
-    flexmock(ENV).should_receive(:[]).with(@env_var).and_return('@ff80::0080:')
-    conf = AutoConfigurator.env_configuration
-    assert_equal JcopRemoteTransport, conf[:class]
-    assert_equal({:host => 'ff80::0080', :port => 8050}, conf[:opts])
-  end
-
-  def test_env_configuration_pcsc_reader_index
-    flexmock(ENV).should_receive(:[]).with(@env_var).and_return('#1')
-    conf = AutoConfigurator.env_configuration
-    assert_equal PcscTransport, conf[:class]
-    assert_equal({:reader_index => 0}, conf[:opts])
-  end
-  def test_env_configuration_pcsc_reader_name
-    reader_name = 'Awesome Reader'
-    flexmock(ENV).should_receive(:[]).with(@env_var).
-                and_return(reader_name)
-    conf = AutoConfigurator.env_configuration
-    assert_equal PcscTransport, conf[:class]
-    assert_equal({:reader_name => reader_name}, conf[:opts])
-  end
-  
-  def test_try_transport
-    transport = Object.new
-    flexmock(PcscTransport).should_receive(:new).with(:reader_index => 1).
-                            and_return(transport)
-    flexmock(transport).should_receive(:connect)
-    flexmock(PcscTransport).should_receive(:new).with(:reader_index => 2).
-                            and_raise('Boom headshot')
-    failport = Object.new
-    flexmock(PcscTransport).should_receive(:new).with(:reader_index => 3).
-                            and_return(failport)    
-    flexmock(failport).should_receive(:connect).and_raise('Lag')
-    
-    config = { :class => PcscTransport, :opts => {:reader_index => 1} }
-    assert_equal transport, AutoConfigurator.try_transport(config)
-    config = { :class => PcscTransport, :opts => {:reader_index => 2} }
-    assert_equal nil, AutoConfigurator.try_transport(config)
-    config = { :class => PcscTransport, :opts => {:reader_index => 3} }
-    assert_equal nil, AutoConfigurator.try_transport(config)
-  end
-  
-  def test_auto_transport_uses_env
-    flexmock(ENV).should_receive(:[]).with(@env_var).and_return('#1')
-    transport = Object.new
-    flexmock(PcscTransport).should_receive(:new).with(:reader_index => 0).
-                            and_return(transport)
-    flexmock(transport).should_receive(:connect)
-    
-    assert_equal transport, AutoConfigurator.auto_transport
-  end
-  
-  def test_auto_transport_with_defaults
-    flexmock(ENV).should_receive(:[]).with(@env_var).and_return(nil)
-    transport = Object.new
-    flexmock(JcopRemoteTransport).should_receive(:new).and_return(nil)
-    flexmock(PcscTransport).should_receive(:new).and_return(transport)
-    flexmock(transport).should_receive(:connect)    
-        
-    assert_equal transport, AutoConfigurator.auto_transport
-  end
-end

data/test/transport/test_java_card_mixin.rb

@@ -1,90 +0,0 @@
-require 'test/unit'
-
-require 'rubygems'
-require 'flexmock/test_unit'
-
-require 'tem_ruby'
-
-class JavaCardMixinTest < Test::Unit::TestCase
-  JavaCardMixin = Tem::Transport::JavaCardMixin
-  
-  # The sole purpose of this class is wrapping the mixin under test.
-  class MixinWrapper
-    include JavaCardMixin
-  end
-  
-  def setup
-  end
-
-  def test_serialize_apdu
-    s = lambda { |apdu| JavaCardMixin.serialize_apdu apdu }
-
-    assert_equal [0x00, 0x05, 0x00, 0x00, 0x00], s[:ins => 0x05],
-                 'Specified INS'
-    assert_equal [0x00, 0x09, 0x00, 0x01, 0x00], s[:ins => 0x09, :p2 => 0x01],
-                 'Specified INS and P2'
-    assert_equal [0x00, 0xF9, 0xAC, 0xEF, 0x00],
-                 s[:ins => 0xF9, :p1 => 0xAC, :p2 => 0xEF],
-                 'Specified INS, P1, P2'
-    assert_equal [0x00, 0xFA, 0xAD, 0xEC, 0x00],
-                 s[:ins => 0xFA, :p12 => [0xAD, 0xEC]],
-                 'Specified INS, P1+P2'
-    assert_equal [0x00, 0x0E, 0x00, 0x00, 0x04, 0x33, 0x95, 0x81, 0x63],
-                 s[:ins => 0x0E, :data => [0x33, 0x95, 0x81, 0x63]],
-                 'Specified INS and DATA'
-    assert_equal [0x80, 0x0F, 0xBA, 0xBE, 0x03, 0x31, 0x41, 0x59],
-                 s[:cla => 0x80, :ins => 0x0F, :p1 => 0xBA, :p2 => 0xBE,
-                   :data => [0x31, 0x41, 0x59]],
-                 'Specified everything'
-    assert_raise(RuntimeError, 'Did not specify INS') do
-      s[:cla => 0x80, :p1 => 0xBA, :p2 => 0xBE, :data => [0x31, 0x41, 0x59]]
-    end
-  end
-  
-  def test_deserialize_response
-    d = lambda { |response| JavaCardMixin.deserialize_response response }
-    
-    assert_equal({ :status => 0x9000, :data => [] }, d[[0x90, 0x00]])
-    assert_equal({ :status => 0x8631, :data => [] }, d[[0x86, 0x31]])
-    assert_equal({ :status => 0x9000, :data => [0x31, 0x41, 0x59, 0x26] },
-                 d[[0x31, 0x41, 0x59, 0x26, 0x90, 0x00]])
-    assert_equal({ :status => 0x7395, :data => [0x31, 0x41, 0x59, 0x26] },
-                 d[[0x31, 0x41, 0x59, 0x26, 0x73, 0x95]])
-  end
-  
-  def win_mock
-    mock = MixinWrapper.new
-    flexmock(mock).should_receive(:exchange_apdu).
-                   with([0x00, 0xF9, 0xAC, 0x00, 0x02, 0x31, 0x41]).
-                   and_return([0x67, 0x31, 0x90, 0x00])
-    mock
-  end  
-  def win_apdu
-    {:ins => 0xF9, :p1 => 0xAC, :data => [0x31, 0x41]}
-  end
-  
-  def lose_mock
-    mock = MixinWrapper.new
-    flexmock(mock).should_receive(:exchange_apdu).
-                   with([0x00, 0xF9, 0xAC, 0x00, 0x02, 0x31, 0x41]).
-                   and_return([0x86, 0x31])
-    mock
-  end  
-  def lose_apdu
-    win_apdu
-  end
-
-  def test_applet_apdu
-    assert_equal({:status => 0x9000, :data => [0x67, 0x31]},
-                 win_mock.applet_apdu(win_apdu))
-    assert_equal({:status => 0x8631, :data => []},
-                 lose_mock.applet_apdu(lose_apdu))
-  end
-  
-  def test_applet_apdu_bang
-    assert_equal [0x67, 0x31], win_mock.applet_apdu!(win_apdu)
-    assert_raise(RuntimeError) do
-      lose_mock.applet_apdu!(lose_apdu)
-    end
-  end
-end

data/test/transport/test_jcop_remote.rb

@@ -1,82 +0,0 @@
-require 'test/unit'
-
-require 'rubygems'
-require 'flexmock/test_unit'
-
-require 'tem_ruby'
-
-# Tests JcopRemoteProtocol, JcopRemoteServer, and JcopRemoteTransport.
-class JcopRemoteTest < Test::Unit::TestCase
-  Protocol = Tem::Transport::JcopRemoteProtocol
-  Server = Tem::Transport::JcopRemoteServer
-  Transport = Tem::Transport::JcopRemoteTransport
-  
-  # Serving logic that records what it receives and replays a log.
-  class Logic
-    include Protocol
-    attr_reader :received
-    def initialize(responses)
-      @responses = responses
-      @received = []
-    end
-    def connection_start
-      @received << :start
-    end
-    def connection_end
-      @received << :end
-    end
-    def exchange_apdu(apdu)
-      @received << apdu
-      @responses.shift
-    end
-  end
-  
-  def setup
-    @server = Server.new(:ip => '127.0.0.1', :port => 51995)
-    @client = Transport.new :host => '127.0.0.1', :port => 51995
-    @old_abort_on_exception = Thread.abort_on_exception
-    Thread.abort_on_exception = true
-  end
-  
-  def teardown
-    Thread.abort_on_exception = @old_abort_on_exception
-    @server.stop
-  end
-
-  def test_apdu_exchange
-    apdu_request = [0x31, 0x41, 0x59, 0x26, 0x53]
-    apdu_response = [0x27, 0x90, 0x00]
-    
-    logic = Logic.new([apdu_response])
-    Thread.new do
-      begin
-        @server.run logic
-      rescue Exception
-        print $!, "\n"
-        print $!.backtrace.join("\n")
-        raise
-      end
-    end
-    Kernel.sleep 0.05  # Wait for the server to start up.
-    @client.connect
-    assert_equal apdu_response, @client.exchange_apdu(apdu_request)
-    @client.disconnect
-    Kernel.sleep 0.05  # Wait for the server to process the disconnect.
-    assert_equal [:start, apdu_request, :end], logic.received
-  end
-  
-  def test_java_card_integration
-    apdu_request = [0x00, 0x31, 0x41, 0x59, 0x00]
-    apdu_response = [0x27, 0x90, 0x00]
-
-    logic = Logic.new([apdu_response])
-    Thread.new { @server.run logic }
-    Kernel.sleep 0.05  # Wait for the server to start up.
-    @client.connect
-    assert_equal [0x27],
-                 @client.applet_apdu!(:ins => 0x31, :p1 => 0x41, :p2 => 0x59)
-    @client.disconnect
-    Kernel.sleep 0.05  # Wait for the server to process the disconnect.
-    assert_equal [:start, apdu_request, :end], logic.received
-  end
-end