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

data/tests/test_attach.rb

@@ -1,101 +1,126 @@
-# $Id$
-#
-#----------------------------------------------------------------------------
-#
-# 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 'socket'
-require 'test/unit'
-
-
-class TestAttach < Test::Unit::TestCase
-
-  Host = "127.0.0.1"
-  Port = 9550
-
-  class EchoServer < EM::Connection
-    def receive_data data
-      send_data data
-    end
-  end
-
-  class EchoClient < EM::Connection
-    def initialize
-      $sock.write("abc\n")
-    end
-
-    def notify_readable
-      $read = $sock.readline
-      $fd = detach
-    end
-
-    def unbind
-      EM.next_tick do
-        $sock.write("def\n")
-        EM.add_timer(0.5){ EM.stop }
-      end
-    end
-  end
-
-  def test_attach
-    EM.run{
-      EM.start_server Host, Port, EchoServer
-      $sock = TCPSocket.new Host, Port
-      EM.attach $sock, EchoClient
-    }
-
-    assert_equal $read, "abc\n"
-    assert_equal $fd, $sock.fileno
-    assert_equal false, $sock.closed?
-    assert_equal $sock.readline, "def\n"
-  end
-
-
-  module PipeWatch
-    def notify_readable
-      $read = $r.readline
-      EM.stop
-    end
-  end
-
-  def test_attach_pipe
-    EM.run{
-      $r, $w = IO.pipe
-      EM.attach $r, PipeWatch
-      $w.write("ghi\n")
-    }
-
-    assert_equal $read, "ghi\n"
-  end
-
-  module PipeReader
-    def receive_data data
-      $read = data
-      EM.stop
-    end
-  end
-
-  def test_read_write_pipe
-    EM.run{
-      $r, $w = IO.pipe
-      EM.attach $r, PipeReader
-      writer = EM.attach($w)
-      writer.send_data 'ghi'
-    }
-
-    assert_equal $read, "ghi"
-  end
+# $Id$
+#
+#----------------------------------------------------------------------------
+#
+# 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 'socket'
+require 'test/unit'
+
+
+class TestAttach < Test::Unit::TestCase
+
+  Host = "127.0.0.1"
+  Port = 9550
+
+  class EchoServer < EM::Connection
+    def receive_data data
+      send_data data
+    end
+  end
+
+  class EchoClient < EM::Connection
+    def initialize
+      self.notify_readable = true
+      $sock.write("abc\n")
+    end
+
+    def notify_readable
+      $read = $sock.readline
+      $fd = detach
+    end
+
+    def unbind
+      EM.next_tick do
+        $sock.write("def\n")
+        EM.add_timer(0.5){ EM.stop }
+      end
+    end
+  end
+
+  def test_attach
+    EM.run{
+      EM.start_server Host, Port, EchoServer
+      $sock = TCPSocket.new Host, Port
+      EM.watch $sock, EchoClient
+    }
+
+    assert_equal $read, "abc\n"
+    unless defined? JRuby # jruby filenos are not real
+      assert_equal $fd, $sock.fileno
+    end
+    assert_equal false, $sock.closed?
+    assert_equal $sock.readline, "def\n"
+  end
+
+  module PipeWatch
+    def notify_readable
+      $read = $r.readline
+      EM.stop
+    end
+  end
+
+  def test_attach_pipe
+    EM.run{
+      $r, $w = IO.pipe
+      EM.watch $r, PipeWatch do |c|
+        c.notify_readable = true
+      end
+      $w.write("ghi\n")
+    }
+
+    assert_equal $read, "ghi\n"
+  end
+
+  def test_set_readable
+    EM.run{
+      $r, $w = IO.pipe
+      c = EM.watch $r, PipeWatch do |c|
+        c.notify_readable = false
+      end
+
+      EM.next_tick{
+        $before = c.notify_readable?
+        c.notify_readable = true
+        $after = c.notify_readable?
+      }
+
+      $w.write("jkl\n")
+    }
+
+    assert !$before
+    assert $after
+    assert_equal $read, "jkl\n"
+  end
+
+  module PipeReader
+    def receive_data data
+      $read = data
+      EM.stop
+    end
+  end
+
+  def test_read_write_pipe
+    EM.run{
+      $r, $w = IO.pipe
+      EM.attach $r, PipeReader
+      writer = EM.attach($w)
+      writer.send_data 'ghi'
+    }
+
+    assert_equal $read, "ghi"
+  end
 end

data/tests/test_basic.rb

@@ -266,8 +266,7 @@ class TestBasic < Test::Unit::TestCase
     x = false
     assert !x
     EM.run do
