eventmachine-le 1.1.0.beta.1

data/tests/test_next_tick.rb

@@ -0,0 +1,104 @@
+require 'em_test_helper'
+
+class TestNextTick < Test::Unit::TestCase
+
+  def test_tick_arg
+    pr = proc {EM.stop}
+    EM.run {
+      EM.next_tick pr
+    }
+    assert true
+  end
+
+  def test_tick_block
+    EM.run {
+      EM.next_tick {EM.stop}
+    }
+    assert true
+  end
+
+  # This illustrates the solution to a long-standing problem.
+  # It's now possible to correctly nest calls to EM#run.
+  # See the source code commentary for EM#run for more info.
+  #
+  def test_run_run
+    EM.run {
+      EM.run {
+        EM.next_tick {EM.stop}
+      }
+    }
+  end
+
+  def test_pre_run_queue
+    x = false
+    EM.next_tick { EM.stop; x = true }
+    EM.run { EM.add_timer(0.01) { EM.stop } }
+    assert x
+  end
+
+  def test_cleanup_after_stop
+    x = true
+    EM.run{
+      EM.next_tick{
+        EM.stop
+        EM.next_tick{ x=false }
+      }
+    }
+    EM.run{
+      EM.next_tick{ EM.stop }
+    }
+    assert x
+  end
+
+  # We now support an additional parameter for EM#run.
+  # You can pass two procs to EM#run now. The first is executed as the normal
+  # run block. The second (if given) is scheduled for execution after the
+  # reactor loop completes.
+  # The reason for supporting this is subtle. There has always been an expectation
+  # that EM#run doesn't return until after the reactor loop ends. But now it's
+  # possible to nest calls to EM#run, which means that a nested call WILL
+  # RETURN. In order to write code that will run correctly either way, it's
+  # recommended to put any code which must execute after the reactor completes
+  # in the second parameter.
+  #
+  def test_run_run_2
+    a = proc {EM.stop}
+    b = proc {assert true}
+    EM.run a, b
+  end
+
+
+  # This illustrates that EM#run returns when it's called nested.
+  # This isn't a feature, rather it's something to be wary of when writing code
+  # that must run correctly even if EM#run is called while a reactor is already
+  # running.
+  def test_run_run_3
+    a = []
+    EM.run {
+      EM.run proc {EM.stop}, proc {a << 2}
+      a << 1
+    }
+    assert_equal( [1,2], a )
+  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 } }.join
+      assert !x
+      EM.next_tick { EM.stop }
+    end
+    assert x
+  end
+
+end

data/tests/test_object_protocol.rb

@@ -0,0 +1,36 @@
+require 'em_test_helper'
+
+class TestObjectProtocol < Test::Unit::TestCase
+  module Server
+    include EM::P::ObjectProtocol
+    def post_init
+      send_object :hello=>'world'
+    end
+    def receive_object obj
+      $server = obj
+      EM.stop
+    end
+  end
+
+  module Client
+    include EM::P::ObjectProtocol
+    def receive_object obj
+      $client = obj
+      send_object 'you_said'=>obj
+    end
+  end
+
+  def setup
+    @port = next_port
+  end
+
+  def test_send_receive
+    EM.run{
+      EM.start_server "127.0.0.1", @port, Server
+      EM.connect "127.0.0.1", @port, Client
+    }
+
+    assert($client == {:hello=>'world'})
+    assert($server == {'you_said'=>{:hello=>'world'}})
+  end
+end

data/tests/test_pause.rb

