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

data/tests/test_ltp2.rb

@@ -1,33 +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'
 
 # TODO!!! Need tests for overlength headers and text bodies.
 

data/tests/test_next_tick.rb

@@ -1,33 +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 TestNextTick < Test::Unit::TestCase
 

data/tests/test_object_protocol.rb

@@ -1,11 +1,6 @@
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
+require 'em_test_helper'
 
 class TestObjectProtocol < Test::Unit::TestCase
-  Host = "127.0.0.1"
-  Port = 9550
-
   module Server
     include EM::P::ObjectProtocol
     def post_init
@@ -25,13 +20,17 @@ class TestObjectProtocol < Test::Unit::TestCase
     end
   end
 
+  def setup
+    @port = next_port
+  end
+
   def test_send_receive
     EM.run{
-      EM.start_server Host, Port, Server
-      EM.connect Host, Port, Client
+      EM.start_server "127.0.0.1", @port, Server
+      EM.connect "127.0.0.1", @port, Client
     }
 
     assert($client == {:hello=>'world'})
     assert($server == {'you_said'=>{:hello=>'world'}})
   end
-end
+end

data/tests/test_pause.rb

@@ -1,30 +1,21 @@
-$:.unshift File.expand_path(File.dirname(__FILE__) + "/../lib")
-require 'eventmachine'
-require 'socket'
-require 'test/unit'
+require 'em_test_helper'
 
 class TestPause < Test::Unit::TestCase
-  TestHost = "127.0.0.1"
-  TestPort = 9070
-
-  def setup
-    assert(!EM.reactor_running?)
-  end
-
-  def teardown
-    assert(!EM.reactor_running?)
-  end
+  if EM.respond_to? :pause_connection
+    def setup
+      @port = next_port
+    end
 
-  #-------------------------------------
+    def teardown
+      assert(!EM.reactor_running?)
+    end
 
-  def test_pause_resume
-    test = self
-    server = nil
+    def test_pause_resume
+      server = nil
 
-    s_rx = c_rx = 0
+      s_rx = c_rx = 0
 
-    EM.run do
-      EM.start_server TestHost, TestPort, Module.new {
+      test_server = Module.new do
         define_method :post_init do
           server = self
         end
@@ -39,32 +30,49 @@ class TestPause < Test::Unit::TestCase
           # be sent and no more incoming data will be received
           pause
         end
-      }
+      end
+
+      test_client = Module.new do
+        def post_init
+          EM.add_periodic_timer(0.01) do
+            send_data 'hello'
+          end
+        end
 
-      c = EM.connect TestHost, TestPort, Module.new {
         define_method :receive_data do |data|
           c_rx += 1
         end
-      }
-      EM.add_periodic_timer(0.01) { c.send_data 'hi' }
+      end
 
-      EM.add_timer(1) do
-        test.assert_equal 1, s_rx
-        test.assert_equal 0, c_rx
-        test.assert server.paused?
+      EM.run do
+        EM.start_server "127.0.0.1", @port, test_server
+        EM.connect "127.0.0.1", @port, test_client
 
-        # resume server, queued outgoing and incoming data will be flushed
-        server.resume
+        EM.add_timer(0.05) do
+          assert_equal 1, s_rx
+          assert_equal 0, c_rx
+          assert server.paused?
 
-        test.assert ! server.paused?
+          # resume server, queued outgoing and incoming data will be flushed
+          server.resume
 
-        EM.add_timer(1) do
-          test.assert server.paused?
-          test.assert s_rx >= 2
-          test.assert c_rx >= 1
-          EM.stop_event_loop
+          assert !server.paused?
+
+          EM.add_timer(0.05) do
+            assert server.paused?
+            assert s_rx > 1
+            assert c_rx > 0
+            EM.stop
+          end
         end
       end
     end