-      Thread.new { EM.schedule { x = true } }.join
-      EM.stop
+      Thread.new { EM.schedule { x = true; EM.stop } }.join
     end
     assert x
   end

data/tests/test_connection_count.rb

@@ -1,45 +1,35 @@
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
-
-class TestConnectionCount < Test::Unit::TestCase
-  def test_idle_connection_count
-    EM.run {
-      $count = EM.connection_count
-      EM.stop_event_loop
-    }
-
-    assert_equal(0, $count)
-  end
-
-  module Client
-    def connection_completed
-      EM.next_tick{
-        $client_connected = EM.connection_count
-        EM.stop
-      }
-    end
-  end
-
-  module Server
-    def post_init
-      $server_connected = EM.connection_count
-    end
-  end
-
-  def test_with_some_connections
-    EM.run {
-      $initial = EM.connection_count
-      EM.start_server("127.0.0.1", 9999, Server)
-      $server_started = EM.connection_count
-      EM.next_tick{
-        EM.connect("127.0.0.1", 9999, Client)
-      }
-    }
-
-    assert_equal(0, $initial)
-    assert_equal(1, $server_started)
-    assert_equal(2, $server_connected)
-    assert_equal(3, $client_connected)
-  end
+$:.unshift "../lib"
+require 'eventmachine'
+require 'test/unit'
+
+class TestConnectionCount < Test::Unit::TestCase
+  def test_idle_connection_count
+    EM.run {
+      $count = EM.connection_count
+      EM.stop_event_loop
+    }
+
+    assert_equal(0, $count)
+  end
+
+  module Client
+    def connection_completed
+      $client_conns += 1
+      EM.stop if $client_conns == 3
+    end
+  end
+
+  def test_with_some_connections
+    EM.run {
+      $client_conns = 0
+      $initial_conns = EM.connection_count
+      EM.start_server("127.0.0.1", 9999)
+      $server_conns = EM.connection_count
+      3.times { EM.connect("127.0.0.1", 9999, Client) }
+    }
+
+    assert_equal(0, $initial_conns)
+    assert_equal(1, $server_conns)
+    assert_equal(4, $client_conns + $server_conns)
+  end
 end

data/tests/test_epoll.rb

@@ -94,7 +94,6 @@ class TestEpoll < Test::Unit::TestCase
     n = 0
     work_proc = proc {n += 1}
     callback_proc = proc {EM.stop}
-    EM.epoll
     EM.run {
       EM.defer work_proc, callback_proc
     }
@@ -120,7 +119,6 @@ class TestEpoll < Test::Unit::TestCase
 
   def test_datagrams
     $in = $out = ""
