eventmachine 0.12.10-x86-mswin32-60 → 1.0.0.beta.2-x86-mswin32-60

data/tests/test_next_tick.rb

@@ -61,7 +61,7 @@ class TestNextTick < Test::Unit::TestCase
   def test_pre_run_queue
     x = false
     EM.next_tick { EM.stop; x = true }
-    EM.run { EM.add_timer(0.2) { EM.stop } }
+    EM.run { EM.add_timer(0.01) { EM.stop } }
     assert x
   end
 

data/tests/test_object_protocol.rb

@@ -1,37 +1,37 @@
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
-
-class TestObjectProtocol < Test::Unit::TestCase
-  Host = "127.0.0.1"
-  Port = 9550
-
-  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 test_send_receive
-    EM.run{
-      EM.start_server Host, Port, Server
-      EM.connect Host, Port, Client
-    }
-
-    assert($client == {:hello=>'world'})
-    assert($server == {'you_said'=>{:hello=>'world'}})
-  end
+$:.unshift "../lib"
+require 'eventmachine'
+require 'test/unit'
+
+class TestObjectProtocol < Test::Unit::TestCase
+  Host = "127.0.0.1"
+  Port = 9550
+
+  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 test_send_receive
+    EM.run{
+      EM.start_server Host, Port, Server
+      EM.connect Host, Port, Client
+    }
+
+    assert($client == {:hello=>'world'})
+    assert($server == {'you_said'=>{:hello=>'world'}})
+  end
 end

data/tests/test_pending_connect_timeout.rb

@@ -39,10 +39,10 @@ class TestPendingConnectTimeout < Test::Unit::TestCase
       EM.heartbeat_interval = 0.1
       $start = Time.now
       c = EM.connect("1.2.3.4", 54321, TimeoutHandler)
-      c.pending_connect_timeout = 5
+      c.pending_connect_timeout = 0.2
     }
 
-    assert_in_delta(5, (Time.now - $start), 0.3)
+    assert_in_delta(0.2, (Time.now - $start), 0.1)
   end
 
 end

data/tests/test_process_watch.rb

@@ -1,48 +1,50 @@
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
-
-class TestProcessWatch < Test::Unit::TestCase
-  module ParentProcessWatcher
-    def process_forked
-      $forked = true
-    end
-  end
-
-  module ChildProcessWatcher
-    def process_exited
-      $exited = true
-    end
-    def unbind
-      $unbind = true
-      EM.stop
-    end
-  end
-
-  def setup
-    EM.kqueue = true if EM.kqueue?
-  end
-
-  def teardown
-    EM.kqueue = false if EM.kqueue?
-  end
-
-  def test_events
-    EM.run{
-      # watch ourselves for a fork notification
-      EM.watch_process(Process.pid, ParentProcessWatcher)
-      $fork_pid = fork{ sleep }
-      child = EM.watch_process($fork_pid, ChildProcessWatcher)
-      $pid = child.pid
-
-      EM.add_timer(0.5){
-        Process.kill('TERM', $fork_pid)
-      }
-    }
-
-    assert_equal($pid, $fork_pid)
-    assert($forked)
-    assert($exited)
-    assert($unbind)
-  end
-end
+$:.unshift "../lib"
+require 'eventmachine'
+require 'test/unit'
+
+if EM.kqueue?
+  class TestProcessWatch < Test::Unit::TestCase
+    module ParentProcessWatcher
+      def process_forked
+        $forked = true
+      end
+    end
+
+    module ChildProcessWatcher
+      def process_exited
+        $exited = true
+      end
+      def unbind
+        $unbind = true
+        EM.stop
+      end
+    end
+
+    def setup
+      EM.kqueue = true
+    end
+
+    def teardown
+      EM.kqueue = false
+    end
+
+    def test_events
+      EM.run{
+        # watch ourselves for a fork notification
+        EM.watch_process(Process.pid, ParentProcessWatcher)
+        $fork_pid = fork{ sleep }
+        child = EM.watch_process($fork_pid, ChildProcessWatcher)
+        $pid = child.pid
+
+        EM.add_timer(0.2){
+          Process.kill('TERM', $fork_pid)
+        }
+      }
+
+      assert_equal($pid, $fork_pid)
+      assert($forked)
+      assert($exited)
+      assert($unbind)
+    end
+  end
+end