+  else
+    warn "EM.pause_connection not implemented, skipping tests in #{__FILE__}"
+
+    # Because some rubies will complain if a TestCase class has no tests
+    def test_em_pause_connection_not_implemented
+      assert true
+    end
   end
 end

data/tests/test_pending_connect_timeout.rb

@@ -1,48 +1,52 @@
-$:.unshift "../lib"
-require 'eventmachine'
-require 'test/unit'
+require 'em_test_helper'
 
 class TestPendingConnectTimeout < Test::Unit::TestCase
 
-  def test_default
-    $timeout = nil
-    EM.run {
-      c = EM.connect("127.0.0.1", 54321)
-      $timeout = c.pending_connect_timeout
-      EM.stop
-    }
-
-    assert_equal(20.0, $timeout)
-  end
-
-  def test_set_and_get
-    $timeout = nil
-    EM.run {
-      c = EM.connect("1.2.3.4", 54321)
-      c.pending_connect_timeout = 2.5
-      $timeout = c.pending_connect_timeout
-      EM.stop
-    }
-
-    assert_equal(2.5, $timeout)
-  end
+  if EM.respond_to? :get_pending_connect_timeout
+    def test_default
+      EM.run {
+        c = EM.connect("127.0.0.1", 54321)
+        assert_equal 20.0, c.pending_connect_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.pending_connect_timeout = 2.5
+        assert_equal 2.5, c.pending_connect_timeout
+        EM.stop
+      }
     end
-  end
 
-  def test_for_real
-    $timeout = nil
-    EM.run {
-      EM.heartbeat_interval = 0.1
-      $start = Time.now
-      c = EM.connect("1.2.3.4", 54321, TimeoutHandler)
-      c.pending_connect_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.1
+        start = Time.now
+        c = EM.connect("1.2.3.4", 54321, timeout_handler)
+        c.pending_connect_timeout = 0.2
+      }
+
+      assert_in_delta(0.2, (finish - start), 0.1)
+    end
+  else
+    warn "EM.pending_connect_timeout not implemented, skipping tests in #{__FILE__}"
 
-    assert_in_delta(0.2, (Time.now - $start), 0.1)
+    # Because some rubies will complain if a TestCase class has no tests
+    def test_em_pending_connect_timeout_not_implemented
+      assert true
+    end
   end
 
 end

data/tests/test_process_watch.rb

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

data/tests/test_processes.rb

@@ -1,128 +1,110 @@
-# $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 TestProcesses < Test::Unit::TestCase
 
