eventmachine 0.12.10 → 1.0.0.beta.1

data/tests/test_channel.rb

@@ -30,8 +30,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_defer.rb

@@ -28,20 +28,22 @@ $:.unshift "../lib"
 require 'eventmachine'
 require 'test/unit'
 
-class TestDeferUsage < Test::Unit::TestCase
+unless RUBY_VERSION >= '1.9.0'
+  class TestDeferUsage < Test::Unit::TestCase
 
-  def test_defers
-    n = 0
-    n_times = 20
-    EM.run {
-      n_times.times {
-        work_proc = proc { n += 1 }
-        callback = proc { EM.stop if n == n_times }
-        EM.defer work_proc, callback
+    def test_defers
+      n = 0
+      n_times = 20
+      EM.run {
+        n_times.times {
+          work_proc = proc { n += 1 }
+          callback = proc { EM.stop if n == n_times }
+          EM.defer work_proc, callback
+        }
       }
-    }
-    assert_equal( n, n_times )
-  end unless RUBY_VERSION >= '1.9.0'
+      assert_equal( n, n_times )
+    end
 
+  end
 end
 

data/tests/test_deferrable.rb

@@ -0,0 +1,35 @@
+$:.unshift "../lib"
+require 'eventmachine'
+require 'test/unit'
+
+class TestDeferrable < Test::Unit::TestCase
+  class Later
+    include EM::Deferrable
+  end
+
+  def test_timeout_without_args
+    $args = "unset"
+
+    EM.run {
+      df = Later.new
+      df.timeout(0.2)
+      df.errback { $args = "none" }
+      EM.add_timer(0.5) { EM.stop }
+    }
+
+    assert_equal("none", $args)
+  end
+
+  def test_timeout_with_args
+    $args = "unset"
+
+    EM.run {
+      df = Later.new
+      df.timeout(0.2, :timeout, :foo)
+      df.errback { |type, name| $args = [type, name] }
+      EM.add_timer(0.5) { EM.stop }
+    }
+
+    assert_equal([:timeout, :foo], $args)
+  end
+end

data/tests/test_file_watch.rb

@@ -38,7 +38,7 @@ class TestFileWatch < Test::Unit::TestCase
       File.open(file.path, 'w'){ |f| f.puts 'hi' }
 
       # delete it
-      EM.add_timer(0.25){ file.close; file.delete }
+      EM.add_timer(0.01){ file.close; file.delete }
     }
 
     assert_equal($path, $tmp_path)

data/tests/test_futures.rb

@@ -190,7 +190,7 @@ class TestFutures < Test::Unit::TestCase
       d = EM::DefaultDeferrable.new
       d.callback {n = 1; EM.stop}
       d.errback {n = 2; EM.stop}
-      d.timeout(1)
+      d.timeout(0.01)
     }
     assert_equal( 2, n )
   end

data/tests/test_hc.rb

@@ -24,7 +24,6 @@
 #
 #
 
-# $:.unshift "../lib"
 require 'eventmachine'
 require 'test/unit'
 
@@ -49,27 +48,25 @@ class TestHeaderAndContentProtocol < Test::Unit::TestCase
       @request << [hdrs, content]
     end
   end
+  
+  class StopOnUnbind < EM::Connection
+    def unbind
+      EM.add_timer(0.1) { EM.stop }
+    end
+  end
 
   def test_no_content
     the_connection = nil
