wj_eventmachine 1.3.0.dev.1

data/tests/test_io_streamer.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'em_test_helper'
+require 'em/io_streamer'
+
+# below to stop 'already initialized constant' warning
+EM::IOStreamer.__send__ :remove_const, :CHUNK_SIZE
+EM::IOStreamer.const_set :CHUNK_SIZE, 2
+
+class TestIOStreamer < Test::Unit::TestCase
+
+  class StreamServer < EM::Connection
+    def initialize(sent)
+      @sent = sent
+    end
+
+    def post_init
+      io = StringIO.new @sent
+      EM::IOStreamer.new(self, io).callback { close_connection_after_writing }
+    end
+  end
+
+  class StreamClient < EM::Connection
+    def initialize(received)
+      @received = received
+    end
+
+    def receive_data data
+      @received << data
+    end
+
+    def unbind
+      EM.stop
+    end
+  end
+
+  def test_io_stream
+    sent = 'this is a test'
+    received = ''.dup
+    EM.run do
+      port = next_port
+      EM.start_server '127.0.0.1', port, StreamServer, sent
+      EM.connect '127.0.0.1', port, StreamClient, received
+    end
+    assert_equal sent, received
+  end
+end

data/tests/test_ipv4.rb

@@ -0,0 +1,96 @@
+require_relative 'em_test_helper'
+
+class TestIPv4 < Test::Unit::TestCase
+  # Runs a TCP server in the local IPv4 address, connects to it and sends a specific data.
+  # Timeout in 2 seconds.
+  def test_ipv4_tcp_local_server
+    omit_if(!Test::Unit::TestCase.public_ipv4?)
+
+    @@received_data = nil
+    @local_port = next_port
+    setup_timeout(2)
+
+    EM.run do
+      EM::start_server(@@public_ipv4, @local_port) do |s|
+        def s.receive_data data
+          @@received_data = data
+          EM.stop
+        end
+      end
+
+      EM::connect(@@public_ipv4, @local_port) do |c|
+        c.send_data "ipv4/tcp"
+      end
+    end
+
+    assert_equal "ipv4/tcp", @@received_data
+  end
+
+  # Runs a UDP server in the local IPv4 address, connects to it and sends a specific data.
+  # Timeout in 2 seconds.
+  def test_ipv4_udp_local_server
+    omit_if(!Test::Unit::TestCase.public_ipv4?)
+
+    @@received_data = nil
+    @local_port = next_port
+    setup_timeout(darwin? ? 4 : 2)
+
+    EM.run do
+      EM::open_datagram_socket(@@public_ipv4, @local_port) do |s|
+        def s.receive_data data
+          @@received_data = data
+          EM.stop
+        end
+      end
+
+      EM::open_datagram_socket(@@public_ipv4, next_port) do |c|
+        c.send_datagram "ipv4/udp", @@public_ipv4, @local_port
+      end
+    end
+
+    assert_equal "ipv4/udp", @@received_data
+  end
+
+  # Try to connect via TCP to an invalid IPv4. EM.connect should raise
+  # EM::ConnectionError.
+  def test_tcp_connect_to_invalid_ipv4
+    omit_if(!Test::Unit::TestCase.public_ipv4?)
+    pend("\nFIXME: Windows as of 2018-06-23 on 32 bit >= 2.4 (#{RUBY_VERSION} #{RUBY_PLATFORM})") if RUBY_PLATFORM[/i386-mingw/] && RUBY_VERSION >= '2.4'
+    
+    invalid_ipv4 = "9.9:9"
+
+    EM.run do
+      begin
+        error = nil
+        EM.connect(invalid_ipv4, 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 IPv4. EM.send_datagram should raise
+  # EM::ConnectionError.
+  def test_udp_send_datagram_to_invalid_ipv4
+    omit_if(!Test::Unit::TestCase.public_ipv4?)
+
+    invalid_ipv4 = "9.9:9"
+
+    EM.run do
+      begin
+        error = nil
+        EM.open_datagram_socket(@@public_ipv4, next_port) do |c|
+          c.send_datagram "hello", invalid_ipv4, 1234
+        end
+      rescue => e
+        error = e
+      ensure
+        EM.stop
+        assert_equal EM::ConnectionError, (error && error.class)
+      end
+    end
+  end
+end

data/tests/test_ipv6.rb

@@ -0,0 +1,107 @@
+require_relative 'em_test_helper'
+
+class TestIPv6 < Test::Unit::TestCase
+
+  if Test::Unit::TestCase.public_ipv6?
+
+    # 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(@@public_ipv6, @local_port) do |s|
+          def s.receive_data data
+            @@received_data = data
+            EM.stop
+          end
+        end
+
+        EM::connect(@@public_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
+      @@remote_ip = nil
+      setup_timeout(2)
+
+      EM.run do
+        EM.open_datagram_socket(@@public_ipv6, @local_port) do |s|
+          def s.receive_data data
+            _port, @@remote_ip = Socket.unpack_sockaddr_in(get_peername)
+            @@received_data = data
+            EM.stop
+          end
+        end
+
+        EM.open_datagram_socket(@@public_ipv6, next_port) do |c|
+          c.send_datagram "ipv6/udp", @@public_ipv6, @local_port
+        end
+      end
+      assert_equal @@remote_ip, @@public_ipv6
+      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(@@public_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
+
+
+  else
+    warn "no IPv6 in this host, 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_iterator.rb

@@ -0,0 +1,122 @@
+require_relative 'em_test_helper'
+
+class TestIterator < Test::Unit::TestCase
+
+  def setup
+    @time0 = nil
+  end
+
+  # By default, format the time with tenths-of-seconds.
+  # Some tests should ask for extra decimal places to ensure
+  # that delays between iterations will receive a changed time.
+  def get_time(n = 1)
+    @time0 = EM.current_time unless @time0
+    sprintf "%07.#{n}f", EM.current_time - @time0
+  end
+
+  def test_default_concurrency
+    items = {}
+    list = 1..10
+    EM.run {
+      EM::Iterator.new(list).each( proc {|num,iter|
+        time = get_time(3)
+        items[time] ||= []
+        items[time] << num
+        EM::Timer.new(0.02) {iter.next}
+      }, proc {EM.stop})
+    }
+    assert_equal(10, items.keys.size)
+    assert_equal(list.to_a.sort, items.values.flatten.sort)
+  end
+
+  def test_default_concurrency_with_a_proc
+    items = {}
+    list = (1..10).to_a
+    original_list = list.dup
+    EM.run {
+      EM::Iterator.new(proc{list.pop || EM::Iterator::Stop}).each( proc {|num,iter|
+        time = get_time(3)
+        items[time] ||= []
+        items[time] << num
+        EM::Timer.new(0.02) {iter.next}
+      }, proc {EM.stop})
+    }
+    assert_equal(10, items.keys.size)
+    assert_equal(original_list.to_a.sort, items.values.flatten.sort)
+  end
+
+  def test_concurrency_bigger_than_list_size
+    items = {}
+    list = [1,2,3]
+    EM.run {
+      EM::Iterator.new(list,10).each(proc {|num,iter|
+        time = get_time
+        items[time] ||= []
+        items[time] << num
+        EM::Timer.new(1) {iter.next}
+      }, proc {EM.stop})
+    }
+    assert_equal(1, items.keys.size)
+    assert_equal(list.to_a.sort, items.values.flatten.sort)
+  end
+
+  def test_changing_concurrency_affects_active_iteration
+    items = {}
+    list = 1..25
+    seen = 0
+    EM.run {
+      i = EM::Iterator.new(list,1)
+      i.each(proc {|num,iter|
+        time = get_time
+        items[time] ||= []
+        items[time] << num
+        if (seen += 1) == 5
+          # The first 5 items will be distinct times
+          # The next 20 items will happen in 2 bursts
+          i.concurrency = 10
+        end
+        EM::Timer.new(0.2) {iter.next}
+      }, proc {EM.stop})
+    }
+    assert_in_delta(7, items.keys.size, 1)
+    assert_equal(list.to_a.sort, items.values.flatten.sort)
+  end
+
+  def test_map
+    list = 100..150
+    EM.run {
+      EM::Iterator.new(list).map(proc{ |num,iter|
+        EM.add_timer(0.01){ iter.return(num) }
+      }, proc{ |results|
+        assert_equal(list.to_a.size, results.size)
+       EM.stop
+      })
+    }
+  end
+
+  def test_inject
+    omit_if(windows?)
+
+    list = %w[ pwd uptime uname date ]
+    EM.run {
+      EM::Iterator.new(list, 2).inject({}, proc{ |hash,cmd,iter|
+        EM.system(cmd){ |output,status|
+          hash[cmd] = status.exitstatus == 0 ? output.strip : nil
+          iter.return(hash)
+        }
+      }, proc{ |results|
+        assert_equal(results.keys.sort, list.sort)
+        EM.stop
+      })
+    }
+  end
+
+  def test_concurrency_is_0
+    EM.run {
+      assert_raise ArgumentError do
+        EM::Iterator.new(1..5,0)
+      end
+      EM.stop
+    }
+  end
+end

data/tests/test_kb.rb

@@ -0,0 +1,28 @@
+require_relative 'em_test_helper'
+
+class TestKeyboardEvents < Test::Unit::TestCase
+
+  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
+    omit_if(jruby?)
+    omit_if(!$stdout.tty?) # don't run the test unless it stands a chance of validity.
+    EM.run do
+      EM.open_keyboard KbHandler
+      EM::Timer.new(1) { EM.stop }
+    end
+  end
+
+end

data/tests/test_keepalive.rb

@@ -0,0 +1,113 @@
+require_relative 'em_test_helper'
+
+class TestKeepalive < Test::Unit::TestCase
+  def setup
+    assert(!EM.reactor_running?)
+    @port = next_port
+  end
+
+  def teardown
+    assert(!EM.reactor_running?)
+  end
+
+  def test_enable_keepalive
+    omit_if(!EM.respond_to?(:get_sock_opt))
+
+    # I don't know why "An operation was attempted on something that is not a socket."
+    pend('FIXME: this test is broken on Windows') if windows?
+
+    val = nil
+    test_module = Module.new do
+      define_method :post_init do
+        enable_keepalive
+        val = get_sock_opt Socket::SOL_SOCKET, Socket::SO_KEEPALIVE
+        EM.stop
+      end
+    end
+
+    EM.run do
+      EM.start_server '127.0.0.1', @port
+      EM.connect '127.0.0.1', @port, test_module
+    end
+
+    # Enabled isn't 1 on all platforms - Mac OS seems to be 8
+    # Docs say any non-zero value indicates keepalive is enabled
+    assert_not_equal 0, val.unpack('i').first
+  end
+
+  def test_enable_keepalive_values
+    omit_if(!EM.respond_to?(:get_sock_opt))
+
+    # I don't know why "An operation was attempted on something that is not a socket."
+    pend('FIXME: this test is broken on Windows') if windows?
+
+    val, val_idle, val_intvl, val_cnt = nil
+    test_module = Module.new do
+      define_method :post_init do
+        enable_keepalive(5, 10, 15)
+        val = get_sock_opt Socket::SOL_SOCKET, Socket::SO_KEEPALIVE
+
+        if defined?(Socket::TCP_KEEPALIVE)
+          val_idle = get_sock_opt Socket::IPPROTO_TCP, Socket::TCP_KEEPALIVE
+        end
+        if defined?(Socket::TCP_KEEPIDLE)
+          val_idle = get_sock_opt Socket::IPPROTO_TCP, Socket::TCP_KEEPIDLE
+        end
+        if defined?(Socket::TCP_KEEPINTVL)
+          val_intvl = get_sock_opt Socket::IPPROTO_TCP, Socket::TCP_KEEPINTVL
+        end
+        if defined?(Socket::TCP_KEEPCNT)
+          val_cnt = get_sock_opt Socket::IPPROTO_TCP, Socket::TCP_KEEPCNT
+        end
+
+        EM.stop
+      end
+    end
+
+    EM.run do
+      EM.start_server '127.0.0.1', @port
+      EM.connect '127.0.0.1', @port, test_module
+    end
+
+    # Enabled isn't 1 on all platforms - Mac OS seems to be 8
+    # Docs say any non-zero value indicates keepalive is enabled
+    assert_not_equal 0, val.unpack('i').first
+
+    # Make sure each of the individual settings was set
+    if defined?(Socket::TCP_KEEPIDLE) || defined?(Socket::TCP_KEEPALIVE)
+      assert_equal 5, val_idle.unpack('i').first
+    end
+
+    if defined?(Socket::TCP_KEEPINTVL)
+      assert_equal 10, val_intvl.unpack('i').first
+    end
+
+    if defined?(Socket::TCP_KEEPCNT)
+      assert_equal 15, val_cnt.unpack('i').first
+    end
+  end
+
+  def test_disable_keepalive
+    omit_if(!EM.respond_to?(:get_sock_opt))
+
+    # I don't know why "An operation was attempted on something that is not a socket."
+    pend('FIXME: this test is broken on Windows') if windows?
+
+    val = nil
+    test_module = Module.new do
+      define_method :post_init do
+        enable_keepalive
+        disable_keepalive
+        val = get_sock_opt Socket::SOL_SOCKET, Socket::SO_KEEPALIVE
+        EM.stop
+      end
+    end
+
+    EM.run do
+      EM.start_server '127.0.0.1', @port
+      EM.connect '127.0.0.1', @port, test_module
+    end
+
+    assert_equal 0, val.unpack('i').first
+  end
+end