eventmachine-with-ipv6 1.0.0.beta.4.ipv6.0

data/tests/test_ipv6.rb

@@ -0,0 +1,135 @@
+require 'em_test_helper'
+require 'socket'
+
+class TestIPv6 < Test::Unit::TestCase
+
+  begin
+    socket = Addrinfo.udp("2001::1", 1).connect
+    @@local_ipv6 = socket.local_address.ip_address
+    socket.close
+
+    # Tries to connect to ipv6.google.com port 80 via TCP.
+    # Timeout in 2 seconds.
+    def test_ipv6_tcp_client
+      conn = nil
+      setup_timeout(4)
+
+      EM.run do
+        conn = EM::connect("2a00:1450:4001:c01::93", 80) do |c|
+          def c.connected
+            @connected
+          end
+
+          def c.unbind(reason)
+            warn "unbind: #{reason.inspect}" if reason # XXX at least find out why it failed
+          end
+
+          def c.connection_completed
+            @connected = true
+            EM.stop
+          end
+        end
+      end
+
+      assert conn.connected
+    end
+
+    # Runs a TCP server in the local IPv6 address, connects to it and sends a specific data.
+    # Timeout in 2 seconds.
+    def test_ipv6_tcp_local_server
+      @@received_data = nil
+      @local_port = next_port
+      setup_timeout(2)
+
+      EM.run do
+        EM.start_server(@@local_ipv6, @local_port) do |s|
+          def s.receive_data data
+            @@received_data = data
+            EM.stop
+          end
+        end
+
+        EM::connect(@@local_ipv6, @local_port) do |c|
+          def c.unbind(reason)
+            warn "unbind: #{reason.inspect}" if reason # XXX at least find out why it failed
+          end
+          c.send_data "ipv6/tcp"
+        end
+      end
+
+      assert_equal "ipv6/tcp", @@received_data
+    end
+
+    # Runs a UDP server in the local IPv6 address, connects to it and sends a specific data.
+    # Timeout in 2 seconds.
+    def test_ipv6_udp_local_server
+      @@received_data = nil
+      @local_port = next_port
+      setup_timeout(2)
+
+      EM.run do
+        EM.open_datagram_socket(@@local_ipv6, @local_port) do |s|
+          def s.receive_data data
+            @@received_data = data
+            EM.stop
+          end
+        end
+
+        EM.open_datagram_socket(@@local_ipv6, next_port) do |c|
+          c.send_datagram "ipv6/udp", @@local_ipv6, @local_port
+        end
+      end
+
+      assert_equal "ipv6/udp", @@received_data
+    end
+
+    # Try to connect via TCP to an invalid IPv6. EM.connect should raise
+    # EM::ConnectionError.
+    def test_tcp_connect_to_invalid_ipv6
+      invalid_ipv6 = "1:A"
+
+      EM.run do
+        begin
+          error = nil
+          EM.connect(invalid_ipv6, 1234)
+        rescue => e
+          error = e
+        ensure
+          EM.stop
+          assert_equal EM::ConnectionError, (error && error.class)
+        end
+      end
+    end
+
+    # Try to send a UDP datagram to an invalid IPv6. EM.send_datagram should raise
+    # EM::ConnectionError.
+    def test_udp_send_datagram_to_invalid_ipv6
+      invalid_ipv6 = "1:A"
+
+      EM.run do
+        begin
+          error = nil
+          EM.open_datagram_socket(@@local_ipv6, next_port) do |c|
+            c.send_datagram "hello", invalid_ipv6, 1234
+          end
+        rescue => e
+          error = e
+        ensure
+          EM.stop
+          assert_equal EM::ConnectionError, (error && error.class)
+        end
+      end
+    end
+
+
+  rescue => e
+    warn "cannot autodiscover local IPv6 (#{e.class}: #{e.message}), skipping tests in #{__FILE__}"
+
+    # Because some rubies will complain if a TestCase class has no tests
+    def test_ipv6_unavailable
+      assert true
+    end
+
+  end
+
+end

data/tests/test_kb.rb