-    EventMachine.run {
-      EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
+    EM.run {
+      EM.start_server( TestHost, TestPort, SimpleTest ) do |conn|
         the_connection = conn
       end
-      EventMachine.add_timer(4) {raise "test timed out"}
+      setup_timeout
 
-      client = Module.new do
-        def unbind
-          EM.add_timer(0.1) { EM.stop }
-        end
-
-        def post_init
-          send_data [ "aaa\n", "bbb\r\n", "ccc\n", "\n" ].join
-          close_connection_after_writing
-        end
+      EM.connect TestHost, TestPort, StopOnUnbind do |c|
+        c.send_data [ "aaa\n", "bbb\r\n", "ccc\n", "\n" ].join
+        c.close_connection_after_writing
       end
-
-      EventMachine.connect( TestHost, TestPort, client )
     }
     assert_equal( ["aaa"], the_connection.first_header )
     assert_equal( [%w(aaa bbb ccc)], the_connection.my_headers )
@@ -84,26 +81,14 @@ class TestHeaderAndContentProtocol < Test::Unit::TestCase
       EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
         the_connection = conn
       end
-      EventMachine.add_timer(4) { assert(false, 'test timeout'); EM.stop }
-
-      client = Module.new do
-        define_method(:headers) { headers }
-        define_method(:content) { content }
-
-        def unbind
-          EM.add_timer(0.1) { EM.stop }
-        end
+      setup_timeout
 
-        def post_init
-          headers.each { |h| send_data "#{h}\r\n" }
-          send_data "\n"
-          send_data content
-          close_connection_after_writing
-        end
+      EM.connect TestHost, TestPort, StopOnUnbind do |c|
+        headers.each { |h| c.send_data "#{h}\r\n" }
+        c.send_data "\n"
+        c.send_data content
+        c.close_connection_after_writing
       end
-
-      EventMachine.connect( TestHost, TestPort, client )
-
     }
     assert_equal( ["aaa"], the_connection.first_header )
     assert_equal( [headers], the_connection.my_headers )
@@ -118,27 +103,16 @@ class TestHeaderAndContentProtocol < Test::Unit::TestCase
       EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
         the_connection = conn
       end
-      EventMachine.add_timer(4) { assert(false, 'test timeout'); EM.stop }
-
-      client = Module.new do
-        define_method(:headers) { headers }
-        define_method(:content) { content }
-
-        def unbind
-          EM.add_timer(0.1) { EM.stop }
-        end
+      setup_timeout
 
-        def post_init
-          5.times do
-            headers.each { |h| send_data "#{h}\r\n" }
-            send_data "\n"
-            send_data content
-          end
-          close_connection_after_writing
+      EventMachine.connect( TestHost, TestPort, StopOnUnbind ) do |c|
+        5.times do
+          headers.each { |h| c.send_data "#{h}\r\n" }
+          c.send_data "\n"
+          c.send_data content
         end
+        c.close_connection_after_writing
       end
-
-      EventMachine.connect( TestHost, TestPort, client )
     }
     assert_equal( ["aaa"] * 5, the_connection.first_header )
     assert_equal( [headers] * 5, the_connection.my_headers )
@@ -184,25 +158,14 @@ class TestHeaderAndContentProtocol < Test::Unit::TestCase
       EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
         the_connection = conn
       end
-      EventMachine.add_timer(4) {raise "test timed out"}
-
-      client = Module.new do
-        define_method(:headers) { headers }
-        define_method(:content) { content }
+      setup_timeout
 
-        def unbind
-          EM.add_timer(0.1) { EM.stop }
-        end
-
-        def post_init
-          headers.each { |h| send_data "#{h}\r\n" }
-          send_data "\n"
-          send_data content
-          close_connection_after_writing
-        end
+      EventMachine.connect( TestHost, TestPort, StopOnUnbind ) do |c|
+        headers.each { |h| c.send_data "#{h}\r\n" }
+        c.send_data "\n"
+        c.send_data content
+        c.close_connection_after_writing
       end
-
-      EventMachine.connect( TestHost, TestPort, client )
     }
 
     hsh = the_connection.headers_2_hash( the_connection.my_headers.shift )
@@ -215,4 +178,13 @@ class TestHeaderAndContentProtocol < Test::Unit::TestCase
     assert_equal(expect, hsh)
   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
+
 end

data/tests/test_httpclient.rb