data/tests/test_proxy_connection.rb

@@ -29,6 +29,40 @@ class TestProxyConnection < Test::Unit::TestCase
     end
   end
 
+  module PartialProxyConnection
+    def initialize(client, request, length)
+      @client, @request, @length = client, request, length
+    end
+
+    def post_init
+      EM::enable_proxy(self, @client, 0, @length)
+    end
+
+    def receive_data(data)
+      $unproxied_data = data
+      @client.send_data(data) 
+    end
+
+    def connection_completed
+      EM.next_tick {
+        send_data @request
+      }
+    end
+
+    def proxy_target_unbound
+      $unbound_early = true
+      EM.stop
+    end
+
+    def proxy_completed
+      $proxy_completed = true
+    end
+
+    def unbind
+      @client.close_connection_after_writing
+    end
+  end
+
   module Client
     def connection_completed
       send_data "EventMachine rocks!"
@@ -61,6 +95,12 @@ class TestProxyConnection < Test::Unit::TestCase
     end
   end
 
+  module PartialProxyServer
+    def receive_data(data)
+      EM.connect("127.0.0.1", 54321, PartialProxyConnection, self, data, 1)
+    end
+  end
+
   module EarlyClosingProxy
     def receive_data(data)
       EM.connect("127.0.0.1", 54321, ProxyConnection, self, data)
@@ -78,6 +118,18 @@ class TestProxyConnection < Test::Unit::TestCase
     assert_equal("I know!", $client_data)
   end
 
