eventmachine-maglev- 0.12.10 → 1.0.0.beta.4

data/tests/test_basic.rb

@@ -1,96 +1,51 @@
-# $Id$
-#
-# Author:: Francis Cianfrocca (gmail: blackhedd)
-# Homepage::  http://rubyeventmachine.com
-# Date:: 8 April 2006
-# 
-# See EventMachine and EventMachine::Connection for documentation and
-# usage examples.
-#
-#----------------------------------------------------------------------------
-#
-# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
-# Gmail: blackhedd
-# 
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of either: 1) the GNU General Public License
-# as published by the Free Software Foundation; either version 2 of the
-# License, or (at your option) any later version; or 2) Ruby's License.
-# 
-# See the file COPYING for complete licensing information.
-#
-#---------------------------------------------------------------------------
-#
-#
-# 
-
-$:.unshift File.expand_path(File.dirname(__FILE__) + "/../lib")
-require 'eventmachine'
+require 'em_test_helper'
 require 'socket'
-require 'test/unit'
 
 class TestBasic < Test::Unit::TestCase
-
   def setup
-    assert(!EM.reactor_running?)
+    @port = next_port
   end
 
-  def teardown
-    assert(!EM.reactor_running?)
-  end
-
-  #-------------------------------------
-
-  def test_libtype
-    lt = EventMachine.library_type
-    em_lib = (ENV["EVENTMACHINE_LIBRARY"] || $eventmachine_library || :xxx).to_sym
-
-    # Running from test runner, under jruby.
-    if RUBY_PLATFORM == 'java'
-      unless em_lib == :pure_ruby
-        assert_equal( :java, lt )
-        return
-      end
-    end
-
-    case em_lib
-    when :pure_ruby
-      assert_equal( :pure_ruby, lt )
-    when :extension
-      assert_equal( :extension, lt )
-    when :java
-      assert_equal( :java, lt )
-    else
-      # Running from jruby as a standalone test.
-      if RUBY_PLATFORM == 'java'
-        assert_equal( :java, lt )
-      else
-        assert_equal( :extension, lt )
-      end
-    end
+  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
-    EventMachine.run {
-      EventMachine.add_timer 0 do
-        EventMachine.stop
-      end
-    }
+    assert_nothing_raised do
+      EM.run {
+        setup_timeout
+        EM.add_timer 0 do
+          EM.stop
+        end
+      }
+    end
   end
 
   #-------------------------------------
 
   def test_timer