@@ -0,0 +1,78 @@
+require 'em_test_helper'
+
+class TestPause < Test::Unit::TestCase
+  if EM.respond_to? :pause_connection
+    def setup
+      @port = next_port
+    end
+
+    def teardown
+      assert(!EM.reactor_running?)
+    end
+
+    def test_pause_resume
+      server = nil
+
+      s_rx = c_rx = 0
+
+      test_server = Module.new do
+        define_method :post_init do
+          server = self
+        end
+
+        define_method :receive_data do |data|
+          s_rx += 1
+
+          EM.add_periodic_timer(0.01) { send_data 'hi' }
+          send_data 'hi'
+
+          # pause server, now no outgoing data will actually
+          # be sent and no more incoming data will be received
+          pause
+        end
+      end
+
+      test_client = Module.new do
+        def post_init
+          EM.add_periodic_timer(0.01) do
+            send_data 'hello'
+          end
+        end
+
+        define_method :receive_data do |data|
+          c_rx += 1
+        end
+      end
+
+      EM.run do
+        EM.start_server "127.0.0.1", @port, test_server
+        EM.connect "127.0.0.1", @port, test_client
+
+        EM.add_timer(0.05) do
+          assert_equal 1, s_rx
+          assert_equal 0, c_rx
+          assert server.paused?
+
+          # resume server, queued outgoing and incoming data will be flushed
+          server.resume
+
+          assert !server.paused?
+
+          EM.add_timer(0.05) do
+            assert server.paused?
+            assert s_rx > 1
+            assert c_rx > 0
+            EM.stop
+          end
+        end
+      end
+    end
+  else
+    warn "EM.pause_connection not implemented, skipping tests in #{__FILE__}"
+
+    # Because some rubies will complain if a TestCase class has no tests
+    def test_em_pause_connection_not_implemented
+      assert true
+    end
+  end
+end

data/tests/test_pending_connect_timeout.rb

@@ -0,0 +1,52 @@
+require 'em_test_helper'
+
+class TestPendingConnectTimeout < Test::Unit::TestCase
+
+  if EM.respond_to? :get_pending_connect_timeout
+    def test_default
+      EM.run {
+        c = EM.connect("127.0.0.1", 54321)
+        assert_equal 20.0, c.pending_connect_timeout
+        EM.stop
+      }
+    end
+
+    def test_set_and_get
+      EM.run {
+        c = EM.connect("127.0.0.1", 54321)
+        c.pending_connect_timeout = 2.5
+        assert_equal 2.5, c.pending_connect_timeout
+        EM.stop
+      }
+    end
+
+    def test_for_real
+      start, finish = nil
+
+      timeout_handler = Module.new do
+        define_method :unbind do
+          finish = Time.now
+          EM.stop
+        end
+      end
+
+      EM.run {
+        setup_timeout
+        EM.heartbeat_interval = 0.1
+        start = Time.now
+        c = EM.connect("1.2.3.4", 54321, timeout_handler)
+        c.pending_connect_timeout = 0.2
+      }
+
+      assert_in_delta(0.2, (finish - start), 0.1)
+    end
+  else
+    warn "EM.pending_connect_timeout not implemented, skipping tests in #{__FILE__}"
+
+    # Because some rubies will complain if a TestCase class has no tests
+    def test_em_pending_connect_timeout_not_implemented
+      assert true
+    end
+  end
+
+end

data/tests/test_pool.rb