@@ -0,0 +1,34 @@
+require 'em_test_helper'
+
+class TestKeyboardEvents < Test::Unit::TestCase
+
+  if !jruby?
+    module KbHandler
+      include EM::Protocols::LineText2
+      def receive_line d
+        EM::stop if d == "STOP"
+      end
+    end
+
+    # This test doesn't actually do anything useful but is here to
+    # illustrate the usage. If you removed the timer and ran this test
+    # by itself on a console, and then typed into the console, it would
+    # work.
+    # I don't know how to get the test harness to simulate actual keystrokes.
+    # When someone figures that out, then we can make this a real test.
+    #
+    def test_kb
+      EM.run {
+        EM.open_keyboard KbHandler
+        EM::Timer.new(1) { EM.stop }
+      } if $stdout.tty? # don't run the test unless it stands a chance of validity.
+    end
+  else
+    warn "EM.open_keyboard not implemented, skipping tests in #{__FILE__}"
+
+    # Because some rubies will complain if a TestCase class has no tests
+    def test_em_open_keyboard_unsupported
+      assert true
+    end
+  end
+end

data/tests/test_ltp.rb

@@ -0,0 +1,138 @@
+require 'em_test_helper'
+
+class TestLineAndTextProtocol < Test::Unit::TestCase
+
+  class SimpleLineTest < EM::P::LineAndTextProtocol
+    def receive_line line
+      @line_buffer << line
+    end
+  end
+
+  module StopClient
+    def set_receive_data(&blk)
+      @rdb = blk
+    end
+
+    def receive_data data
+      @rdb.call(data) if @rdb
+    end
+
+    def unbind
+      EM.add_timer(0.1) { EM.stop }
+    end
+  end
+
+  def setup
+    @port = next_port
+  end
+
+  def test_simple_lines
+    lines_received = []
+    EM.run {
+      EM.start_server( "127.0.0.1", @port, SimpleLineTest ) do |conn|
+        conn.instance_eval "@line_buffer = lines_received"
+      end
+      setup_timeout
+
+      EM.connect "127.0.0.1", @port, StopClient do |c|
+        c.send_data "aaa\nbbb\r\nccc\n"
+        c.close_connection_after_writing
+      end
+    }
+    assert_equal( %w(aaa bbb ccc), lines_received )
+  end
+
+  #--------------------------------------------------------------------
+
+  class SimpleLineTest < EM::P::LineAndTextProtocol
+    def receive_error text
+      @error_message << text
+    end
+  end
+
+  def test_overlength_lines
+    lines_received = []
+    EM.run {
+      EM.start_server( "127.0.0.1", @port, SimpleLineTest ) do |conn|
+        conn.instance_eval "@error_message = lines_received"
+      end
+      setup_timeout
+
+      EM.connect "127.0.0.1", @port, StopClient do |c|
+        c.send_data "a" * (16*1024 + 1)
+        c.send_data "\n"
+        c.close_connection_after_writing
+      end
+
+    }
+    assert_equal( ["overlength line"], lines_received )
+  end
+
+
+  #--------------------------------------------------------------------
+
+  class LineAndTextTest < EM::P::LineAndTextProtocol
+    def receive_line line
+      if line =~ /content-length:\s*(\d+)/i
+        @content_length = $1.to_i
+      elsif line.length == 0
+        set_binary_mode @content_length
+      end
+    end
+    def receive_binary_data text
+      send_data "received #{text.length} bytes"
+      close_connection_after_writing
+    end
+  end
+
+  def test_lines_and_text
+    output = ''
+    EM.run {
+      EM.start_server( "127.0.0.1", @port, LineAndTextTest )
+      setup_timeout
+
+      EM.connect "127.0.0.1", @port, StopClient do |c|
+        c.set_receive_data { |data| output << data }
+        c.send_data "Content-length: 400\n"
+        c.send_data "\n"
+        c.send_data "A" * 400
+        EM.add_timer(0.1) { c.close_connection_after_writing }
+      end
+    }
+    assert_equal( "received 400 bytes", output )
+  end
+
+  #--------------------------------------------------------------------
+
+
+  class BinaryTextTest < EM::P::LineAndTextProtocol
+    def receive_line line
+      if line =~ /content-length:\s*(\d+)/i
+        set_binary_mode $1.to_i
+      else
+        raise "protocol error"
+      end
+    end
+    def receive_binary_data text
+      send_data "received #{text.length} bytes"
+      close_connection_after_writing
+    end
+  end
+
+  def test_binary_text
+    output = ''
+    EM.run {
+      EM.start_server( "127.0.0.1", @port, BinaryTextTest )
+      setup_timeout
+
+      EM.connect "127.0.0.1", @port, StopClient do |c|
+        c.set_receive_data { |data| output << data }
+        c.send_data "Content-length: 10000\n"
+        c.send_data "A" * 10000
+        EM.add_timer(0.1) { c.close_connection_after_writing }
+      end
+    }
+    assert_equal( "received 10000 bytes", output )
+  end
+
+end

