eventmachine 0.12.8-x86-mswin32-60 → 0.12.10-x86-mswin32-60

data/tests/test_next_tick.rb

@@ -33,7 +33,6 @@ class TestNextTick < Test::Unit::TestCase
 
   def test_tick_arg
     pr = proc {EM.stop}
-    EM.epoll
     EM.run {
       EM.next_tick pr
     }
@@ -41,7 +40,6 @@ class TestNextTick < Test::Unit::TestCase
   end
 
   def test_tick_block
-    EM.epoll
     EM.run {
       EM.next_tick {EM.stop}
     }

data/tests/test_pause.rb

@@ -0,0 +1,70 @@
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../lib")
+require 'eventmachine'
+require 'socket'
+require 'test/unit'
+
+class TestPause < Test::Unit::TestCase
+  TestHost = "127.0.0.1"
+  TestPort = 9070
+
+  def setup
+    assert(!EM.reactor_running?)
+  end
+
+  def teardown
+    assert(!EM.reactor_running?)
+  end
+
+  #-------------------------------------
+
+  def test_pause_resume
+    test = self
+    server = nil
+
+    s_rx = c_rx = 0
+
+    EM.run do
+      EM.start_server TestHost, TestPort, Module.new {
+        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
+      }
+
+      c = EM.connect TestHost, TestPort, Module.new {
+        define_method :receive_data do |data|
+          c_rx += 1
+        end
+      }
+      EM.add_periodic_timer(0.01) { c.send_data 'hi' }
+
+      EM.add_timer(1) do
+        test.assert_equal 1, s_rx
+        test.assert_equal 0, c_rx
+        test.assert server.paused?
+
+        # resume server, queued outgoing and incoming data will be flushed
+        server.resume
+
+        test.assert ! server.paused?
+
+        EM.add_timer(1) do
+          test.assert server.paused?
+          test.assert s_rx >= 2
+          test.assert c_rx >= 1
+          EM.stop_event_loop
+        end
+      end
+    end
+  end
+end

data/tests/test_pending_connect_timeout.rb

@@ -0,0 +1,48 @@
+$:.unshift "../lib"
+require 'eventmachine'
+require 'test/unit'
+
+class TestPendingConnectTimeout < Test::Unit::TestCase
+
+  def test_default
+    $timeout = nil
+    EM.run {
+      c = EM.connect("127.0.0.1", 54321)
+      $timeout = c.pending_connect_timeout
+      EM.stop
+    }
+
+    assert_equal(20.0, $timeout)
+  end
+
+  def test_set_and_get
+    $timeout = nil
+    EM.run {
+      c = EM.connect("1.2.3.4", 54321)
+      c.pending_connect_timeout = 2.5
+      $timeout = c.pending_connect_timeout
+      EM.stop
+    }
+
+    assert_equal(2.5, $timeout)
+  end
+
+  module TimeoutHandler
+    def unbind
+      EM.stop
+    end
+  end
+
+  def test_for_real
+    $timeout = nil
+    EM.run {
+      EM.heartbeat_interval = 0.1
+      $start = Time.now
+      c = EM.connect("1.2.3.4", 54321, TimeoutHandler)
+      c.pending_connect_timeout = 5
+    }
+
+    assert_in_delta(5, (Time.now - $start), 0.3)
+  end
+
+end

data/tests/test_ssl_args.rb