@@ -44,7 +44,7 @@ class TestHttpClient < Test::Unit::TestCase
   def test_http_client
     ok = false
     EventMachine.run {
-      c = EventMachine::Protocols::HttpClient.send :request, :host => "www.bayshorenetworks.com", :port => 80
+      c = EventMachine::Protocols::HttpClient.send :request, :host => "www.google.com", :port => 80
       c.callback {
         ok = true
         EventMachine.stop
@@ -59,7 +59,7 @@ class TestHttpClient < Test::Unit::TestCase
   def test_http_client_1
     ok = false
     EventMachine.run {
-      c = EventMachine::Protocols::HttpClient.send :request, :host => "www.bayshorenetworks.com", :port => 80
+      c = EventMachine::Protocols::HttpClient.send :request, :host => "www.google.com", :port => 80
       c.callback {ok = true; EventMachine.stop}
       c.errback {EventMachine.stop}
     }
@@ -71,7 +71,7 @@ class TestHttpClient < Test::Unit::TestCase
   def test_http_client_2
     ok = false
     EventMachine.run {
-      c = EventMachine::Protocols::HttpClient.send :request, :host => "www.bayshorenetworks.com", :port => 80
+      c = EventMachine::Protocols::HttpClient.send :request, :host => "www.google.com", :port => 80
       c.callback {|result|
         ok = true;
         EventMachine.stop
@@ -154,6 +154,15 @@ class TestHttpClient < Test::Unit::TestCase
         close_connection_after_writing
       end
   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
 
   # TODO, this is WRONG. The handler is asserting an HTTP 1.1 request, but the client
   # is sending a 1.0 request. Gotta fix the client
@@ -161,7 +170,7 @@ class TestHttpClient < Test::Unit::TestCase
       response = nil
       EventMachine.run {
         EventMachine.start_server Localhost, Localport, PostContent
-        EventMachine.add_timer(2) {raise "timed out"}
+        setup_timeout(2)
         c = EventMachine::Protocols::HttpClient.request(
           :host=>Localhost,
           :port=>Localport,
@@ -186,7 +195,7 @@ class TestHttpClient < Test::Unit::TestCase
   def test_cookie
     ok = false
     EM.run {
-      c = EM::Protocols::HttpClient.send :request, :host => "www.bayshorenetworks.com", :port => 80, :cookie=>"aaa=bbb"
+      c = EM::Protocols::HttpClient.send :request, :host => "www.google.com", :port => 80, :cookie=>"aaa=bbb"
       c.callback {|result|
         ok = true;
         EventMachine.stop
@@ -202,7 +211,7 @@ class TestHttpClient < Test::Unit::TestCase
     ok = false
     EM.run {
       c = EM::P::HttpClient.request(
-        :host => "www.bayshorenetworks.com",
+        :host => "www.google.com",
         :port => 80,
         :version => "1.0"
       )

data/tests/test_httpclient2.rb

@@ -121,7 +121,8 @@ class TestHttpClient2 < Test::Unit::TestCase
       e.callback {
         headers2 = e.headers
       }
-      EM::Timer.new(1) {EM.stop}
+      EM.tick_loop { EM.stop if headers && headers2 }
+      EM.add_timer(1) { EM.stop }
     }
     assert(headers)
     assert(headers2)
@@ -141,7 +142,7 @@ class TestHttpClient2 < Test::Unit::TestCase
   def test_https_get
     d = nil
     EM.run {
-      http = EM::P::HttpClient2.connect :host => 'www.amazon.com', :port => 443, :ssl => true
+      http = EM::P::HttpClient2.connect :host => 'www.apple.com', :port => 443, :ssl => true
       d = http.get "/"
       d.callback {
         EM.stop

data/tests/test_inactivity_timeout.rb

@@ -37,14 +37,14 @@ class TestInactivityTimeout < Test::Unit::TestCase
     EM.run {
       EM.heartbeat_interval = 0.1
       EM.start_server("127.0.0.1", 12345)
-      EM.add_timer(0.2) {
+      EM.add_timer(0.1) {
         $start = Time.now
         c = EM.connect("127.0.0.1", 12345, TimeoutHandler)
-        c.comm_inactivity_timeout = 2.5
+        c.comm_inactivity_timeout = 0.2
       }
     }
 
-    assert_in_delta(2.5, (Time.now - $start), 0.3)
+    assert_in_delta(0.2, (Time.now - $start), 0.1)
   end
 
 end

data/tests/test_ltp.rb

@@ -55,7 +55,15 @@ class TestLineAndTextProtocol < Test::Unit::TestCase
       EM.add_timer(0.1) { EM.stop }
     end
   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_simple_lines
     lines_received = []
@@ -63,7 +71,7 @@ class TestLineAndTextProtocol < Test::Unit::TestCase
       EventMachine.start_server( TestHost, TestPort, SimpleLineTest ) do |conn|
         conn.instance_eval "@line_buffer = lines_received"
       end
-      EventMachine.add_timer(4) {assert(false, "test timed out")}
+      setup_timeout
 
       EventMachine.connect TestHost, TestPort, StopClient do |c|
         c.send_data "aaa\nbbb\r\nccc\n"
@@ -87,7 +95,7 @@ class TestLineAndTextProtocol < Test::Unit::TestCase
       EventMachine.start_server( TestHost, TestPort, SimpleLineTest ) do |conn|
         conn.instance_eval "@error_message = lines_received"
       end
-      EventMachine.add_timer(4) {assert(false, "test timed out")}
+      setup_timeout
 
       EventMachine.connect TestHost, TestPort, StopClient do |c|
         c.send_data "a" * (16*1024 + 1)
@@ -126,7 +134,7 @@ class TestLineAndTextProtocol < Test::Unit::TestCase
       EventMachine.start_server( TestHost, TestPort, LineAndTextTest ) do |conn|
         conn.instance_eval "@lines = lines_received; @text = text_received"
       end
-      EventMachine.add_timer(4) {assert(false, "test timed out")}
+      setup_timeout
 
       EventMachine.connect TestHost, TestPort, StopClient do |c|
         c.set_receive_data { |data| output << data }
@@ -166,7 +174,7 @@ class TestLineAndTextProtocol < Test::Unit::TestCase
       EventMachine.start_server( TestHost, TestPort, BinaryTextTest ) do |conn|
         conn.instance_eval "@lines = lines_received; @text = text_received"
       end
-      EventMachine.add_timer(4) {assert(false, "test timed out")}
+      setup_timeout
 
       EventMachine.connect TestHost, TestPort, StopClient do |c|
         c.set_receive_data { |data| output << data }

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_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

@@ -2,47 +2,49 @@ $:.unshift "../lib"
 require 'eventmachine'
 require 'test/unit'
 
-class TestProcessWatch < Test::Unit::TestCase
-  module ParentProcessWatcher
-    def process_forked
-      $forked = true
+if EM.kqueue?
+  class TestProcessWatch < Test::Unit::TestCase
+    module ParentProcessWatcher
+      def process_forked
+        $forked = true
+      end
     end
-  end
 
-  module ChildProcessWatcher
-    def process_exited
-      $exited = true
-    end
-    def unbind
-      $unbind = true
-      EM.stop
+    module ChildProcessWatcher
+      def process_exited
+        $exited = true
+      end
+      def unbind
+        $unbind = true
+        EM.stop
+      end
     end
-  end
 
-  def setup
-    EM.kqueue = true if EM.kqueue?
-  end
+    def setup
+      EM.kqueue = true
+    end
 
-  def teardown
-    EM.kqueue = false if EM.kqueue?
-  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
+    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)
+        EM.add_timer(0.2){
+          Process.kill('TERM', $fork_pid)
+        }
       }
-    }
 
-    assert_equal($pid, $fork_pid)
-    assert($forked)
-    assert($exited)
-    assert($unbind)
+      assert_equal($pid, $fork_pid)
+      assert($forked)
+      assert($exited)
+      assert($unbind)
+    end
   end
-end
+end