eventmachine 1.2.1 → 1.2.2

data/tests/test_idle_connection.rb

@@ -1,25 +1,31 @@
 require 'em_test_helper'
 
 class TestIdleConnection < Test::Unit::TestCase
-  if EM.respond_to?(:get_idle_time)
-    def test_idle_time
-      EM.run{
-        conn = EM.connect 'www.google.com', 80
-        EM.add_timer(3){
-          $idle_time = conn.get_idle_time
-          conn.send_data "GET / HTTP/1.0\r\n\r\n"
-          EM.next_tick{
-            EM.next_tick{
-              $idle_time_after_send = conn.get_idle_time
-              conn.close_connection
-              EM.stop
-            }
-          }
-        }
-      }
+  def setup
+    @port = next_port
+  end
+
+  def test_idle_time
+    omit_if(!EM.respond_to?(:get_idle_time))
 
-      assert_in_delta 3, $idle_time, 0.2
-      assert_in_delta 0, $idle_time_after_send, 0.1
+    a, b = nil, nil
+    EM.run do
+      EM.start_server '127.0.0.1', @port, Module.new
+      conn = EM.connect '127.0.0.1', @port
+      EM.add_timer(0.3) do
+        a = conn.get_idle_time
+        conn.send_data 'a'
+        EM.next_tick do
+          EM.next_tick do
+            b = conn.get_idle_time
+            conn.close_connection
+            EM.stop
+          end
+        end
+      end
     end
+
+    assert_in_delta 0.3, a, 0.1
+    assert_in_delta 0, b, 0.1
   end
 end

data/tests/test_ipv4.rb

@@ -1,125 +1,95 @@
 require 'em_test_helper'
-require 'socket'
 
 class TestIPv4 < Test::Unit::TestCase
-
-  if Test::Unit::TestCase.public_ipv4?
-
-    # Tries to connect to www.google.com port 80 via TCP.
-    # Timeout in 2 seconds.
-    def test_ipv4_tcp_client
-      conn = nil
-      setup_timeout(2)
-
-      EM.run do
-        conn = EM::connect("www.google.com", 80) do |c|
-          def c.connected
-            @connected
-          end
-
-          def c.connection_completed
-            @connected = true
-            EM.stop
-          end
+  # Runs a TCP server in the local IPv4 address, connects to it and sends a specific data.
+  # Timeout in 2 seconds.
+  def test_ipv4_tcp_local_server
+    omit_if(!Test::Unit::TestCase.public_ipv4?)
+
+    @@received_data = nil
+    @local_port = next_port
+    setup_timeout(2)
+
+    EM.run do
+      EM::start_server(@@public_ipv4, @local_port) do |s|
+        def s.receive_data data
+          @@received_data = data
+          EM.stop
         end
       end
 
-      assert conn.connected
-    end
-
-    # Runs a TCP server in the local IPv4 address, connects to it and sends a specific data.
-    # Timeout in 2 seconds.
-    def test_ipv4_tcp_local_server
-      @@received_data = nil
-      @local_port = next_port
-      setup_timeout(2)
-
-      EM.run do
-        EM::start_server(@@public_ipv4, @local_port) do |s|
-          def s.receive_data data
-            @@received_data = data
-            EM.stop
-          end
-        end
-
-        EM::connect(@@public_ipv4, @local_port) do |c|
-          c.send_data "ipv4/tcp"
-        end
+      EM::connect(@@public_ipv4, @local_port) do |c|
+        c.send_data "ipv4/tcp"
       end
-
-      assert_equal "ipv4/tcp", @@received_data
     end
 
-    # Runs a UDP server in the local IPv4 address, connects to it and sends a specific data.
-    # Timeout in 2 seconds.
-    def test_ipv4_udp_local_server
-      @@received_data = nil
-      @local_port = next_port
-      setup_timeout(2)
-
-      EM.run do
-        EM::open_datagram_socket(@@public_ipv4, @local_port) do |s|
-          def s.receive_data data
-            @@received_data = data
-            EM.stop
-          end
-        end
+    assert_equal "ipv4/tcp", @@received_data
+  end
 
-        EM::open_datagram_socket(@@public_ipv4, next_port) do |c|
-          c.send_datagram "ipv4/udp", @@public_ipv4, @local_port
-        end
-      end
+  # Runs a UDP server in the local IPv4 address, connects to it and sends a specific data.
+  # Timeout in 2 seconds.
+  def test_ipv4_udp_local_server
+    omit_if(!Test::Unit::TestCase.public_ipv4?)
 
-      assert_equal "ipv4/udp", @@received_data
-    end
+    @@received_data = nil
+    @local_port = next_port
+    setup_timeout(2)
 