@@ -1,68 +1,79 @@
-require "test/unit"
-require 'tempfile'
-
-$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
-require "eventmachine"
-
-module EventMachine
-  def self._set_mocks
-    class <<self
-      alias set_tls_parms_old set_tls_parms
-      alias start_tls_old start_tls
-      def set_tls_parms *args; end
-      def start_tls *args; end
-    end
-  end
-  
-  def self._clear_mocks
-    class <<self
-      alias set_tls_parms set_tls_parms_old
-      alias start_tls start_tls_old
-    end
-  end
-end
-  
-
-class TestSslArgs < Test::Unit::TestCase
-  def setup
-    EventMachine._set_mocks
-  end
-  
-  def teardown
-    EventMachine._clear_mocks
-  end
-  
-  def test_tls_params_file_doesnt_exist
-    priv_file, cert_file = 'foo_priv_key', 'bar_cert_file'
-    [priv_file, cert_file].all? do |f|
-      assert(!File.exists?(f), "Cert file #{f} seems to exist, and should not for the tests")
-    end
-    
-    # associate_callback_target is a pain! (build!)
-    conn = EventMachine::Connection.new('foo')
-    
-    assert_raises(EventMachine::FileNotFoundException) do
-      conn.start_tls(:private_key_file => priv_file)
-    end
-    assert_raises(EventMachine::FileNotFoundException) do
-      conn.start_tls(:cert_chain_file => cert_file)
-    end
-    assert_raises(EventMachine::FileNotFoundException) do
-      conn.start_tls(:private_key_file => priv_file, :cert_chain_file => cert_file)
-    end
-  end
-  
-  def test_tls_params_file_does_exist
-    priv_file = Tempfile.new('em_test')
-    cert_file = Tempfile.new('em_test')
-    priv_file_path = priv_file.path
-    cert_file_path = cert_file.path
-    conn = EventMachine::Connection.new('foo')
-    params = {:private_key_file => priv_file_path, :cert_chain_file => cert_file_path}
-    begin
-      conn.start_tls params
-    rescue Object
-      assert(false, 'should not have raised an exception')
-    end
-  end
+require "test/unit"
+require 'tempfile'
+
+$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+require "eventmachine"
+
+module EventMachine
+  def self._set_mocks
+    class <<self
+      alias set_tls_parms_old set_tls_parms
+      alias start_tls_old start_tls
+      begin
+        old, $VERBOSE = $VERBOSE, nil
+        def set_tls_parms *args; end
+        def start_tls *args; end
+      ensure
+        $VERBOSE = old
+      end
+    end
+  end
+
+  def self._clear_mocks
+    class <<self
+      begin
+        old, $VERBOSE = $VERBOSE, nil
+        alias set_tls_parms set_tls_parms_old
+        alias start_tls start_tls_old
+      ensure
+        $VERBOSE = old
+      end
+    end
+  end
+end
+
+  
+
+class TestSslArgs < Test::Unit::TestCase
+  def setup
+    EventMachine._set_mocks
+  end
+  
+  def teardown
+    EventMachine._clear_mocks
+  end
+  
+  def test_tls_params_file_doesnt_exist
+    priv_file, cert_file = 'foo_priv_key', 'bar_cert_file'
+    [priv_file, cert_file].all? do |f|
+      assert(!File.exists?(f), "Cert file #{f} seems to exist, and should not for the tests")
+    end
+    
+    # associate_callback_target is a pain! (build!)
+    conn = EventMachine::Connection.new('foo')
+    
+    assert_raises(EventMachine::FileNotFoundException) do
+      conn.start_tls(:private_key_file => priv_file)
+    end
+    assert_raises(EventMachine::FileNotFoundException) do
+      conn.start_tls(:cert_chain_file => cert_file)
+    end
+    assert_raises(EventMachine::FileNotFoundException) do
+      conn.start_tls(:private_key_file => priv_file, :cert_chain_file => cert_file)
+    end
+  end
+  
+  def test_tls_params_file_does_exist
+    priv_file = Tempfile.new('em_test')
+    cert_file = Tempfile.new('em_test')
+    priv_file_path = priv_file.path
+    cert_file_path = cert_file.path
+    conn = EventMachine::Connection.new('foo')
+    params = {:private_key_file => priv_file_path, :cert_chain_file => cert_file_path}
+    begin
+      conn.start_tls params
+    rescue Object
+      assert(false, 'should not have raised an exception')
+    end
+  end
 end if EM.ssl?

data/tests/test_timers.rb

