wj_eventmachine 1.3.0.dev.1

data/tests/jruby/test_jeventmachine.rb

@@ -0,0 +1,38 @@
+if !(RUBY_PLATFORM =~ /java/)
+  puts "Ignoring tests in #{__FILE__}.  They must be run in JRuby "
+else
+  require 'test/unit'
+  require 'jeventmachine'
+
+  class TestJEventmachine < Test::Unit::TestCase
+
+    def setup
+      EventMachine.instance_variable_set("@em", nil)
+      load 'jeventmachine.rb'
+    end
+
+    def test_can_make_calls_without_errors_before_initialization
+      assert_equal nil, EventMachine.signal_loopbreak
+      assert_equal nil, EventMachine.stop_tcp_server(123)
+      assert_equal nil, EventMachine.send_data(123, "rewr", 4)
+      assert_equal nil, EventMachine.close_connection(332, nil)
+    end
+
+    def test_create
+      EventMachine::initialize_event_machine
+      em = EventMachine::instance_variable_get("@em")
+      assert_equal true, em.is_a?(Java::com.rubyeventmachine.EmReactor)
+    end
+
+    def test_can_make_calls_without_errors_after_release
+      EventMachine.initialize_event_machine
+      EventMachine.release_machine
+
+      assert_equal nil, EventMachine.signal_loopbreak
+      assert_equal nil, EventMachine.stop_tcp_server(123)
+      assert_equal nil, EventMachine.send_data(123, "rewr", 4)
+      assert_equal nil, EventMachine.close_connection(332, nil)
+    end
+
+  end
+end

data/tests/test_attach.rb

@@ -0,0 +1,199 @@
+require_relative 'em_test_helper'
+
+class TestAttach < Test::Unit::TestCase
+  class EchoServer < EM::Connection
+    def receive_data data
+      $received_data << data
+      send_data data
+    end
+  end
+
+  class EchoClient < EM::Connection
+    def initialize socket
+      self.notify_readable = true
+      @socket = socket
+      @socket.write("abc\n")
+    end
+
+    def notify_readable
+      $read = @socket.readline
+      $fd = detach
+    end
+
+    def unbind
+      EM.next_tick do
+        @socket.write("def\n")
+        EM.add_timer(0.1) { EM.stop }
+      end
+    end
+  end
+
+  def setup
+    @port = next_port
+    $read, $r, $w, $fd = nil
+    $received_data = ""
+  end
+
+  def teardown
+    [$r, $w].each do |io|
+      io.close rescue nil
+    end
+    $received_data = nil
+  end
+
+  def test_attach
+    socket = nil
+
+    EM.run {
+      EM.start_server "127.0.0.1", @port, EchoServer
+      socket = TCPSocket.new "127.0.0.1", @port
+      EM.watch socket, EchoClient, socket
+    }
+
+    assert_equal $read, "abc\n"
+    unless jruby? # jruby filenos are not real
+      assert_equal $fd, socket.fileno
+    end
+    assert_equal false, socket.closed?
+    assert_equal socket.readline, "def\n"
+  end
+
+  module PipeWatch
+    def notify_readable
+      $read = $r.readline
+      EM.stop
+    end
+  end
+
+  def test_attach_server
+    omit_if(jruby?)
+    $before = TCPServer.new("127.0.0.1", @port)
+    sig     = nil
+    EM.run {
+      sig = EM.attach_server $before, EchoServer
+
+      handler = Class.new(EM::Connection) do
+        def initialize
+          send_data "hello world"
+          close_connection_after_writing
+          EM.add_timer(0.1) { EM.stop }
+        end
+      end
+      EM.connect("127.0.0.1", @port, handler)
+    }
+
+    assert_equal false, $before.closed?
+    assert_equal "hello world", $received_data
+    assert sig.is_a?(Integer)
+  end
+
+  def test_attach_pipe
+    EM.run{
+      $r, $w = IO.pipe
+      EM.watch $r, PipeWatch do |c|
+        c.notify_readable = true
+      end
+      $w.write("ghi\n")
+    }
+
+    assert_equal $read, "ghi\n"
+  end
+
+  def test_set_readable
+    before, after = nil
+
+    EM.run{
+      $r, $w = IO.pipe
+      c = EM.watch $r, PipeWatch do |con|
+        con.notify_readable = false
+      end
+
+      EM.next_tick{
+        before = c.notify_readable?
+        c.notify_readable = true
+        after = c.notify_readable?
+      }
+
+      $w.write("jkl\n")
+    }
+
+    assert !before
+    assert after
+    assert_equal $read, "jkl\n"
+  end
+
+  def test_read_write_pipe
+    result = nil
+
+    pipe_reader = Module.new do
+      define_method :receive_data do |data|
+        result = data
+        EM.stop
+      end
+    end
+
+    r,w = IO.pipe
+
+    EM.run {
+      EM.attach r, pipe_reader
+      writer = EM.attach(w)
+      writer.send_data 'ghi'
+
+      # XXX: Process will hang in Windows without this line
+      writer.close_connection_after_writing
+    }
+
+    assert_equal "ghi", result
+  ensure
+    [r,w].each {|io| io.close rescue nil }
+  end
+
+  # This test shows that watch_only? is true for EM.watch
+  def test_watch_only
+    r, w = IO.pipe
+    $watch_only = nil
+
+    EM.run do
+      EM.watch r do |c|
+        assert_true(c.watch_only?)
+        c.notify_readable = true
+        def c.receive_data data
+          fail('this method should not be called')
+        end
+        def c.notify_readable
+          $watch_only = watch_only?
+        end
+      end
+      w.write 'hello'
+      EM.next_tick { EM.stop }
+    end
+
+    assert_true($watch_only)
+  end
+
+  # This test shows that watch_only? is false for EM.attach
+  def test_attach_data
+    pend("\nFIXME: Freezes Windows testing as of 2018-07-31") if windows?
+    r, w = IO.pipe
+    $watch_only = nil
+    $read = []
+
+    EM.run do
+      EM.attach r do |c|
+        assert_false(c.watch_only?)
+        def c.receive_data data
+          $watch_only = watch_only?
+          $read << data
+        end
+        def c.notify_readable
+          fail('this method should not be called')
+        end
+      end
+      w.write 'world'
+      EM.next_tick { EM.stop }
+    end
+
+    assert_false($watch_only)
+    assert_equal('world', $read.first)
+  end
+end