@@ -0,0 +1,196 @@
+require 'em_test_helper'
+
+class TestPool < Test::Unit::TestCase
+  def pool
+    @pool ||= EM::Pool.new
+  end
+
+  def go
+    EM.run { yield }
+  end
+
+  def stop
+    EM.stop
+  end
+
+  def deferrable
+    @deferrable ||= EM::DefaultDeferrable.new
+  end
+
+  def test_supports_more_work_than_resources
+    ran = false
+    go do
+      pool.perform do
+        ran = true
+        deferrable
+      end
+      stop
+    end
+    assert_equal false, ran
+    go do
+      pool.add :resource
+      stop
+    end
+    assert_equal true, ran
+  end
+
+  def test_reques_resources_on_error
+    pooled_res, pooled_res2 = nil
+    pool.add :res
+    go do
+      pool.perform do |res|
+        pooled_res = res
+        deferrable
+      end
+      stop
+    end
+    deferrable.fail
+    go do
+      pool.perform do |res|
+        pooled_res2 = res
+        deferrable
+      end
+      stop
+    end
+    assert_equal :res, pooled_res
+    assert_equal pooled_res, pooled_res2
+  end
+
+  def test_supports_custom_error_handler
+    eres = nil
+    pool.on_error do |res|
+      eres = res
+    end
+    performs = []
+    pool.add :res
+    go do
+      pool.perform do |res|
+        performs << res
+        deferrable
+      end
+      pool.perform do |res|
+        performs << res
+        deferrable
+      end
+      deferrable.fail
+      stop
+    end
+    assert_equal :res, eres
+    # manual requeues required when error handler is installed:
+    assert_equal 1, performs.size
+    assert_equal :res, performs.first
+  end
+
+  def test_catches_successful_deferrables
+    performs = []
+    pool.add :res
+    go do
+      pool.perform { |res| performs << res; deferrable }
+      pool.perform { |res| performs << res; deferrable }
+      stop
+    end
+    assert_equal [:res], performs
+    deferrable.succeed
+    go { stop }
+    assert_equal [:res, :res], performs
+  end
+
+  def test_prunes_locked_and_removed_resources
+    performs = []
+    pool.add :res
+    deferrable.succeed
+    go do
+      pool.perform { |res| performs << res; pool.remove res; deferrable }
+      pool.perform { |res| performs << res; pool.remove res; deferrable }
+      stop
+    end
+    assert_equal [:res], performs
+  end
+
+  # Contents is only to be used for inspection of the pool!
+  def test_contents
+    pool.add :res
+    assert_equal [:res], pool.contents
+    # Assert that modifying the contents list does not affect the pools
+    # contents.
+    pool.contents.delete(:res)
+    assert_equal [:res], pool.contents
+  end
+
+  def test_contents_when_perform_errors_and_on_error_is_not_set
+    pool.add :res
+    assert_equal [:res], pool.contents
+
+    pool.perform do |r|
+      d = EM::DefaultDeferrable.new
+      d.fail
+      d
+    end
+
+    EM.run { EM.next_tick { EM.stop } }
+
+    assert_equal [:res], pool.contents
+  end
+
+  def test_contents_when_perform_errors_and_on_error_is_set
+    pool.add :res
+    res = nil
+    pool.on_error do |r|
+      res = r
+    end
+    assert_equal [:res], pool.contents
+
+    pool.perform do |r|
+      d = EM::DefaultDeferrable.new
+      d.fail 'foo'
+      d
+    end
+
+    EM.run { EM.next_tick { EM.stop } }
+
+    assert_equal :res, res
+    assert_equal [], pool.contents
+  end
+
+  def test_num_waiting
+    pool.add :res
+    assert_equal 0, pool.num_waiting
+    pool.perform { |r| EM::DefaultDeferrable.new }
+    assert_equal 0, pool.num_waiting
+    10.times { pool.perform { |r| EM::DefaultDeferrable.new } }
+    EM.run { EM.next_tick { EM.stop } }
+    assert_equal 10, pool.num_waiting
+  end
+
+  def test_exceptions_in_the_work_block_bubble_up_raise_and_fail_the_resource
+    pool.add :res
+
+    res = nil
+    pool.on_error { |r| res = r }
+    pool.perform { raise 'boom' }
+
+    assert_raises(RuntimeError) do
+      EM.run { EM.next_tick { EM.stop } }
+    end
+
+    assert_equal [], pool.contents
+    assert_equal :res, res
+  end
+
+  def test_removed_list_does_not_leak_on_errors
+    pool.add :res
+
+    pool.on_error do |r|
+      # This is actually the wrong thing to do, and not required, but some users
+      # might do it. When they do, they would find that @removed would cause a
+      # slow leak.
+      pool.remove r
+    end
+
+    pool.perform { d = EM::DefaultDeferrable.new; d.fail; d }
+
+    EM.run { EM.next_tick { EM.stop } }
+    assert_equal [], pool.instance_variable_get(:@removed)
+  end
+
+end