-    # Try to connect via TCP to an invalid IPv4. EM.connect should raise
-    # EM::ConnectionError.
-    def test_tcp_connect_to_invalid_ipv4
-      invalid_ipv4 = "9.9:9"
-
-      EM.run do
-        begin
-          error = nil
-          EM.connect(invalid_ipv4, 1234)
-        rescue => e
-          error = e
-        ensure
+    EM.run do
+      EM::open_datagram_socket(@@public_ipv4, @local_port) do |s|
+        def s.receive_data data
+          @@received_data = data
           EM.stop
-          assert_equal EM::ConnectionError, (error && error.class)
         end
       end
+
+      EM::open_datagram_socket(@@public_ipv4, next_port) do |c|
+        c.send_datagram "ipv4/udp", @@public_ipv4, @local_port
+      end
     end
 
-    # Try to send a UDP datagram to an invalid IPv4. EM.send_datagram should raise
-    # EM::ConnectionError.
-    def test_udp_send_datagram_to_invalid_ipv4
-      invalid_ipv4 = "9.9:9"
-
-      EM.run do
-        begin
-          error = nil
-          EM.open_datagram_socket(@@public_ipv4, next_port) do |c|
-            c.send_datagram "hello", invalid_ipv4, 1234
-          end
-        rescue => e
-          error = e
-        ensure
-          EM.stop
-          assert_equal EM::ConnectionError, (error && error.class)
-        end
+    assert_equal "ipv4/udp", @@received_data
+  end
+
+  # Try to connect via TCP to an invalid IPv4. EM.connect should raise
+  # EM::ConnectionError.
+  def test_tcp_connect_to_invalid_ipv4
+    omit_if(!Test::Unit::TestCase.public_ipv4?)
+
+    invalid_ipv4 = "9.9:9"
+
+    EM.run do
+      begin
+        error = nil
+        EM.connect(invalid_ipv4, 1234)
+      rescue => e
+        error = e
+      ensure
+        EM.stop
+        assert_equal EM::ConnectionError, (error && error.class)
       end
     end
+  end
 
+  # Try to send a UDP datagram to an invalid IPv4. EM.send_datagram should raise
+  # EM::ConnectionError.
+  def test_udp_send_datagram_to_invalid_ipv4
+    omit_if(!Test::Unit::TestCase.public_ipv4?)
 
-  else
-    warn "no IPv4 in this host, skipping tests in #{__FILE__}"
+    invalid_ipv4 = "9.9:9"
 
-    # Because some rubies will complain if a TestCase class has no tests
-    def test_ipv4_unavailable
-      assert true
+    EM.run do
+      begin
+        error = nil
+        EM.open_datagram_socket(@@public_ipv4, next_port) do |c|
+          c.send_datagram "hello", invalid_ipv4, 1234
+        end
+      rescue => e
+        error = e
+      ensure
+        EM.stop
+        assert_equal EM::ConnectionError, (error && error.class)
+      end
     end
-
   end
-
 end

data/tests/test_ipv6.rb

@@ -4,32 +4,6 @@ class TestIPv6 < Test::Unit::TestCase
 
   if Test::Unit::TestCase.public_ipv6?
 
-    # Tries to connect to ipv6.google.com (2607:f8b0:4010:800::1006) port 80 via TCP.
-    # Timeout in 6 seconds.
-    def test_ipv6_tcp_client_with_ipv6_google_com
-      conn = nil
-      setup_timeout(6)
-
-      EM.run do
-        conn = EM::connect("2607:f8b0:4010:800::1006", 80) do |c|
-          def c.connected
-            @connected
-          end
-
-          def c.unbind(reason)
-            warn "unbind: #{reason.inspect}" if reason # XXX at least find out why it failed
-          end
-
-          def c.connection_completed
-            @connected = true
-            EM.stop
-          end
-        end
-      end
-
-      assert conn.connected
-    end
-
     # Runs a TCP server in the local IPv6 address, connects to it and sends a specific data.
     # Timeout in 2 seconds.
     def test_ipv6_tcp_local_server

data/tests/test_iterator.rb

@@ -2,8 +2,12 @@ require 'em_test_helper'
 
 class TestIterator < Test::Unit::TestCase
 
-  def get_time
-    EM.current_time.strftime('%H:%M:%S')
+  # By default, format the time with tenths-of-seconds.
+  # Some tests should ask for extra decimal places to ensure
+  # that delays between iterations will receive a changed time.
+  def get_time(n=1)
+    time = EM.current_time
+    time.strftime('%H:%M:%S.') + time.tv_usec.to_s[0, n]
   end
 
   def test_default_concurrency
@@ -11,10 +15,10 @@ class TestIterator < Test::Unit::TestCase
     list = 1..10
     EM.run {
       EM::Iterator.new(list).each( proc {|num,iter|
-        time = get_time
+        time = get_time(3)
         items[time] ||= []
         items[time] << num
-        EM::Timer.new(1) {iter.next}
+        EM::Timer.new(0.02) {iter.next}
       }, proc {EM.stop})
     }
     assert_equal(10, items.keys.size)