data/tests/test_basic.rb

@@ -0,0 +1,321 @@
+require_relative 'em_test_helper'
+
+class TestBasic < Test::Unit::TestCase
+  def setup
+    @port = next_port
+  end
+
+  INVALID = "(not known|no data of the requested|No such host is known|Temporary failure in name resolution)"
+
+  def test_connection_class_cache
+    mod = Module.new
+    a, b = nil, nil
+    EM.run {
+      EM.start_server '127.0.0.1', @port, mod
+      a = EM.connect '127.0.0.1', @port, mod
+      b = EM.connect '127.0.0.1', @port, mod
+      EM.stop
+    }
+    assert_equal a.class, b.class
+    assert_kind_of EM::Connection, a
+  end
+
+  #-------------------------------------
+
+  def test_em
+    assert_nothing_raised do
+      EM.run {
+        setup_timeout
+        EM.add_timer 0 do
+          EM.stop
+        end
+      }
+    end
+  end
+
+  #-------------------------------------
+
+  def test_timer
+    assert_nothing_raised do
+      EM.run {
+        setup_timeout(darwin? ? 0.6 : 0.4)
+        n = 0
+        EM.add_periodic_timer(0.1) {
+          n += 1
+          EM.stop if n == 2
+        }
+      }
+    end
+  end
+
+  #-------------------------------------
+
+  # This test once threw an already-running exception.
+  module Trivial
+    def post_init
+      EM.stop
+    end
+  end
+
+  def test_server
+    assert_nothing_raised do
+      EM.run {
+        setup_timeout
+        EM.start_server "127.0.0.1", @port, Trivial
+        EM.connect "127.0.0.1", @port
+      }
+    end
+  end
+
+  #--------------------------------------
+
+  # EM#run_block starts the reactor loop, runs the supplied block, and then STOPS
+  # the loop automatically. Contrast with EM#run, which keeps running the reactor
+  # even after the supplied block completes.
+  def test_run_block
+    assert !EM.reactor_running?
+    a = nil
+    EM.run_block { a = "Worked" }
+    assert a
+    assert !EM.reactor_running?
+  end
+
+  class UnbindError < EM::Connection
+    ERR = Class.new(StandardError)
+    def initialize *args
+      super
+    end
+    def connection_completed
+      close_connection_after_writing
+    end
+    def unbind
+      raise ERR
+    end
+  end
+
+  def test_unbind_error_during_stop
+    assert_raises( UnbindError::ERR ) {
+      EM.run {
+        EM.start_server "127.0.0.1", @port
+        EM.connect "127.0.0.1", @port, UnbindError do
+          EM.stop
+        end
+      }
+    }
+  end
+
+  def test_unbind_error
+    EM.run {
+      EM.error_handler do |e|
+        assert(e.is_a?(UnbindError::ERR))
+        EM.stop
+      end
+      EM.start_server "127.0.0.1", @port
+      EM.connect "127.0.0.1", @port, UnbindError
+    }
+
+    # Remove the error handler before the next test
+    EM.error_handler(nil)
+  end
+
+  module BrsTestSrv
+    def receive_data data
+      $received << data
+    end
+    def unbind
+      EM.stop
+    end
+  end
+  module BrsTestCli
+    def post_init
+      send_data $sent
+      close_connection_after_writing
+    end
+  end
+
+  # From ticket #50
+  def test_byte_range_send
+    $received = ''
+    $sent = (0..255).to_a.pack('C*')
+    EM::run {
+      EM::start_server "127.0.0.1", @port, BrsTestSrv
+      EM::connect "127.0.0.1", @port, BrsTestCli
+
+      setup_timeout
+    }
+    assert_equal($sent, $received)
+  end
+
+  def test_bind_connect
+    local_ip = UDPSocket.open {|s| s.connect('localhost', 80); s.addr.last }
+
+    bind_port = next_port
+
+    port, ip = nil
+    bound_server = Module.new do
+      define_method :post_init do
+        begin
+          port, ip = Socket.unpack_sockaddr_in(get_peername)
+        ensure
+          EM.stop
+        end
+      end
+    end
+
+    EM.run do
+      darwin? ? setup_timeout(0.3) : setup_timeout
+      EM.start_server "127.0.0.1", @port, bound_server
+      EM.bind_connect local_ip, bind_port, "127.0.0.1", @port
+    end
+
+    assert_equal bind_port, port
+    assert_equal local_ip, ip
+  end
+
+  def test_invalid_address_bind_connect_dst
+    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'
+    e = nil
+    EM.run do
+      begin
+        EM.bind_connect('localhost', nil, 'invalid.invalid', 80)
+      rescue Exception => e
+        # capture the exception
+      ensure
+        EM.stop
+      end
+    end
+
+    assert_kind_of(EventMachine::ConnectionError, e)
+    assert_match(/unable to resolve address:.*#{INVALID}/, e.message)
+  end
+
+  def test_invalid_address_bind_connect_src
+    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'
+    e = nil
+    EM.run do
+      begin
+        EM.bind_connect('invalid.invalid', nil, 'localhost', 80)
+      rescue Exception => e
+        # capture the exception
+      ensure
+        EM.stop
+      end
+    end
+
+    assert_kind_of(EventMachine::ConnectionError, e)
+    assert_match(/invalid bind address:.*#{INVALID}/, e.message)
+  end
+
+  def test_reactor_thread?
+    assert !EM.reactor_thread?
+    EM.run { assert EM.reactor_thread?; EM.stop }
+    assert !EM.reactor_thread?
+  end
+
+  def test_schedule_on_reactor_thread
+    x = false
+    EM.run do
+      EM.schedule { x = true }
+      EM.stop
+    end
+    assert x
+  end
+
+  def test_schedule_from_thread
+    x = false
+    EM.run do
+      Thread.new { EM.schedule { x = true; EM.stop } }.join
+    end
+    assert x
+  end
+
+  def test_set_heartbeat_interval
+    omit_if(jruby?)
+    interval = 0.5
+    EM.run {
+      EM.set_heartbeat_interval interval
+      $interval = EM.get_heartbeat_interval
+      EM.stop
+    }
+    assert_equal(interval, $interval)
+  end
+
+  module PostInitRaiser
+    ERR = Class.new(StandardError)
+    def post_init
+      raise ERR
+    end
+  end
+
+  def test_bubble_errors_from_post_init
+    assert_raises(PostInitRaiser::ERR) do
+      EM.run do
+        EM.start_server "127.0.0.1", @port
+        EM.connect "127.0.0.1", @port, PostInitRaiser
+      end
+    end
+  end
+
+  module InitializeRaiser
+    ERR = Class.new(StandardError)
+    def initialize
+      raise ERR
+    end
+  end
+
+  def test_bubble_errors_from_initialize
+    assert_raises(InitializeRaiser::ERR) do
+      EM.run do
+        EM.start_server "127.0.0.1", @port
+        EM.connect "127.0.0.1", @port, InitializeRaiser
+      end
+    end
+  end
+
+  def test_schedule_close
+    omit_if(jruby?)
+    localhost, port = '127.0.0.1', 9000
+    timer_ran = false
+    num_close_scheduled = nil
+    EM.run do
+      assert_equal 0, EM.num_close_scheduled
+      EM.add_timer(1) { timer_ran = true; EM.stop }
+      EM.start_server localhost, port do |s|
+        s.close_connection
+        num_close_scheduled = EM.num_close_scheduled
+      end
+      EM.connect localhost, port do |c|
+        def c.unbind
+          EM.stop
+        end
+      end
+    end
+    assert !timer_ran
+    assert_equal 1, num_close_scheduled
+  end
+
+  def test_error_handler_idempotent # issue 185
+    errors = []
+    ticks = []
+    EM.error_handler do |e|
+      errors << e
+    end
+
+    EM.run do
+      EM.next_tick do
+        ticks << :first
+        raise
+      end
+      EM.next_tick do
+        ticks << :second
+      end
+      EM.add_timer(0.001) { EM.stop }
+    end
+
+    # Remove the error handler before the next test
+    EM.error_handler(nil)
+
+    assert_equal 1, errors.size
+    assert_equal [:first, :second], ticks
+  end
+end