@@ -1,141 +1,162 @@
-# $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 TestTimers < Test::Unit::TestCase
-
-  def test_timer_with_block
-    x = false
-    EventMachine.run {
-      EventMachine::Timer.new(0.25) {
-        x = true
-        EventMachine.stop
-      }
-    }
-    assert x
-  end
-
-  def test_timer_with_proc
-    x = false
-    EventMachine.run {
-      EventMachine::Timer.new(0.25, proc {
-        x = true
-        EventMachine.stop
-      })
-    }
-    assert x
-  end
-
-  def test_timer_cancel
-    x = true
-    EventMachine.run {
-      timer = EventMachine::Timer.new(0.25, proc { x = false })
-      timer.cancel
-      EventMachine::Timer.new(0.5, proc {EventMachine.stop})
-    }
-    assert x
-  end
-
-  def test_periodic_timer
-    x = 0
-    EventMachine.run {
-      EventMachine::PeriodicTimer.new(0.1) do
-        x += 1
-        EventMachine.stop if x == 4
-      end
-    }
-    assert( x == 4 )
-  end
-
-  def test_periodic_timer_cancel
-    x = 0
-    EventMachine.run {
-      pt = EventMachine::PeriodicTimer.new(0.25, proc { x += 1 })
-      pt.cancel
-      EventMachine::Timer.new(0.5) {EventMachine.stop}
-    }
-    assert( x == 0 )
-  end
-
-  def test_periodic_timer_self_cancel
-    x = 0
-    EventMachine.run {
-      pt = EventMachine::PeriodicTimer.new(0.1) {
-        x += 1
-        if x == 4
-          pt.cancel
-          EventMachine.stop
-        end
-      }
-    }
-    assert( x == 4 )
-  end
-
-
-  # This test is only applicable to compiled versions of the reactor.
-  # Pure ruby and java versions have no built-in limit on the number of outstanding timers.
-  #
-  def test_timer_change_max_outstanding
-    ten_thousand_timers = proc {
-      10000.times {
-        EM.add_timer(5) {}
-      }
-    }
-
-    EM.run {
-      if EM.library_type == :pure_ruby
-        ten_thousand_timers.call
-      elsif EM.library_type == :java
-        ten_thousand_timers.call
-      else
-        begin
-          assert_raises( RuntimeError ) {
-            ten_thousand_timers.call
-          }
-        rescue Object
-          p $!
-          assert(false, $!.message)
-        end
-      end
-      EM.stop
-    }
-
-    assert(!EM.reactor_running?, 'Reactor running when it should not be.')
-    assert( EM.get_max_timers != 10001 )
-    EM.set_max_timers( 10001 )
-    assert( EM.get_max_timers == 10001 )
-
-    EM.run {
-      ten_thousand_timers.call
-      EM.stop
-    }
-  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 TestTimers < Test::Unit::TestCase
+
+  def test_timer_with_block
+    x = false
+    EventMachine.run {
+      EventMachine::Timer.new(0.25) {
+        x = true
+        EventMachine.stop
+      }
+    }
+    assert x
+  end
+
+  def test_timer_with_proc
+    x = false
+    EventMachine.run {
+      EventMachine::Timer.new(0.25, proc {
+        x = true
+        EventMachine.stop
+      })
+    }
+    assert x
+  end
+
+  def test_timer_cancel
+    x = true
+    EventMachine.run {
+      timer = EventMachine::Timer.new(0.25, proc { x = false })
+      timer.cancel
+      EventMachine::Timer.new(0.5, proc {EventMachine.stop})
+    }
+    assert x
+  end
+
+  def test_periodic_timer
+    x = 0
+    EventMachine.run {
+      EventMachine::PeriodicTimer.new(0.1) do
+        x += 1
+        EventMachine.stop if x == 4
+      end
+    }
+    assert( x == 4 )
+  end
+
+  def test_add_periodic_timer
+    x = 0
+    EM.run {
+      t = EM.add_periodic_timer(0.1) do
+        x += 1
+        EM.stop  if x == 4
+      end
+      assert t.respond_to?(:cancel)
+    }
+  end
+
+  def test_periodic_timer_cancel
+    x = 0
+    EventMachine.run {
+      pt = EventMachine::PeriodicTimer.new(0.25, proc { x += 1 })
+      pt.cancel
+      EventMachine::Timer.new(0.5) {EventMachine.stop}
+    }
+    assert( x == 0 )
+  end
+
+  def test_add_periodic_timer_cancel
+    x = 0
+    EventMachine.run {
+      pt = EM.add_periodic_timer(0.25) { x += 1 }
+      EM.cancel_timer(pt)
+      EM.add_timer(0.5) { EM.stop }
+    }
+    assert( x == 0 )
+  end
+
+  def test_periodic_timer_self_cancel
+    x = 0
+    EventMachine.run {
+      pt = EventMachine::PeriodicTimer.new(0.1) {
+        x += 1
+        if x == 4
+          pt.cancel
+          EventMachine.stop
+        end
+      }
+    }
+    assert( x == 4 )
+  end
+
+
+  # This test is only applicable to compiled versions of the reactor.
+  # Pure ruby and java versions have no built-in limit on the number of outstanding timers.
+  #
+  def test_timer_change_max_outstanding
+    ten_thousand_timers = proc {
+      10001.times {
+        EM.add_timer(5) {}
+      }
+    }
+
+    EM.run {
+      if EM.library_type == :pure_ruby
+        ten_thousand_timers.call
+      elsif EM.library_type == :java
+        ten_thousand_timers.call
+      else
+        begin
+          assert_raises( RuntimeError ) {
+            ten_thousand_timers.call
+          }
+        rescue Object
+          p $!
+          assert(false, $!.message)
+        end
+      end
+      EM.stop
+    }
+
+    assert(!EM.reactor_running?, 'Reactor running when it should not be.')
+    assert( EM.get_max_timers != 10001 )
+    EM.set_max_timers( 10001 )
+    assert( EM.get_max_timers == 10001 )
+
+    EM.run {
+      ten_thousand_timers.call
+      EM.stop
+    }
+  end
+
+end