-    EM.epoll
     EM.run {
       EM.open_datagram_socket "127.0.0.1", 9500, TestDatagramServer
       EM.open_datagram_socket "127.0.0.1", 0, TestDatagramClient

data/tests/test_get_sock_opt.rb

@@ -0,0 +1,30 @@
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../lib")
+require 'eventmachine'
+require 'socket'
+require 'test/unit'
+
+class TestGetSockOpt < Test::Unit::TestCase
+
+  def setup
+    assert(!EM.reactor_running?)
+  end
+
+  def teardown
+    assert(!EM.reactor_running?)
+  end
+
+  #-------------------------------------
+
+  def test_get_sock_opt
+    test = self
+    EM.run do
+      EM.connect 'google.com', 80, Module.new {
+        define_method :connection_completed do
+          val = get_sock_opt Socket::SOL_SOCKET, Socket::SO_ERROR
+          test.assert_equal "\0\0\0\0", val
+          EM.stop
+        end
+      }
+    end
+  end
+end

data/tests/test_httpclient2.rb

@@ -80,7 +80,7 @@ class TestHttpClient2 < Test::Unit::TestCase
   def test_get
     content = nil
     EM.run {
-      http = EM::P::HttpClient2.connect "www.bayshorenetworks.com", 80
+      http = EM::P::HttpClient2.connect "google.com", 80
       d = http.get "/"
       d.callback {
         content = d.content
@@ -96,7 +96,7 @@ class TestHttpClient2 < Test::Unit::TestCase
   def _test_get_multiple
     content = nil
     EM.run {
-      http = EM::P::HttpClient2.connect "www.bayshorenetworks.com", 80
+      http = EM::P::HttpClient2.connect "google.com", 80
       d = http.get "/"
       d.callback {
         e = http.get "/"
@@ -112,7 +112,7 @@ class TestHttpClient2 < Test::Unit::TestCase
   def test_get_pipeline
     headers, headers2 = nil, nil
     EM.run {
-      http = EM::P::HttpClient2.connect "www.microsoft.com", 80
+      http = EM::P::HttpClient2.connect "google.com", 80
       d = http.get("/")
       d.callback {
         headers = d.headers

data/tests/test_inactivity_timeout.rb

@@ -15,7 +15,7 @@ class TestInactivityTimeout < Test::Unit::TestCase
     assert_equal(0.0, $timeout)
   end
 
-  def test_with_set
+  def test_set_and_get
     $timeout = nil
     EM.run {
       c = EM.connect("127.0.0.1", 54321)
@@ -27,4 +27,24 @@ class TestInactivityTimeout < Test::Unit::TestCase
     assert_equal(2.5, $timeout)
   end
 
+  module TimeoutHandler
+    def unbind
+      EM.stop
+    end
+  end
+
+  def test_for_real
+    EM.run {
+      EM.heartbeat_interval = 0.1
+      EM.start_server("127.0.0.1", 12345)
+      EM.add_timer(0.2) {
+        $start = Time.now
+        c = EM.connect("127.0.0.1", 12345, TimeoutHandler)
+        c.comm_inactivity_timeout = 2.5
+      }
+    }
+
+    assert_in_delta(2.5, (Time.now - $start), 0.3)
+  end
+
 end

data/tests/test_ltp.rb

@@ -1,188 +1,182 @@
-# $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 'eventmachine'
-require 'test/unit'
-
-class TestLineAndTextProtocol < Test::Unit::TestCase
-
-  TestHost = "127.0.0.1"
-  TestPort = 8905
-
-
-  #--------------------------------------------------------------------
-
-  class SimpleLineTest < EventMachine::Protocols::LineAndTextProtocol
-    def receive_line line
-      @line_buffer << line
-    end
-  end
-
-  module StopClient
-    def set_receive_data(&blk)
-      @rdb = blk
-    end
-    
-    def receive_data data
-      @rdb.call(data) if @rdb
-    end
-    
-    def unbind
-      EM.add_timer(0.1) { EM.stop }
-    end
-  end
-
-
-  def test_simple_lines
-    # THIS TEST CURRENTLY FAILS IN JRUBY.
-    assert( RUBY_PLATFORM !~ /java/ )
-
-    lines_received = []
-    EventMachine.run {
-      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")}
-
-      EventMachine.connect TestHost, TestPort, StopClient do |c|
-        c.send_data "aaa\nbbb\r\nccc\n"
-        c.close_connection_after_writing
-      end
-    }
-    assert_equal( %w(aaa bbb ccc), lines_received )
-  end
-
-  #--------------------------------------------------------------------
-
-  class SimpleLineTest < EventMachine::Protocols::LineAndTextProtocol
-    def receive_error text
-      @error_message << text
-    end
-  end
-
-  def test_overlength_lines
-    # THIS TEST CURRENTLY FAILS IN JRUBY.
-    assert( RUBY_PLATFORM !~ /java/ )
-
-    lines_received = []
-    EventMachine.run {
-      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")}
-
-      EventMachine.connect TestHost, TestPort, StopClient do |c|
-        c.send_data "a" * (16*1024 + 1)
-        c.send_data "\n"
-        c.close_connection_after_writing
-      end
-
-    }
-    assert_equal( ["overlength line"], lines_received )
-  end
-
-
-  #--------------------------------------------------------------------
-
-  class LineAndTextTest < EventMachine::Protocols::LineAndTextProtocol
-    def post_init
-    end
-    def receive_line line
-      if line =~ /content-length:\s*(\d+)/i
-        @content_length = $1.to_i
-      elsif line.length == 0
-        set_binary_mode @content_length
-      end
-    end
-    def receive_binary_data text
-      send_data "received #{text.length} bytes"
-      close_connection_after_writing
-    end
-  end
-
-  def test_lines_and_text
-    output = ''
-    lines_received = []
-    text_received = []
-    EventMachine.run {
-      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")}
-
-      EventMachine.connect TestHost, TestPort, StopClient do |c|
-        c.set_receive_data { |data| output << data }
-        c.send_data "Content-length: 400\n"
-        c.send_data "\n"
-        c.send_data "A" * 400
-        EM.add_timer(0.1) { c.close_connection_after_writing }
-      end
-    }
-    assert_equal( "received 400 bytes", output )
-  end
-
-  #--------------------------------------------------------------------
-
-
-  class BinaryTextTest < EventMachine::Protocols::LineAndTextProtocol
-    def post_init
-    end
-    def receive_line line
-      if line =~ /content-length:\s*(\d+)/i
-        set_binary_mode $1.to_i
-      else
-        raise "protocol error"
-      end
-    end
-    def receive_binary_data text
-      send_data "received #{text.length} bytes"
-      close_connection_after_writing
-    end
-  end
-
-  def test_binary_text
-    output = ''
-    lines_received = []
-    text_received = []
-    EventMachine.run {
-      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")}
-
-      EventMachine.connect TestHost, TestPort, StopClient do |c|
-        c.set_receive_data { |data| output << data }
-        c.send_data "Content-length: 10000\n"
-        c.send_data "A" * 10000
-        EM.add_timer(0.2) { c.close_connection_after_writing }
-      end
-    }
-    assert_equal( "received 10000 bytes", output )
-  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.
+#
+#---------------------------------------------------------------------------
+#
+#
+#
+#
+
+require 'eventmachine'
+require 'test/unit'
+
+class TestLineAndTextProtocol < Test::Unit::TestCase
+
+  TestHost = "127.0.0.1"
+  TestPort = 8905
+
+
+  #--------------------------------------------------------------------
+
+  class SimpleLineTest < EventMachine::Protocols::LineAndTextProtocol
+    def receive_line line
+      @line_buffer << line
+    end
+  end
+
+  module StopClient
+    def set_receive_data(&blk)
+      @rdb = blk
+    end
+    
+    def receive_data data
+      @rdb.call(data) if @rdb
+    end
+    
+    def unbind
+      EM.add_timer(0.1) { EM.stop }
+    end
+  end
+
+
+  def test_simple_lines
+    lines_received = []
+    EventMachine.run {
+      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")}
+
+      EventMachine.connect TestHost, TestPort, StopClient do |c|
+        c.send_data "aaa\nbbb\r\nccc\n"
+        c.close_connection_after_writing
+      end
+    }
+    assert_equal( %w(aaa bbb ccc), lines_received )
+  end
+
+  #--------------------------------------------------------------------
+
+  class SimpleLineTest < EventMachine::Protocols::LineAndTextProtocol
+    def receive_error text
+      @error_message << text
+    end
+  end
+
+  def test_overlength_lines
+    lines_received = []
+    EventMachine.run {
+      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")}
+
+      EventMachine.connect TestHost, TestPort, StopClient do |c|
+        c.send_data "a" * (16*1024 + 1)
+        c.send_data "\n"
+        c.close_connection_after_writing
+      end
+
+    }
+    assert_equal( ["overlength line"], lines_received )
+  end
+
+
+  #--------------------------------------------------------------------
+
+  class LineAndTextTest < EventMachine::Protocols::LineAndTextProtocol
+    def post_init
+    end
+    def receive_line line
+      if line =~ /content-length:\s*(\d+)/i
+        @content_length = $1.to_i
+      elsif line.length == 0
+        set_binary_mode @content_length
+      end
+    end
+    def receive_binary_data text
+      send_data "received #{text.length} bytes"
+      close_connection_after_writing
+    end
+  end
+
+  def test_lines_and_text
+    output = ''
+    lines_received = []
+    text_received = []
+    EventMachine.run {
+      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")}
+
+      EventMachine.connect TestHost, TestPort, StopClient do |c|
+        c.set_receive_data { |data| output << data }
+        c.send_data "Content-length: 400\n"
+        c.send_data "\n"
+        c.send_data "A" * 400
+        EM.add_timer(0.1) { c.close_connection_after_writing }
+      end
+    }
+    assert_equal( "received 400 bytes", output )
+  end
+
+  #--------------------------------------------------------------------
+
+
+  class BinaryTextTest < EventMachine::Protocols::LineAndTextProtocol
+    def post_init
+    end
+    def receive_line line
+      if line =~ /content-length:\s*(\d+)/i
+        set_binary_mode $1.to_i
+      else
+        raise "protocol error"
+      end
+    end
+    def receive_binary_data text
+      send_data "received #{text.length} bytes"
+      close_connection_after_writing
+    end
+  end
+
+  def test_binary_text
+    output = ''
+    lines_received = []
+    text_received = []
+    EventMachine.run {
+      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")}
+
+      EventMachine.connect TestHost, TestPort, StopClient do |c|
+        c.set_receive_data { |data| output << data }
+        c.send_data "Content-length: 10000\n"
+        c.send_data "A" * 10000
+        EM.add_timer(0.2) { c.close_connection_after_writing }
+      end
+    }
+    assert_equal( "received 10000 bytes", output )
+  end
+
+  #--------------------------------------------------------------------
+end