-  # EM::DeferrableChildProcess is a sugaring of a common use-case
-  # involving EM::popen.
-  # Call the #open method on EM::DeferrableChildProcess, passing
-  # a command-string. #open immediately returns an EM::Deferrable
-  # object. It also schedules the forking of a child process, which
-  # will execute the command passed to #open.
-  # When the forked child terminates, the Deferrable will be signalled
-  # and execute its callbacks, passing the data that the child process
-  # wrote to stdout.
-  #
-  def test_deferrable_child_process
-    ls = ""
-    EM.run {
-      d = EM::DeferrableChildProcess.open( "ls -ltr" )
-      d.callback {|data_from_child|
-        ls = data_from_child
-        EM.stop
+  if !windows? && !jruby?
+
+    # EM::DeferrableChildProcess is a sugaring of a common use-case
+    # involving EM::popen.
+    # Call the #open method on EM::DeferrableChildProcess, passing
+    # a command-string. #open immediately returns an EM::Deferrable
+    # object. It also schedules the forking of a child process, which
+    # will execute the command passed to #open.
+    # When the forked child terminates, the Deferrable will be signalled
+    # and execute its callbacks, passing the data that the child process
+    # wrote to stdout.
+    #
+    def test_deferrable_child_process
+      ls = ""
+      EM.run {
+        d = EM::DeferrableChildProcess.open( "ls -ltr" )
+        d.callback {|data_from_child|
+          ls = data_from_child
+          EM.stop
+        }
       }
-    }
-    assert( ls.length > 0)
-  end
+      assert( ls.length > 0)
+    end
 
-  def setup
-    $out = nil
-    $status = nil
-  end
+    def setup
+      $out = nil
+      $status = nil
+    end
 
-  def test_em_system
-    EM.run{
-      EM.system('ls'){ |out,status| $out, $status = out, status; EM.stop }
-    }
+    def test_em_system
+      EM.run{
+        EM.system('ls'){ |out,status| $out, $status = out, status; EM.stop }
+      }
 
-    assert( $out.length > 0 )
-    assert_equal($status.exitstatus, 0)
-    assert_equal($status.class, Process::Status)
-  end
+      assert( $out.length > 0 )
+      assert_equal($status.exitstatus, 0)
+      assert_equal($status.class, Process::Status)
+    end
 
-  def test_em_system_pid
-    $pids = []
+    def test_em_system_pid
+      $pids = []
 
-    EM.run{
-      $pids << EM.system('echo hi', proc{ |out,status|$pids << status.pid; EM.stop })
-    }
+      EM.run{
+        $pids << EM.system('echo hi', proc{ |out,status|$pids << status.pid; EM.stop })
+      }
 
-    assert_equal $pids[0], $pids[1]
-  end
+      assert_equal $pids[0], $pids[1]
+    end
+
+    def test_em_system_with_proc
+      EM.run{
+        EM.system('ls', proc{ |out,status| $out, $status = out, status; EM.stop })
+      }
 
-  def test_em_system_with_proc
-    EM.run{
-      EM.system('ls', proc{ |out,status| $out, $status = out, status; EM.stop })
-    }
+      assert( $out.length > 0 )
+      assert_equal($status.exitstatus, 0)
+      assert_equal($status.class, Process::Status)
+    end
+
+    def test_em_system_with_two_procs
+      EM.run{
+        EM.system('sh', proc{ |process|
+          process.send_data("echo hello\n")
+          process.send_data("exit\n")
+        }, proc{ |out,status|
+          $out = out
+          $status = status
+          EM.stop
+        })
+      }
 
-    assert( $out.length > 0 )
-    assert_equal($status.exitstatus, 0)
-    assert_equal($status.class, Process::Status)
-  end
+      assert_equal("hello\n", $out)
+    end
+
+    def test_em_system_cmd_arguments
+      EM.run{
+        EM.system('sh', '--version', proc{ |process|
+        }, proc{ |out,status|
+          $out = out
+          $status = status
+          EM.stop
+        })
+      }
 
-  def test_em_system_with_two_procs
-    EM.run{
-      EM.system('sh', proc{ |process|
-        process.send_data("echo hello\n")
-        process.send_data("exit\n")
-      }, proc{ |out,status|
-        $out = out
-        $status = status
-        EM.stop
-      })
-    }
-
-    assert_equal("hello\n", $out)
-  end
+      assert_match(/version/i, $out)
+    end
 
-  def test_em_system_cmd_arguments
-    EM.run{
-      EM.system('sh', '--version', proc{ |process|
-      }, proc{ |out,status|
-        $out = out
-        $status = status
-        EM.stop
-      })
-    }
-
-    assert_match(/version/i, $out)
-  end
+    def test_em_system_spaced_arguments
+      EM.run{
+        EM.system('ruby', '-e', 'puts "hello"', proc{ |out,status|
+          $out = out
+          EM.stop
+        })
+      }
 
-  def test_em_system_spaced_arguments
-    EM.run{
-      EM.system('ruby', '-e', 'puts "hello"', proc{ |out,status|
-        $out = out
-        EM.stop
-      })
-    }
+      assert_equal("hello\n", $out)
+    end
+  else
+    warn "EM.popen not implemented, skipping tests in #{__FILE__}"
 
-    assert_equal("hello\n", $out)
+    # Because some rubies will complain if a TestCase class has no tests
+    def test_em_popen_unsupported
+      assert true
+    end
   end
 end