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

data/tests/test_error_handler.rb

@@ -1,10 +1,13 @@
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
+require 'em_test_helper'
 
 class TestErrorHandler < Test::Unit::TestCase
+  def setup
+    @exception = Class.new(StandardError)
+  end
+
   def test_error_handler
     error = nil
+
     EM.error_handler{ |e|
       error = e
       EM.error_handler(nil)
@@ -14,20 +17,20 @@ class TestErrorHandler < Test::Unit::TestCase
     assert_nothing_raised do
       EM.run{
         EM.add_timer(0){
-          raise 'test'
+          raise @exception, 'test'
         }
       }
     end
 
-    assert_equal error.class, RuntimeError
+    assert_equal error.class, @exception
     assert_equal error.message, 'test'
   end
 
   def test_without_error_handler
-    assert_raise RuntimeError do
+    assert_raise @exception do
       EM.run{
         EM.add_timer(0){
-          raise 'test'
+          raise @exception, 'test'
         }
       }
     end

data/tests/test_exc.rb

@@ -1,44 +1,17 @@
-# $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 TestSomeExceptions < Test::Unit::TestCase
 
-  # Read the commentary in EventMachine#run.
+  # Read the commentary in EM#run.
   # This test exercises the ensure block in #run that makes sure
-  # EventMachine#release_machine gets called even if an exception is
+  # EM#release_machine gets called even if an exception is
   # thrown within the user code. Without the ensured call to release_machine,
-  # the second call to EventMachine#run will fail with a C++ exception
+  # the second call to EM#run will fail with a C++ exception
   # because the machine wasn't cleaned up properly.
 
   def test_a
     assert_raises(RuntimeError) {
-      EventMachine.run {
+      EM.run {
       raise "some exception"
     }
     }
@@ -46,7 +19,7 @@ class TestSomeExceptions < Test::Unit::TestCase
 
   def test_b
     assert_raises(RuntimeError) {
-      EventMachine.run {
+      EM.run {
       raise "some exception"
     }
     }

data/tests/test_file_watch.rb

@@ -1,49 +1,65 @@
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
+require 'em_test_helper'
+require 'tempfile'
 
 class TestFileWatch < Test::Unit::TestCase
-  module FileWatcher
-    def file_modified
-      $modified = true
+  if windows?
+    def test_watch_file_raises_unsupported_error
+      assert_raises(EM::Unsupported) do
+        EM.run do
+          file = Tempfile.new("fake_file")
+          EM.watch_file(file.path)
+        end
+      end
     end
-    def file_deleted
-      $deleted = true
+  elsif EM.respond_to? :watch_filename
+    module FileWatcher
+      def file_modified
+        $modified = true
+      end
+      def file_deleted
+        $deleted = true
+      end
+      def unbind
+        $unbind = true
+        EM.stop
+      end
     end
-    def unbind
-      $unbind = true
-      EM.stop
+
+    def setup
+      EM.kqueue = true if EM.kqueue?
     end
-  end
 
-  def setup
-    EM.kqueue = true if EM.kqueue?
-  end
+    def teardown
+      EM.kqueue = false if EM.kqueue?
+    end
 
-  def teardown
-    EM.kqueue = false if EM.kqueue?
-  end
+    def test_events
+      EM.run{
+        file = Tempfile.new('em-watch')
+        $tmp_path = file.path
 
-  def test_events
-    EM.run{
-      require 'tempfile'
-      file = Tempfile.new('em-watch')
-      $tmp_path = file.path
+        # watch it
+        watch = EM.watch_file(file.path, FileWatcher)
+        $path = watch.path
 
-      # watch it
-      watch = EM.watch_file(file.path, FileWatcher)
-      $path = watch.path
+        # modify it
+        File.open(file.path, 'w'){ |f| f.puts 'hi' }
 
-      # modify it
-      File.open(file.path, 'w'){ |f| f.puts 'hi' }
+        # delete it
+        EM.add_timer(0.01){ file.close; file.delete }
+      }
 
-      # delete it
-      EM.add_timer(0.01){ file.close; file.delete }
-    }
+      assert_equal($path, $tmp_path)
+      assert($modified)
+      assert($deleted)
+      assert($unbind)
+    end
+  else
+    warn "EM.watch_file not implemented, skipping tests in #{__FILE__}"
 
-    assert_equal($path, $tmp_path)
-    assert($modified)
-    assert($deleted)
-    assert($unbind)
+    # Because some rubies will complain if a TestCase class has no tests
+    def test_em_watch_file_unsupported
+      assert true
+    end
   end
 end

data/tests/test_futures.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 TestFutures < Test::Unit::TestCase
 
@@ -37,14 +9,14 @@ class TestFutures < Test::Unit::TestCase
   end
 
   def test_future
-      assert_equal(100, EventMachine::Deferrable.future(100) )
+      assert_equal(100, EM::Deferrable.future(100) )
 
       p1 = proc { 100 + 1 }
-      assert_equal(101, EventMachine::Deferrable.future(p1) )
+      assert_equal(101, EM::Deferrable.future(p1) )
   end
 
   class MyFuture
-      include EventMachine::Deferrable
+      include EM::Deferrable
       def initialize *args
         super
         set_deferred_status :succeeded, 40
@@ -52,7 +24,7 @@ class TestFutures < Test::Unit::TestCase
   end
 
   class MyErrorFuture
-      include EventMachine::Deferrable
+      include EM::Deferrable
       def initialize *args
         super
         set_deferred_status :failed, 41
@@ -67,7 +39,7 @@ class TestFutures < Test::Unit::TestCase
       end
 
       value = nil
-      EventMachine::Deferrable.future my_future, proc {|v| value=v}
+      EM::Deferrable.future my_future, proc {|v| value=v}
       assert_equal( 40, value )
   end
 
@@ -76,7 +48,7 @@ class TestFutures < Test::Unit::TestCase
       # Call future with two additional arguments and they will be treated as a callback
       # and an errback.
       value = nil
-      EventMachine::Deferrable.future MyErrorFuture.new, nil, proc {|v| value=v}
+      EM::Deferrable.future MyErrorFuture.new, nil, proc {|v| value=v}
       assert_equal( 41, value )
   end
 
@@ -85,7 +57,7 @@ class TestFutures < Test::Unit::TestCase
       # Call future with no additional arguments but with a block, and the block will be
       # treated as a callback.
       value = nil
-      EventMachine::Deferrable.future MyFuture.new do |v|
+      EM::Deferrable.future MyFuture.new do |v|
         value=v
       end
       assert_equal( 40, value )
@@ -93,7 +65,7 @@ class TestFutures < Test::Unit::TestCase
 
 
   class RecursiveCallback
-      include EventMachine::Deferrable
+      include EM::Deferrable
   end
 
   # A Deferrable callback can call #set_deferred_status to change the values

data/tests/test_get_sock_opt.rb

@@ -1,30 +1,37 @@
-$:.unshift File.expand_path(File.dirname(__FILE__) + "/../lib")
-require 'eventmachine'
+require 'em_test_helper'
 require 'socket'
-require 'test/unit'
 
 class TestGetSockOpt < Test::Unit::TestCase
 
-  def setup
-    assert(!EM.reactor_running?)
-  end
+  if EM.respond_to? :get_sock_opt
+    def setup
+      assert(!EM.reactor_running?)
+    end
 
-  def teardown
-    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
+  else
+    warn "EM.get_sock_opt not implemented, skipping tests in #{__FILE__}"
 
-  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
-      }
+    # Because some rubies will complain if a TestCase class has no tests
+    def test_em_get_sock_opt_unsupported
+      assert true
     end
   end
 end

data/tests/test_handler_check.rb

@@ -1,6 +1,4 @@
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
+require 'em_test_helper'
 
 class TestHandlerCheck < Test::Unit::TestCase
 

data/tests/test_hc.rb

@@ -1,38 +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 TestHeaderAndContentProtocol < Test::Unit::TestCase
 
-  TestHost = "127.0.0.1"
-  TestPort = 8905
-
-  class SimpleTest < EventMachine::Protocols::HeaderAndContentProtocol
+  class SimpleTest < EM::P::HeaderAndContentProtocol
     attr_reader :first_header, :my_headers, :request
 
     def receive_first_header_line hdr
@@ -51,19 +21,23 @@ class TestHeaderAndContentProtocol < Test::Unit::TestCase
   
   class StopOnUnbind < EM::Connection
     def unbind
-      EM.add_timer(0.1) { EM.stop }
+      EM.add_timer(0.01) { EM.stop }
     end
   end
 
+  def setup
+    @port = next_port
+  end
+
   def test_no_content
     the_connection = nil
     EM.run {
-      EM.start_server( TestHost, TestPort, SimpleTest ) do |conn|
+      EM.start_server( "127.0.0.1", @port, SimpleTest ) do |conn|
         the_connection = conn
       end
       setup_timeout
 
-      EM.connect TestHost, TestPort, StopOnUnbind do |c|
+      EM.connect "127.0.0.1", @port, StopOnUnbind do |c|
         c.send_data [ "aaa\n", "bbb\r\n", "ccc\n", "\n" ].join
         c.close_connection_after_writing
       end
@@ -77,13 +51,13 @@ class TestHeaderAndContentProtocol < Test::Unit::TestCase
     the_connection = nil
     content = "A" * 50
     headers = ["aaa", "bbb", "Content-length: #{content.length}", "ccc"]
-    EventMachine.run {
-      EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
+    EM.run {
+      EM.start_server( "127.0.0.1", @port, SimpleTest ) do |conn|
         the_connection = conn
       end
       setup_timeout
 
-      EM.connect TestHost, TestPort, StopOnUnbind do |c|
+      EM.connect "127.0.0.1", @port, StopOnUnbind do |c|
         headers.each { |h| c.send_data "#{h}\r\n" }
         c.send_data "\n"
         c.send_data content
@@ -99,13 +73,13 @@ class TestHeaderAndContentProtocol < Test::Unit::TestCase
     the_connection = nil
     content = "A" * 50
     headers = ["aaa", "bbb", "Content-length: #{content.length}", "ccc"]
-    EventMachine.run {
-      EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
+    EM.run {
+      EM.start_server( "127.0.0.1", @port, SimpleTest ) do |conn|
         the_connection = conn
       end
       setup_timeout
 
-      EventMachine.connect( TestHost, TestPort, StopOnUnbind ) do |c|
+      EM.connect( "127.0.0.1", @port, StopOnUnbind ) do |c|
         5.times do
           headers.each { |h| c.send_data "#{h}\r\n" }
           c.send_data "\n"
@@ -125,20 +99,20 @@ class TestHeaderAndContentProtocol < Test::Unit::TestCase
   #   the_connection = nil
   #   content = "A" * 50
   #   headers = ["aaa", "bbb", ["Content-length: #{content.length}"]*2, "ccc"].flatten
-  #   EventMachine.run {
-  #     EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
+  #   EM.run {
+  #     EM.start_server( "127.0.0.1", @port, SimpleTest ) do |conn|
   #       the_connection = conn
   #     end
-  #     EventMachine.add_timer(4) {raise "test timed out"}
+  #     EM.add_timer(4) {raise "test timed out"}
   #     test_proc = proc {
-  #       t = TCPSocket.new TestHost, TestPort
+  #       t = TCPSocket.new "127.0.0.1", @port
   #       headers.each {|h| t.write "#{h}\r\n" }
   #       t.write "\n"
   #       t.write content
   #       t.close
   #     }
-  #     EventMachine.defer test_proc, proc {
-  #       EventMachine.stop
+  #     EM.defer test_proc, proc {
+  #       EM.stop
   #     }
   #   }
   # end
@@ -154,13 +128,13 @@ class TestHeaderAndContentProtocol < Test::Unit::TestCase
       "x-tempest-header:ddd"
     ]
 
-    EventMachine.run {
-      EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
+    EM.run {
+      EM.start_server( "127.0.0.1", @port, SimpleTest ) do |conn|
         the_connection = conn
       end
       setup_timeout
 
-      EventMachine.connect( TestHost, TestPort, StopOnUnbind ) do |c|
+      EM.connect( "127.0.0.1", @port, StopOnUnbind ) do |c|
         headers.each { |h| c.send_data "#{h}\r\n" }
         c.send_data "\n"
         c.send_data content
@@ -178,13 +152,4 @@ 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