data/tests/test_ltp2.rb

@@ -0,0 +1,288 @@
+require 'em_test_helper'
+
+# TODO!!! Need tests for overlength headers and text bodies.
+
+class TestLineText2 < Test::Unit::TestCase
+
+  # Run each of these tests two ways: passing in the whole test-dataset in one chunk,
+  # and passing it in one character at a time.
+
+  class Basic
+    include EM::Protocols::LineText2
+    attr_reader :lines
+    def receive_line line
+      (@lines ||= []) << line
+    end
+  end
+  def test_basic
+    testdata = "Line 1\nLine 2\r\nLine 3\n"
+
+    a = Basic.new
+    a.receive_data testdata
+    assert_equal( ["Line 1", "Line 2", "Line 3"], a.lines )
+
+    a = Basic.new
+    testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
+    assert_equal( ["Line 1", "Line 2", "Line 3"], a.lines )
+  end
+
+  class ChangeDelimiter
+    include EM::Protocols::LineText2
+    attr_reader :lines
+    def initialize *args
+      super
+      @delim = "A"
+      set_delimiter @delim
+    end
+    def receive_line line
+      (@lines ||= []) << line
+      set_delimiter( @delim.succ! )
+    end
+  end
+
+  def test_change_delimiter
+    testdata = %Q(LineaALinebBLinecCLinedD)
+
+    a = ChangeDelimiter.new
+    a.receive_data testdata
+    assert_equal( ["Linea", "Lineb", "Linec", "Lined"], a.lines )
+
+    a = ChangeDelimiter.new
+    testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
+    assert_equal( ["Linea", "Lineb", "Linec", "Lined"], a.lines )
+  end
+
+
+  #--
+  # Test two lines followed by an empty line, ten bytes of binary data, then
+  # two more lines.
+
+  class Binary
+    include EM::Protocols::LineText2
+    attr_reader :lines, :body
+    def initialize *args
+      super
+      @lines = []
+      @body = nil
+    end
+    def receive_line ln
+      if ln == ""
+        set_text_mode 10
+      else
+        @lines << ln
+      end
+    end
+    def receive_binary_data data
+      @body = data
+    end
+  end
+
+  def test_binary
+    testdata = %Q(Line 1
+Line 2
+
+0000000000Line 3
+Line 4
+)
+
+    a = Binary.new
+    a.receive_data testdata
+    assert_equal( ["Line 1", "Line 2", "Line 3", "Line 4"], a.lines)
+    assert_equal( "0000000000", a.body )
+
+    a = Binary.new
+    testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
+    assert_equal( ["Line 1", "Line 2", "Line 3", "Line 4"], a.lines)
+    assert_equal( "0000000000", a.body )
+  end
+
+
+  # Test unsized binary data. The expectation is that each chunk of it
+  # will be passed to us as it it received.
+  class UnsizedBinary
+    include EM::Protocols::LineText2
+    attr_reader :n_calls, :body
+    def initialize *args
+      super
+      set_text_mode
+    end
+    def receive_binary_data data
+      @n_calls ||= 0
+      @n_calls += 1
+      (@body ||= "") << data
+    end
+  end
+
+  def test_unsized_binary
+    testdata = "X\0" * 1000
+
+    a = UnsizedBinary.new
+    a.receive_data testdata
+    assert_equal( 1, a.n_calls )
+    assert_equal( testdata, a.body )
+
+    a = UnsizedBinary.new
+    testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
+    assert_equal( 2000, a.n_calls )
+    assert_equal( testdata, a.body )
+  end
+
+
+  # Test binary data with a "throw back" into line-mode.
+  class ThrowBack
+    include EM::Protocols::LineText2
+    attr_reader :headers
+    def initialize *args
+      super
+      @headers = []
+      @n_bytes = 0
+      set_text_mode
+    end
+    def receive_binary_data data
+      wanted = 25 - @n_bytes
+      will_take = if data.length > wanted
+                    data.length - wanted
+                  else
+                    data.length
+                  end
+      @n_bytes += will_take
+
+      if @n_bytes == 25
+        set_line_mode( data[will_take..-1] )
+      end
+    end
+    def receive_line ln
+      @headers << ln
+    end
+  end
+  def test_throw_back
+    testdata = "Line\n" * 10
+
+    a = ThrowBack.new
+    a.receive_data testdata
+    assert_equal( ["Line"] * 5, a.headers )
+
+    a = ThrowBack.new
+    testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
+    assert_equal( ["Line"] * 5, a.headers )
+  end
+
+  # Test multi-character line delimiters.
+  # Also note that the test data has a "tail" with no delimiter, that will be
+  # discarded, but cf. the BinaryTail test.
+  # TODO!!! This test doesn't work in the byte-by-byte case.
+  class Multichar
+    include EM::Protocols::LineText2
+    attr_reader :lines
+    def initialize *args
+      super
+      @lines = []
+      set_delimiter "012"
+    end
+    def receive_line ln
+      @lines << ln
+    end
+  end
+  def test_multichar
+    testdata = "Line012Line012Line012Line"
+
+    a = Multichar.new
+    a.receive_data testdata
+    assert_equal( ["Line"]*3, a.lines )
+
+    a = Multichar.new
+    testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
+    # DOESN'T WORK in this case. Multi-character delimiters are broken.
+    #assert_equal( ["Line"]*3, a.lines )
+  end
+
+  # Test a binary "tail," when a sized binary transfer doesn't complete because
+  # of an unbind. We get a partial result.
+  class BinaryTail
+    include EM::Protocols::LineText2
+    attr_reader :data
+    def initialize *args
+      super
+      @data = ""
+      set_text_mode 1000
+    end
+    def receive_binary_data data
+      # we expect to get all the data in one chunk, even in the byte-by-byte case,
+      # because sized transfers by definition give us exactly one call to
+      # #receive_binary_data.
+      @data = data
+    end
+  end
+  def test_binary_tail
+    testdata = "0" * 500
+
+    a = BinaryTail.new
+    a.receive_data testdata
+    a.unbind
+    assert_equal( "0" * 500, a.data )
+
+    a = BinaryTail.new
+    testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
+    a.unbind
+    assert_equal( "0" * 500, a.data )
+  end
+
+
+  # Test an end-of-binary call. Arrange to receive binary data but don't bother counting it
+  # as it comes. Rely on getting receive_end_of_binary_data to signal the transition back to
+  # line mode.
+  # At the present time, this isn't strictly necessary with sized binary chunks because by
+  # definition we accumulate them and make exactly one call to receive_binary_data, but
+  # we may want to support a mode in the future that would break up large chunks into multiple
+  # calls.
+  class LazyBinary
+    include EM::Protocols::LineText2
+    attr_reader :data, :end
+    def initialize *args
+      super
+      @data = ""
+      set_text_mode 1000
+    end
+    def receive_binary_data data
+      # we expect to get all the data in one chunk, even in the byte-by-byte case,
+      # because sized transfers by definition give us exactly one call to
+      # #receive_binary_data.
+      @data = data
+    end
+    def receive_end_of_binary_data
+      @end = true
+    end
+  end
+  def test_receive_end_of_binary_data
+    testdata = "_" * 1000
+    a = LazyBinary.new
+    testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
+    assert_equal( "_" * 1000, a.data )
+    assert( a.end )
+  end
+
+
+  # This tests a bug fix in which calling set_text_mode failed when called
+  # inside receive_binary_data.
+  #
+  class BinaryPair
+    include EM::Protocols::LineText2
+    attr_reader :sizes
+    def initialize *args
+      super
+      set_text_mode 1
+      @sizes = []
+    end
+    def receive_binary_data dt
+      @sizes <<  dt.length
+      set_text_mode( (dt.length == 1) ? 2 : 1 )
+    end
+  end
+  def test_binary_pairs
+    test_data = "123" * 5
+    a = BinaryPair.new
+    a.receive_data test_data
+    assert_equal( [1,2,1,2,1,2,1,2,1,2], a.sizes )
+  end
+
+end