eventmachine 1.0.0.beta.2-x86-mingw32 → 1.0.0.beta.3-x86-mingw32

data/tests/test_httpclient.rb

@@ -1,32 +1,4 @@
-# $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'
+require 'em_test_helper'
 
 class TestHttpClient < Test::Unit::TestCase
 
@@ -43,13 +15,13 @@ class TestHttpClient < Test::Unit::TestCase
 
   def test_http_client
     ok = false
-    EventMachine.run {
-      c = EventMachine::Protocols::HttpClient.send :request, :host => "www.google.com", :port => 80
+    EM.run {
+      c = EM::P::HttpClient.send :request, :host => "www.google.com", :port => 80
       c.callback {
         ok = true
-        EventMachine.stop
+        EM.stop
       }
-      c.errback {EventMachine.stop} # necessary, otherwise a failure blocks the test suite forever.
+      c.errback {EM.stop} # necessary, otherwise a failure blocks the test suite forever.
     }
     assert ok
   end
@@ -58,10 +30,10 @@ class TestHttpClient < Test::Unit::TestCase
 
   def test_http_client_1
     ok = false
-    EventMachine.run {
-      c = EventMachine::Protocols::HttpClient.send :request, :host => "www.google.com", :port => 80
-      c.callback {ok = true; EventMachine.stop}
-      c.errback {EventMachine.stop}
+    EM.run {
+      c = EM::P::HttpClient.send :request, :host => "www.google.com", :port => 80
+      c.callback {ok = true; EM.stop}
+      c.errback {EM.stop}
     }
     assert ok
   end
@@ -70,13 +42,13 @@ class TestHttpClient < Test::Unit::TestCase
 
   def test_http_client_2
     ok = false
-    EventMachine.run {
-      c = EventMachine::Protocols::HttpClient.send :request, :host => "www.google.com", :port => 80
+    EM.run {
+      c = EM::P::HttpClient.send :request, :host => "www.google.com", :port => 80
       c.callback {|result|
         ok = true;
-        EventMachine.stop
+        EM.stop
       }
-      c.errback {EventMachine.stop}
+      c.errback {EM.stop}
     }
     assert ok
   end
@@ -89,7 +61,7 @@ class TestHttpClient < Test::Unit::TestCase
   # causing this test to hang. Observe, there was no problem with responses
   # lacking a content-length, just when the content-length was zero.
   #
-  class EmptyContent < EventMachine::Connection
+  class EmptyContent < EM::Connection
       def initialize *args
         super
       end
@@ -101,12 +73,12 @@ class TestHttpClient < Test::Unit::TestCase
 
   def test_http_empty_content
       ok = false
-      EventMachine.run {
-        EventMachine.start_server "127.0.0.1", 9701, EmptyContent
-        c = EventMachine::Protocols::HttpClient.send :request, :host => "127.0.0.1", :port => 9701
+      EM.run {
+        EM.start_server "127.0.0.1", 9701, EmptyContent
+        c = EM::P::HttpClient.send :request, :host => "127.0.0.1", :port => 9701
         c.callback {|result|
           ok = true
-          EventMachine.stop
+          EM.stop
         }
       }
       assert ok
@@ -115,7 +87,7 @@ class TestHttpClient < Test::Unit::TestCase
 
   #---------------------------------------
 
-  class PostContent < EventMachine::Protocols::LineAndTextProtocol
+  class PostContent < EM::P::LineAndTextProtocol
       def initialize *args
         super
         @lines = []
@@ -155,23 +127,14 @@ class TestHttpClient < Test::Unit::TestCase
       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
   def test_post
       response = nil
-      EventMachine.run {
-        EventMachine.start_server Localhost, Localport, PostContent
+      EM.run {
+        EM.start_server Localhost, Localport, PostContent
         setup_timeout(2)
-        c = EventMachine::Protocols::HttpClient.request(
+        c = EM::P::HttpClient.request(
           :host=>Localhost,
           :port=>Localport,
           :method=>:post,
@@ -181,7 +144,7 @@ class TestHttpClient < Test::Unit::TestCase
         )
         c.callback {|r|
           response = r
-          EventMachine.stop
+          EM.stop
         }
       }
 
@@ -198,9 +161,9 @@ class TestHttpClient < Test::Unit::TestCase
       c = EM::Protocols::HttpClient.send :request, :host => "www.google.com", :port => 80, :cookie=>"aaa=bbb"
       c.callback {|result|
         ok = true;
-        EventMachine.stop
+        EM.stop
       }
-      c.errback {EventMachine.stop}
+      c.errback {EM.stop}
     }
     assert ok
   end
@@ -217,9 +180,9 @@ class TestHttpClient < Test::Unit::TestCase
       )
       c.callback {|result|
         ok = true;
-        EventMachine.stop
+        EM.stop
       }
-      c.errback {EventMachine.stop}
+      c.errback {EM.stop}
     }
     assert ok
   end

data/tests/test_httpclient2.rb

@@ -1,32 +1,4 @@
-# $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'
+require 'em_test_helper'
 
 class TestHttpClient2 < Test::Unit::TestCase
   Localhost = "127.0.0.1"

data/tests/test_inactivity_timeout.rb

@@ -1,50 +1,54 @@
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
+require 'em_test_helper'
 
 class TestInactivityTimeout < Test::Unit::TestCase
 
-  def test_default
-    $timeout = nil
-    EM.run {
-      c = EM.connect("127.0.0.1", 54321)
-      $timeout = c.comm_inactivity_timeout
-      EM.stop
-    }
-
-    assert_equal(0.0, $timeout)
-  end
-
-  def test_set_and_get
-    $timeout = nil
-    EM.run {
-      c = EM.connect("127.0.0.1", 54321)
-      c.comm_inactivity_timeout = 2.5
-      $timeout = c.comm_inactivity_timeout
-      EM.stop
-    }
-
-    assert_equal(2.5, $timeout)
-  end
+  if EM.respond_to? :get_comm_inactivity_timeout
+    def test_default
+      EM.run {
+        c = EM.connect("127.0.0.1", 54321)
+        assert_equal 0.0, c.comm_inactivity_timeout
+        EM.stop
+      }
+    end
 
-  module TimeoutHandler
-    def unbind
-      EM.stop
+    def test_set_and_get
+      EM.run {
+        c = EM.connect("127.0.0.1", 54321)
+        c.comm_inactivity_timeout = 2.5
+        assert_equal 2.5, c.comm_inactivity_timeout
+        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.1) {
-        $start = Time.now
-        c = EM.connect("127.0.0.1", 12345, TimeoutHandler)
-        c.comm_inactivity_timeout = 0.2
+    def test_for_real
+      start, finish = nil
+
+      timeout_handler = Module.new do
+        define_method :unbind do
+          finish = Time.now
+          EM.stop
+        end
+      end
+
+      EM.run {
+        setup_timeout
+        EM.heartbeat_interval = 0.01
+        EM.start_server("127.0.0.1", 12345)
+        EM.add_timer(0.01) {
+          start = Time.now
+          c = EM.connect("127.0.0.1", 12345, timeout_handler)
+          c.comm_inactivity_timeout = 0.02
+        }
       }
-    }
 
-    assert_in_delta(0.2, (Time.now - $start), 0.1)
-  end
+      assert_in_delta(0.02, (finish - start), 0.02)
+    end
+  else
+    warn "EM.comm_inactivity_timeout not implemented, skipping tests in #{__FILE__}"
 
+    # Because some rubies will complain if a TestCase class has no tests
+    def test_em_comm_inactivity_timeout_not_implemented
+      assert true
+    end
+  end
 end

data/tests/test_kb.rb

@@ -1,60 +1,34 @@
-# $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'
+require 'em_test_helper'
 
 class TestKeyboardEvents < Test::Unit::TestCase
 
-  def setup
-  end
-
-  def teardown
-  end
+  if !jruby?
+    module KbHandler
+      include EM::Protocols::LineText2
+      def receive_line d
+        EM::stop if d == "STOP"
+      end
+    end
 
-  module KbHandler
-    include EM::Protocols::LineText2
-    def receive_line d
-      EM::stop if d == "STOP"
+    # This test doesn't actually do anything useful but is here to
+    # illustrate the usage. If you removed the timer and ran this test
+    # by itself on a console, and then typed into the console, it would
+    # work.
+    # I don't know how to get the test harness to simulate actual keystrokes.
+    # When someone figures that out, then we can make this a real test.
+    #
+    def test_kb
+      EM.run {
+        EM.open_keyboard KbHandler
+        EM::Timer.new(1) { EM.stop }
+      } if $stdout.tty? # don't run the test unless it stands a chance of validity.
     end
-  end
+  else
+    warn "EM.open_keyboard not implemented, skipping tests in #{__FILE__}"
 
-  # This test doesn't actually do anything useful but is here to
-  # illustrate the usage. If you removed the timer and ran this test
-  # by itself on a console, and then typed into the console, it would
-  # work.
-  # I don't know how to get the test harness to simulate actual keystrokes.
-  # When someone figures that out, then we can make this a real test.
-  #
-  def test_kb
-    EM.run {
-      EM.open_keyboard KbHandler
-      EM::Timer.new(1) { EM.stop }
-    } if $stdout.tty? # don't run the test unless it stands a chance of validity.
+    # Because some rubies will complain if a TestCase class has no tests
+    def test_em_open_keyboard_unsupported
+      assert true
+    end
   end
-
 end

data/tests/test_ltp.rb

@@ -1,42 +1,8 @@
-# $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'
+require 'em_test_helper'
 
 class TestLineAndTextProtocol < Test::Unit::TestCase
 
-  TestHost = "127.0.0.1"
-  TestPort = 8905
-
-
-  #--------------------------------------------------------------------
-
-  class SimpleLineTest < EventMachine::Protocols::LineAndTextProtocol
+  class SimpleLineTest < EM::P::LineAndTextProtocol
     def receive_line line
       @line_buffer << line
     end
@@ -46,34 +12,29 @@ class TestLineAndTextProtocol < Test::Unit::TestCase
     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 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
-      }
-    }
+
+  def setup
+    @port = next_port
   end
 
   def test_simple_lines
     lines_received = []
-    EventMachine.run {
-      EventMachine.start_server( TestHost, TestPort, SimpleLineTest ) do |conn|
+    EM.run {
+      EM.start_server( "127.0.0.1", @port, SimpleLineTest ) do |conn|
         conn.instance_eval "@line_buffer = lines_received"
       end
       setup_timeout
 
-      EventMachine.connect TestHost, TestPort, StopClient do |c|
+      EM.connect "127.0.0.1", @port, StopClient do |c|
         c.send_data "aaa\nbbb\r\nccc\n"
         c.close_connection_after_writing
       end
@@ -83,7 +44,7 @@ class TestLineAndTextProtocol < Test::Unit::TestCase
 
   #--------------------------------------------------------------------
 
-  class SimpleLineTest < EventMachine::Protocols::LineAndTextProtocol
+  class SimpleLineTest < EM::P::LineAndTextProtocol
     def receive_error text
       @error_message << text
     end
@@ -91,13 +52,13 @@ class TestLineAndTextProtocol < Test::Unit::TestCase
 
   def test_overlength_lines
     lines_received = []
-    EventMachine.run {
-      EventMachine.start_server( TestHost, TestPort, SimpleLineTest ) do |conn|
+    EM.run {
+      EM.start_server( "127.0.0.1", @port, SimpleLineTest ) do |conn|
         conn.instance_eval "@error_message = lines_received"
       end
       setup_timeout
 
-      EventMachine.connect TestHost, TestPort, StopClient do |c|
+      EM.connect "127.0.0.1", @port, StopClient do |c|
         c.send_data "a" * (16*1024 + 1)
         c.send_data "\n"
         c.close_connection_after_writing
@@ -110,9 +71,7 @@ class TestLineAndTextProtocol < Test::Unit::TestCase
 
   #--------------------------------------------------------------------
 
-  class LineAndTextTest < EventMachine::Protocols::LineAndTextProtocol
-    def post_init
-    end
+  class LineAndTextTest < EM::P::LineAndTextProtocol
     def receive_line line
       if line =~ /content-length:\s*(\d+)/i
         @content_length = $1.to_i
@@ -130,13 +89,13 @@ class TestLineAndTextProtocol < Test::Unit::TestCase
     output = ''
     lines_received = []
     text_received = []
-    EventMachine.run {
-      EventMachine.start_server( TestHost, TestPort, LineAndTextTest ) do |conn|
+    EM.run {
+      EM.start_server( "127.0.0.1", @port, LineAndTextTest ) do |conn|
         conn.instance_eval "@lines = lines_received; @text = text_received"
       end
       setup_timeout
 
-      EventMachine.connect TestHost, TestPort, StopClient do |c|
+      EM.connect "127.0.0.1", @port, StopClient do |c|
         c.set_receive_data { |data| output << data }
         c.send_data "Content-length: 400\n"
         c.send_data "\n"
@@ -150,9 +109,7 @@ class TestLineAndTextProtocol < Test::Unit::TestCase
   #--------------------------------------------------------------------
 
 
-  class BinaryTextTest < EventMachine::Protocols::LineAndTextProtocol
-    def post_init
-    end
+  class BinaryTextTest < EM::P::LineAndTextProtocol
     def receive_line line
       if line =~ /content-length:\s*(\d+)/i
         set_binary_mode $1.to_i
@@ -170,21 +127,20 @@ class TestLineAndTextProtocol < Test::Unit::TestCase
     output = ''
     lines_received = []
     text_received = []
-    EventMachine.run {
-      EventMachine.start_server( TestHost, TestPort, BinaryTextTest ) do |conn|
+    EM.run {
+      EM.start_server( "127.0.0.1", @port, BinaryTextTest ) do |conn|
         conn.instance_eval "@lines = lines_received; @text = text_received"
       end
       setup_timeout
 
-      EventMachine.connect TestHost, TestPort, StopClient do |c|
+      EM.connect "127.0.0.1", @port, 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 }
+        EM.add_timer(0.1) { c.close_connection_after_writing }
       end
     }
     assert_equal( "received 10000 bytes", output )
   end
 
-  #--------------------------------------------------------------------
 end