-    n = 0
-    EventMachine.run {
-      EventMachine.add_periodic_timer(0.1) {
-        n += 1
-        EventMachine.stop if n == 2
+    assert_nothing_raised do
+      EM.run {
+        setup_timeout
+        n = 0
+        EM.add_periodic_timer(0.1) {
+          n += 1
+          EM.stop if n == 2
+        }
       }
-    }
+    end
   end
 
   #-------------------------------------
@@ -98,22 +53,24 @@ class TestBasic < Test::Unit::TestCase
   # This test once threw an already-running exception.
   module Trivial
     def post_init
-      EventMachine.stop
+      EM.stop
     end
   end
 
   def test_server
-    EventMachine.run {
-      EventMachine.start_server "localhost", 9000, Trivial
-      EventMachine.connect "localhost", 9000
-    }
-    assert( true ) # make sure it halts
+    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
 
   #--------------------------------------
 
-  # EventMachine#run_block starts the reactor loop, runs the supplied block, and then STOPS
-  # the loop automatically. Contrast with EventMachine#run, which keeps running the reactor
+  # 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?
@@ -123,20 +80,8 @@ class TestBasic < Test::Unit::TestCase
     assert !EM.reactor_running?
   end
 
-
-  #--------------------------------------
-
-  # TODO! This is an unfinished edge case.
-  # EM mishandles uncaught Ruby exceptions that fire from within #unbind handlers.
-  # A uncaught Ruby exception results in a call to EM::release_machine (which is in an ensure
-  # block in EM::run). But if EM is processing an unbind request, the release_machine call
-  # will cause a segmentation fault.
-  #
-
-  TestHost = "127.0.0.1"
-  TestPort = 9070
-
   class UnbindError < EM::Connection
+    ERR = Class.new(StandardError)
     def initialize *args
       super
     end
@@ -144,60 +89,19 @@ class TestBasic < Test::Unit::TestCase
       close_connection_after_writing
     end
     def unbind
-      raise "Blooey"
+      raise ERR
     end
   end
 
-  def xxx_test_unbind_error
-    assert_raises( RuntimeError ) {
+  def test_unbind_error
+    assert_raises( UnbindError::ERR ) {
       EM.run {
-        EM.start_server TestHost, TestPort
-        EM.connect TestHost, TestPort, UnbindError
+        EM.start_server "127.0.0.1", @port
+        EM.connect "127.0.0.1", @port, UnbindError
       }
     }
   end
 
-  #------------------------------------
-  #
-  # TODO. This is an unfinished bug fix.
-  # This case was originally reported by Dan Aquino. If you throw a Ruby exception
-  # in a post_init handler, it gets rethrown as a confusing reactor exception.
-  # The problem is in eventmachine.rb, which calls post_init within the private
-  # initialize method of the EM::Connection class. This happens in both the EM::connect
-  # method and in the code that responds to connection-accepted events.
-  # What happens is that we instantiate the new connection object, which calls
-  # initialize, and then after initialize returns, we stick the new connection object
-  # into EM's @conns hashtable.
-  # But the problem is that Connection::initialize calls #post_init before it returns,
-  # and this may be user-written code that may throw an uncaught Ruby exception.
-  # If that happens, the reactor will abort, and it will then try to run down open
-  # connections. Because @conns never got a chance to properly reflect the new connection
-  # (because initialize never returned), we throw a ConnectionNotBound error
-  # (eventmachine.rb line 1080).
-  # When the bug is fixed, activate this test case.
-  #
-
-  class PostInitError < EM::Connection
-    def post_init
-      aaa bbb # should produce a Ruby exception
-    end
-  end
-  # This test causes issues, the machine becomes unreleasable after 
-  # release_machine suffers an exception in event_callback.
-  def xxx_test_post_init_error
-    assert_raises( EventMachine::ConnectionNotBound ) {
-      EM.run {
-        EM::Timer.new(1) {EM.stop}
-        EM.start_server TestHost, TestPort
-        EM.connect TestHost, TestPort, PostInitError
-      }
-    }
-    EM.run {
-      EM.stop
-    }
-    assert !EM.reactor_running?
-  end
-
   module BrsTestSrv
     def receive_data data
       $received << data
@@ -218,10 +122,10 @@ class TestBasic < Test::Unit::TestCase
     $received = ''
     $sent = (0..255).to_a.pack('C*')
     EM::run {
-      EM::start_server TestHost, TestPort, BrsTestSrv
-      EM::connect TestHost, TestPort, BrsTestCli
+      EM::start_server "127.0.0.1", @port, BrsTestSrv
+      EM::connect "127.0.0.1", @port, BrsTestCli
 
-      EM::add_timer(0.5) { assert(false, 'test timed out'); EM.stop; Kernel.warn "test timed out!" }
+      setup_timeout
     }
     assert_equal($sent, $received)
   end
@@ -229,22 +133,27 @@ class TestBasic < Test::Unit::TestCase
   def test_bind_connect
     local_ip = UDPSocket.open {|s| s.connect('google.com', 80); s.addr.last }
 
-    bind_port = rand(33333)+1025
+    bind_port = next_port
 
-    test = self
-    EM.run do
-      EM.start_server(TestHost, TestPort, Module.new do
-        define_method :post_init do
-          begin
-            test.assert_equal bind_port, Socket.unpack_sockaddr_in(get_peername).first
-            test.assert_equal local_ip, Socket.unpack_sockaddr_in(get_peername).last
-          ensure
-            EM.stop_event_loop
-          end
+    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)
-      EM.bind_connect local_ip, bind_port, TestHost, TestPort
+      end
     end
+
+    EM.run do
+      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_reactor_thread?
@@ -264,21 +173,55 @@ class TestBasic < Test::Unit::TestCase
   
   def test_schedule_from_thread
     x = false
-    assert !x
     EM.run do
       Thread.new { EM.schedule { x = true; EM.stop } }.join
     end
     assert x
   end
 
-  def test_set_heartbeat_interval
-    interval = 0.5
-    EM.run {
-      EM.set_heartbeat_interval interval
-      $interval = EM.get_heartbeat_interval
-      EM.stop
-    }
-    assert_equal(interval, $interval)
+  if EM.respond_to? :set_heartbeat_interval
+    def test_set_heartbeat_interval
+      interval = 0.5
+      EM.run {
+        EM.set_heartbeat_interval interval
+        $interval = EM.get_heartbeat_interval
+        EM.stop
+      }
+      assert_equal(interval, $interval)
+    end
+  else
+    warn "EM.set_heartbeat_interval not implemented, skipping a test in #{__FILE__}"
+  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
 end
-

data/tests/test_channel.rb

@@ -1,8 +1,6 @@
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
+require 'em_test_helper'
 
-class TestEventMachineChannel < Test::Unit::TestCase
+class TestEMChannel < Test::Unit::TestCase
   def test_channel_subscribe
     s = 0
     EM.run do
@@ -30,8 +28,9 @@ class TestEventMachineChannel < Test::Unit::TestCase
     EM.run do
       c = EM::Channel.new
       c.pop{ |v| s = v }
-      c << 1
-      c << 2
+      c.push(1,2,3)
+      c << 4
+      c << 5
       EM.next_tick { EM.stop }
     end
     assert_equal 1, s

data/tests/test_completion.rb

@@ -0,0 +1,177 @@
+require 'em/completion'
+
+class TestCompletion < Test::Unit::TestCase
+  def completion
+    @completion ||= EM::Completion.new
+  end
+
+  def crank
+    # This is a slow solution, but this just executes the next tick queue
+    # once. It's the easiest way for now.
+    EM.run { EM.stop }
+  end
+
+  def results
+    @results ||= []
+  end
+
+  def test_state
+    assert_equal :unknown, completion.state
+  end
+
+  def test_succeed
+    completion.callback { |val| results << val }
+    completion.succeed :object
+    crank
+    assert_equal :succeeded, completion.state
+    assert_equal [:object], results
+  end
+
+  def test_fail
+    completion.errback { |val| results << val }
+    completion.fail :object
+    crank
+    assert_equal :failed, completion.state
+    assert_equal [:object], results
+  end
+
+  def test_callback
+    completion.callback { results << :callback }
+    completion.errback  { results << :errback  }
+    completion.succeed
+    crank
+    assert_equal [:callback], results
+  end
+
+  def test_errback
+    completion.callback { results << :callback }
+    completion.errback  { results << :errback  }
+    completion.fail
+    crank
+    assert_equal [:errback], results
+  end
+
+  def test_stateback
+    completion.stateback(:magic) { results << :stateback }
+    completion.change_state(:magic)
+    crank
+    assert_equal [:stateback], results
+  end
+
+  def test_does_not_enqueue_when_completed
+    completion.callback { results << :callback }
+    completion.succeed
+    completion.errback  { results << :errback  }
+    completion.fail
+    crank
+    assert_equal [:callback], results
+  end
+
+  def test_completed
+    assert_equal false, completion.completed?
+    completion.succeed
+    assert_equal true, completion.completed?
+    completion.fail
+    assert_equal true, completion.completed?
+    completion.change_state :magic
+    assert_equal false, completion.completed?
+  end
+
+  def test_recursive_callbacks
+    completion.callback do |val|
+      results << val
+      completion.succeed :two
+    end
+    completion.callback do |val|
+      results << val
+      completion.succeed :three
+    end
+    completion.callback do |val|
+      results << val
+    end
+    completion.succeed :one
+    crank
+    assert_equal [:one, :two, :three], results
+  end
+
+  def test_late_defined_callbacks
+    completion.callback { results << :one }
+    completion.succeed
+    crank
+    assert_equal [:one], results
+    completion.callback { results << :two }
+    crank
+    assert_equal [:one, :two], results
+  end
+
+  def test_cleared_completions
+    completion.callback { results << :callback }
+    completion.errback  { results << :errback  }
+
+    completion.succeed
+    crank
+    completion.fail
+    crank
+    completion.succeed
+    crank
+
+    assert_equal [:callback], results
+  end
+
+  def test_skip_completed_callbacks
+    completion.callback { results << :callback }
+    completion.succeed
+    crank
+
+    completion.errback  { results << :errback  }
+    completion.fail
+    crank
+
+    assert_equal [:callback], results
+  end
+
+  def test_completions
+    completion.completion { results << :completion }
+    completion.succeed
+    crank
+    assert_equal [:completion], results
+
+    completion.change_state(:unknown)
+    results.clear
+
+    completion.completion { results << :completion }
+    completion.fail
+    crank
+    assert_equal [:completion], results
+  end
+
+  def test_latent_completion
+    completion.completion { results << :completion }
+    completion.succeed
+    crank
+    completion.completion { results << :completion }
+    crank
+    assert_equal [:completion, :completion], results
+  end
+
+  def test_timeout
+    args = [1, 2, 3]
+    EM.run do
+      completion.timeout(0.0001, *args)
+      completion.errback { |*errargs| results << errargs }
+      completion.completion { EM.stop }
+      EM.add_timer(0.1) { flunk 'test timed out' }
+    end
+    assert_equal [[1,2,3]], results
+  end
+
+  def test_timeout_gets_cancelled
+    EM.run do
+      completion.timeout(0.0001, :timeout)
+      completion.errback  { results << :errback  }
+      completion.succeed
+      EM.add_timer(0.0002) { EM.stop }
+    end
+    assert_equal [], results
+  end
+end

data/tests/test_connection_count.rb

@@ -1,6 +1,4 @@
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
+require 'em_test_helper'
 
 class TestConnectionCount < Test::Unit::TestCase
   def test_idle_connection_count

data/tests/test_defer.rb

@@ -1,34 +1,6 @@
-# $Id$
-#
-# Author:: Francis Cianfrocca (gmail: blackhedd)
-# Homepage::  http://rubyeventmachine.com
-# Date:: 8 April 2006
-# 
-# See EventMachine and EventMachine::Connection for documentation and
-# usage examples.
-#
-#----------------------------------------------------------------------------
-#
-# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
-# Gmail: blackhedd
-# 
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of either: 1) the GNU General Public License
-# as published by the Free Software Foundation; either version 2 of the
-# License, or (at your option) any later version; or 2) Ruby's License.
-# 
-# See the file COPYING for complete licensing information.
-#
-#---------------------------------------------------------------------------
-#
-#
-#
+require 'em_test_helper'
 
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
-
-class TestDeferUsage < Test::Unit::TestCase
+class TestDefer < Test::Unit::TestCase
 
   def test_defers
     n = 0
@@ -41,7 +13,6 @@ class TestDeferUsage < Test::Unit::TestCase
       }
     }
     assert_equal( n, n_times )
-  end unless RUBY_VERSION >= '1.9.0'
+  end
 
 end
-

data/tests/test_deferrable.rb

@@ -0,0 +1,35 @@
+require 'em_test_helper'
+
+class TestDeferrable < Test::Unit::TestCase
+  class Later
+    include EM::Deferrable
+  end
+
+  def test_timeout_without_args
+    assert_nothing_raised do
+      EM.run {
+        df = Later.new
+        df.timeout(0)
+        df.errback { EM.stop }
+        EM.add_timer(0.01) { flunk "Deferrable was not timed out." }
+      }
+    end
+  end
+
+  def test_timeout_with_args
+    args = nil
+
+    EM.run {
+      df = Later.new
+      df.timeout(0, :timeout, :foo)
+      df.errback do |type, name|
+        args = [type, name]
+        EM.stop
+      end
+
+      EM.add_timer(0.01) { flunk "Deferrable was not timed out." }
+    }
+
+    assert_equal [:timeout, :foo], args
+  end
+end