+  def test_partial_proxy_connection
+    EM.run {
+      EM.start_server("127.0.0.1", 54321, Server)
+      EM.start_server("127.0.0.1", 12345, PartialProxyServer)
+      EM.connect("127.0.0.1", 12345, Client)
+    }
+
+    assert_equal("I know!", $client_data)
+    assert_equal(" know!", $unproxied_data)
+    assert($proxy_completed)
+  end
+
   def test_early_close
     $client_data = nil
     EM.run {

data/tests/test_pure.rb

@@ -1,125 +1,134 @@
-# $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 "../lib"
-require 'eventmachine'
-require 'test/unit'
-
-class TestPure < Test::Unit::TestCase
-
-
-  Host,Port = "0.0.0.0", 9060
-
-
-  # These tests are intended to exercise problems that come up in the
-  # pure-Ruby implementation. However, we DON'T constrain them such that
-  # they only run in pure-Ruby. These tests need to work identically in
-  # any implementation.
-
-  def setup
-  end
-
-  def teardown
-  end
-
-  #-------------------------------------
-
-  # The EM reactor needs to run down open connections and release other resources
-  # when it stops running. Make sure this happens even if user code throws a Ruby
-  # exception.
-  # One way to see this is to run identical tests that open a TCP server and throw
-  # an exception. (We do this twice because an exception aborts a test. We make the
-  # two tests identical except for the method name because we can't predict the order
-  # in which the test harness will run them.)
-  # If exception handling is incorrect, the second test will fail with a no-bind error
-  # because the TCP server opened in the first test will not have been closed.
-  #
-  def run_exception
-      EM.run {
-        EM.start_server Host, Port
-        raise "an exception"
-      }
-  end
-  def test_exception_1
-    assert_raises( RuntimeError ) { run_exception }
-  end
-  def test_exception_2
-    ex_class = RUBY_PLATFORM == 'java' ? NativeException : RuntimeError
-    assert_raises( ex_class ) { run_exception }
-  end
-
-
-  # Under some circumstances, the pure Ruby library would emit an Errno::ECONNREFUSED
-  # exception on certain kinds of TCP connect-errors.
-  # It's always been something of an open question whether EM should throw an exception
-  # in these cases but the defined answer has always been to catch it the unbind method.
-  # With a connect failure, the latter will always fire, but connection_completed will
-  # never fire. So even though the point is arguable, it's incorrect for the pure Ruby
-  # version to throw an exception.
-  module TestConnrefused
-    def unbind
-      EM.stop
-    end
-    def connection_completed
-      raise "should never get here"
-    end
-  end
-  def test_connrefused
-    EM.run {
-      EM.connect "0.0.0.0", 60001, TestConnrefused
-    }
-  end
-
-
-  # Make sure connection_completed gets called as expected with TCP clients. This is the
-  # opposite of test_connrefused.
-  # If the test fails, it will hang because EM.stop never gets called.
-  #
-  module TestConnaccepted
-    def connection_completed
-      EM.stop
-    end
-  end
-  def test_connaccepted
-    timeout = false
-    EM.run {
-      EM.start_server "0.0.0.0", 60002
-      EM.connect "0.0.0.0", 60002, TestConnaccepted
-      EM::Timer.new(1) {timeout = true; EM.stop}
-    }
-    assert_equal( false, timeout )
-  end
-
-  def test_reactor_running
-    a = false
-    EM.run {
-      a = EM.reactor_running?
-      EM.next_tick {EM.stop}
-    }
-    assert a
-  end
-
-end
+# $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 "../lib"
+require 'eventmachine'
+require 'test/unit'
+
+class TestPure < Test::Unit::TestCase
+
+
+  Host,Port = "0.0.0.0", 9060
+
+
+  # These tests are intended to exercise problems that come up in the
+  # pure-Ruby implementation. However, we DON'T constrain them such that
+  # they only run in pure-Ruby. These tests need to work identically in
+  # any implementation.
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  #-------------------------------------
+
+  # The EM reactor needs to run down open connections and release other resources
+  # when it stops running. Make sure this happens even if user code throws a Ruby
+  # exception.
+  # One way to see this is to run identical tests that open a TCP server and throw
+  # an exception. (We do this twice because an exception aborts a test. We make the
+  # two tests identical except for the method name because we can't predict the order
+  # in which the test harness will run them.)
+  # If exception handling is incorrect, the second test will fail with a no-bind error
+  # because the TCP server opened in the first test will not have been closed.
+  #
+  def run_exception
+      EM.run {
+        EM.start_server Host, Port
+        raise "an exception"
+      }
+  end
+  def test_exception_1
+    assert_raises( RuntimeError ) { run_exception }
+  end
+  def test_exception_2
+    ex_class = RUBY_PLATFORM == 'java' ? NativeException : RuntimeError
+    assert_raises( ex_class ) { run_exception }
+  end
+
+
+  # Under some circumstances, the pure Ruby library would emit an Errno::ECONNREFUSED
+  # exception on certain kinds of TCP connect-errors.
+  # It's always been something of an open question whether EM should throw an exception
+  # in these cases but the defined answer has always been to catch it the unbind method.
+  # With a connect failure, the latter will always fire, but connection_completed will
+  # never fire. So even though the point is arguable, it's incorrect for the pure Ruby
+  # version to throw an exception.
+  module TestConnrefused
+    def unbind
+      EM.stop
+    end
+    def connection_completed
+      raise "should never get here"
+    end
+  end
+  def test_connrefused
+    EM.run {
+      EM.connect "0.0.0.0", 60001, TestConnrefused
+    }
+  end
+
+
+  # Make sure connection_completed gets called as expected with TCP clients. This is the
+  # opposite of test_connrefused.
+  # If the test fails, it will hang because EM.stop never gets called.
+  #
+  module TestConnaccepted
+    def connection_completed
+      EM.stop
+    end
+  end
+  def test_connaccepted
+    timeout = false
+    EM.run {
+      EM.start_server "0.0.0.0", 60002
+      EM.connect "0.0.0.0", 60002, TestConnaccepted
+      setup_timeout(1)
+    }
+    assert_equal( false, timeout )
+  end
+  
+  def setup_timeout(timeout = 4)
+    EM.schedule {
+      start_time = EM.current_time
+      EM.add_periodic_timer(0.01) {
+        raise "timeout" if EM.current_time - start_time >= timeout
+      }
+    }
+  end
+
+  def test_reactor_running
+    a = false
+    EM.run {
+      a = EM.reactor_running?
+      EM.next_tick {EM.stop}
+    }
+    assert a
+  end
+
+end