@@ -27,10 +31,10 @@ class TestIterator < Test::Unit::TestCase
     original_list = list.dup
     EM.run {
       EM::Iterator.new(proc{list.pop || EM::Iterator::Stop}).each( proc {|num,iter|
-        time = get_time
+        time = get_time(3)
         items[time] ||= []
         items[time] << num
-        EM::Timer.new(1) {iter.next}
+        EM::Timer.new(0.02) {iter.next}
       }, proc {EM.stop})
     }
     assert_equal(10, items.keys.size)
@@ -52,26 +56,25 @@ class TestIterator < Test::Unit::TestCase
     assert_equal(list.to_a.sort, items.values.flatten.sort)
   end
 
-
   def test_changing_concurrency_affects_active_iteration
     items = {}
     list = 1..25
+    seen = 0
     EM.run {
-      i = EM::Iterator.new(list,5)
+      i = EM::Iterator.new(list,1)
       i.each(proc {|num,iter|
         time = get_time
         items[time] ||= []
         items[time] << num
-        EM::Timer.new(1) {iter.next}
+        if (seen += 1) == 5
+          # The first 5 items will be distinct times
+          # The next 20 items will happen in 2 bursts
+          i.concurrency = 10
+        end
+        EM::Timer.new(0.2) {iter.next}
       }, proc {EM.stop})
-      EM.add_timer(1){
-        i.concurrency = 1
-      }
-      EM.add_timer(3){
-        i.concurrency = 3
-      }
     }
-    assert_equal(9, items.keys.size)
+    assert_in_delta(7, items.keys.size, 1)
     assert_equal(list.to_a.sort, items.values.flatten.sort)
   end
 

data/tests/test_ltp.rb

@@ -2,7 +2,14 @@ require 'em_test_helper'
 
 class TestLineAndTextProtocol < Test::Unit::TestCase
 
-  class SimpleLineTest < EM::P::LineAndTextProtocol
+  class TLP_LineBuffer < EM::P::LineAndTextProtocol
+    attr_reader :line_buffer
+
+    def initialize
+      super
+      @line_buffer = []
+    end
+
     def receive_line line
       @line_buffer << line
     end
@@ -27,10 +34,10 @@ class TestLineAndTextProtocol < Test::Unit::TestCase
   end
 
   def test_simple_lines
-    lines_received = []
+    conn = nil
     EM.run {
-      EM.start_server( "127.0.0.1", @port, SimpleLineTest ) do |conn|
-        conn.instance_eval "@line_buffer = lines_received"
+      EM.start_server( "127.0.0.1", @port, TLP_LineBuffer ) do |c|
+        conn = c
       end
       setup_timeout
 
@@ -39,25 +46,35 @@ class TestLineAndTextProtocol < Test::Unit::TestCase
         c.close_connection_after_writing
       end
     }
-    assert_equal( %w(aaa bbb ccc), lines_received )
+    assert_equal( %w(aaa bbb ccc), conn.line_buffer)
   end
 
   #--------------------------------------------------------------------
 
-  class SimpleLineTest < EM::P::LineAndTextProtocol
+  class TLP_ErrorMessage < EM::P::LineAndTextProtocol
+    attr_reader :error_message
+
+    def initialize
+      super
+      @error_message = []
+    end
+
+    def receive_line text
+      raise
+    end
+
     def receive_error text
       @error_message << text
     end
   end
 
   def test_overlength_lines
-    lines_received = []
+    conn = nil
     EM.run {
-      EM.start_server( "127.0.0.1", @port, SimpleLineTest ) do |conn|
-        conn.instance_eval "@error_message = lines_received"
+      EM.start_server( "127.0.0.1", @port, TLP_ErrorMessage ) do |c|
+        conn = c
       end
       setup_timeout
-
       EM.connect "127.0.0.1", @port, StopClient do |c|
         c.send_data "a" * (16*1024 + 1)
         c.send_data "\n"
@@ -65,7 +82,7 @@ class TestLineAndTextProtocol < Test::Unit::TestCase
       end
 
     }
-    assert_equal( ["overlength line"], lines_received )
+    assert_equal( ["overlength line"], conn.error_message )
   end
 
 

data/tests/test_pending_connect_timeout.rb

@@ -25,7 +25,7 @@ class TestPendingConnectTimeout < Test::Unit::TestCase
 
       timeout_handler = Module.new do
         define_method :unbind do
-          finish = Time.now
+          finish = EM.current_time
           EM.stop
         end
       end
@@ -33,8 +33,8 @@ class TestPendingConnectTimeout < Test::Unit::TestCase
       EM.run {
         setup_timeout
         EM.heartbeat_interval = 0.1
-        start = Time.now
-        c = EM.connect("1.2.3.4", 54321, timeout_handler)
+        start = EM.current_time
+        c = EM.connect('192.0.2.0', 54321, timeout_handler)
         c.pending_connect_timeout = 0.2
       }