eventmachine-eventmachine 0.12.7 → 0.12.8

data/tests/test_next_tick.rb

@@ -29,81 +29,107 @@ $:.unshift "../lib"
 require 'eventmachine'
 require 'test/unit'
 
+class TestNextTick < Test::Unit::TestCase
 
+  def test_tick_arg
+    pr = proc {EM.stop}
+    EM.epoll
+    EM.run {
+      EM.next_tick pr
+    }
+    assert true
+  end
 
-class TestNextTick < Test::Unit::TestCase
+  def test_tick_block
+    EM.epoll
+    EM.run {
+      EM.next_tick {EM.stop}
+    }
+    assert true
+  end
 
-	def setup
-	end
+  # This illustrates the solution to a long-standing problem.
+  # It's now possible to correctly nest calls to EM#run.
+  # See the source code commentary for EM#run for more info.
+  #
+  def test_run_run
+    EM.run {
+      EM.run {
+        EM.next_tick {EM.stop}
+      }
+    }
+  end
 
-	def teardown
-	end
+  def test_pre_run_queue
+    x = false
+    EM.next_tick { EM.stop; x = true }
+    EM.run { EM.add_timer(0.2) { EM.stop } }
+    assert x
+  end
 
-	def test_tick_arg
-		pr = proc {EM.stop}
-		EM.epoll
-		EM.run {
-			EM.next_tick pr
-		}
-		assert true
-	end
+  def test_cleanup_after_stop
+    x = true
+    EM.run{
+      EM.next_tick{
+        EM.stop
+        EM.next_tick{ x=false }
+      }
+    }
+    EM.run{
+      EM.next_tick{ EM.stop }
+    }
+    assert x
+  end
 
-	def test_tick_block
-		EM.epoll
-		EM.run {
-			EM.next_tick {EM.stop}
-		}
-		assert true
-	end
+  # We now support an additional parameter for EM#run.
+  # You can pass two procs to EM#run now. The first is executed as the normal
+  # run block. The second (if given) is scheduled for execution after the
+  # reactor loop completes.
+  # The reason for supporting this is subtle. There has always been an expectation
+  # that EM#run doesn't return until after the reactor loop ends. But now it's
+  # possible to nest calls to EM#run, which means that a nested call WILL
+  # RETURN. In order to write code that will run correctly either way, it's
+  # recommended to put any code which must execute after the reactor completes
+  # in the second parameter.
+  #
+  def test_run_run_2
+    a = proc {EM.stop}
+    b = proc {assert true}
+    EM.run a, b
+  end
 
-	# This illustrates the solution to a long-standing problem.
-	# It's now possible to correctly nest calls to EM#run.
-	# See the source code commentary for EM#run for more info.
-	#
-	def test_run_run
-		EM.run {
-			EM.run {
-				EM.next_tick {EM.stop}
-			}
-		}
-	end
 
-	def test_pre_run_queue
-		x = false
-		EM.next_tick { EM.stop; x = true }
-		EM.run { EM.add_timer(0.2) { EM.stop } }
-		assert x
-	end
+  # This illustrates that EM#run returns when it's called nested.
+  # This isn't a feature, rather it's something to be wary of when writing code
+  # that must run correctly even if EM#run is called while a reactor is already
+  # running.
+  def test_run_run_3
+    a = []
+    EM.run {
+      EM.run proc {EM.stop}, proc {a << 2}
+      a << 1
+    }
+    assert_equal( [1,2], a )
+  end
 
-	# We now support an additional parameter for EM#run.
-	# You can pass two procs to EM#run now. The first is executed as the normal
-	# run block. The second (if given) is scheduled for execution after the
-	# reactor loop completes.
-	# The reason for supporting this is subtle. There has always been an expectation
-	# that EM#run doesn't return until after the reactor loop ends. But now it's
-	# possible to nest calls to EM#run, which means that a nested call WILL
-	# RETURN. In order to write code that will run correctly either way, it's
-	# recommended to put any code which must execute after the reactor completes
-	# in the second parameter.
-	#
-	def test_run_run_2
-		a = proc {EM.stop}
-		b = proc {assert true}
-		EM.run a, b
-	end
 
+  def test_schedule_on_reactor_thread
+    x = false
+    EM.run do
+      EM.schedule { x = true }
+      EM.stop
+    end
+    assert x
+  end
 
-	# This illustrates that EM#run returns when it's called nested.
-	# This isn't a feature, rather it's something to be wary of when writing code
-	# that must run correctly even if EM#run is called while a reactor is already
-	# running.
-	def test_run_run_3
-		a = []
-		EM.run {
-			EM.run proc {EM.stop}, proc {a << 2}
-			a << 1
-		}
-		assert_equal( [1,2], a )
-	end
+  def test_schedule_from_thread
+    x = false
+    EM.run do
+      Thread.new { EM.schedule { x = true } }.join
+      assert !x
+      EM.next_tick { EM.stop }
+    end
+    assert x
+  end
 
 end

data/tests/test_object_protocol.rb

@@ -0,0 +1,37 @@
+$:.unshift "../lib"
+require 'eventmachine'
+require 'test/unit'
+
+class TestObjectProtocol < Test::Unit::TestCase
+  Host = "127.0.0.1"
+  Port = 9550
+
+  module Server
+    include EM::P::ObjectProtocol
+    def post_init
+      send_object :hello=>'world'
+    end
+    def receive_object obj
+      $server = obj
+      EM.stop
+    end
+  end
+
+  module Client
+    include EM::P::ObjectProtocol
+    def receive_object obj
+      $client = obj
+      send_object 'you_said'=>obj
+    end
+  end
+
+  def test_send_receive
+    EM.run{
+      EM.start_server Host, Port, Server
+      EM.connect Host, Port, Client
+    }
+
+    assert($client == {:hello=>'world'})
+    assert($server == {'you_said'=>{:hello=>'world'}})
+  end
+end

data/tests/test_process_watch.rb

@@ -0,0 +1,48 @@
+$:.unshift "../lib"
+require 'eventmachine'
+require 'test/unit'
+
+class TestProcessWatch < Test::Unit::TestCase
+  module ParentProcessWatcher
+    def process_forked
+      $forked = true
+    end
+  end
+
+  module ChildProcessWatcher
+    def process_exited
+      $exited = true
+    end
+    def unbind
+      $unbind = true
+      EM.stop
+    end
+  end
+
+  def setup
+    EM.kqueue = true if EM.kqueue?
+  end
+
+  def teardown
+    EM.kqueue = false if EM.kqueue?
+  end
+
+  def test_events
+    EM.run{
+      # watch ourselves for a fork notification
+      EM.watch_process(Process.pid, ParentProcessWatcher)
+      $fork_pid = fork{ sleep }
+      child = EM.watch_process($fork_pid, ChildProcessWatcher)
+      $pid = child.pid
+
+      EM.add_timer(0.5){
+        Process.kill('TERM', $fork_pid)
+      }
+    }
+
+    assert_equal($pid, $fork_pid)
+    assert($forked)
+    assert($exited)
+    assert($unbind)
+  end
+end

data/tests/test_processes.rb

@@ -30,27 +30,27 @@ require 'test/unit'
 
 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
-			}
-		}
-		assert( ls.length > 0)
-	end
+  # 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
 
   def setup
     $out = nil
@@ -67,6 +67,16 @@ class TestProcesses < Test::Unit::TestCase
     assert_equal($status.class, Process::Status)
   end
 
+  def test_em_system_pid
+    $pids = []
+
+    EM.run{
+      $pids << EM.system('echo hi', proc{ |out,status|$pids << status.pid; EM.stop })
+    }
+
+    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 })
@@ -89,7 +99,30 @@ class TestProcesses < Test::Unit::TestCase
       })
     }
 
-    assert_equal($out, "hello\n")
+    assert_equal("hello\n", $out)
   end
-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
+      })
+    }
+
+    assert_equal("hello\n", $out)
+  end
+end

data/tests/test_proxy_connection.rb

@@ -0,0 +1,92 @@
+$:.unshift "../lib"
+require 'eventmachine'
+require 'test/unit'
+
+class TestProxyConnection < Test::Unit::TestCase
+
+  module ProxyConnection
+    def initialize(client, request)
+      @client, @request = client, request
+    end
+
+    def post_init
+      EM::enable_proxy(self, @client)
+    end
+
+    def connection_completed
+      EM.next_tick {
+        send_data @request
+      }
+    end
+
+    def proxy_target_unbound
+      $unbound_early = true
+      EM.stop
+    end
+
+    def unbind
+      @client.close_connection_after_writing
+    end
+  end
+
+  module Client
+    def connection_completed
+      send_data "EventMachine rocks!"
+    end
+
+    def receive_data(data)
+      $client_data = data
+    end
+
+    def unbind
+      EM.stop
+    end
+  end
+
+  module Client2
+    include Client
+    def unbind; end
+  end
+
+  module Server
+    def receive_data(data)
+      send_data "I know!" if data == "EventMachine rocks!"
+      close_connection_after_writing
+    end
+  end
+
+  module ProxyServer
+    def receive_data(data)
+      EM.connect("127.0.0.1", 54321, ProxyConnection, self, data)
+    end
+  end
+
+  module EarlyClosingProxy
+    def receive_data(data)
+      EM.connect("127.0.0.1", 54321, ProxyConnection, self, data)
+      close_connection
+    end
+  end
+
+  def test_proxy_connection
+    EM.run {
+      EM.start_server("127.0.0.1", 54321, Server)
+      EM.start_server("127.0.0.1", 12345, ProxyServer)
+      EM.connect("127.0.0.1", 12345, Client)
+    }
+
+    assert_equal("I know!", $client_data)
+  end
+
+  def test_early_close
+    $client_data = nil
+    EM.run {
+      EM.start_server("127.0.0.1", 54321, Server)
+      EM.start_server("127.0.0.1", 12345, EarlyClosingProxy)
+      EM.connect("127.0.0.1", 12345, Client2)
+    }
+
+    assert($unbound_early)
+  end
+
+end

data/tests/test_pure.rb

@@ -67,12 +67,11 @@ class TestPure < Test::Unit::TestCase
     assert_raises( RuntimeError ) { run_exception }
   end
   def test_exception_2
-		ex_class = RUBY_PLATFORM == 'java' ? NativeException : RuntimeError
+    ex_class = RUBY_PLATFORM == 'java' ? NativeException : RuntimeError
     assert_raises( ex_class ) { run_exception }
   end
 
 
-
   # Under some circumstances, the pure Ruby library would emit an Errno::ECONNREFUSED
   # exception on certain kinds of TCP connect-errors.
   # It's always been something of an open question whether EM should throw an exception
@@ -114,8 +113,6 @@ class TestPure < Test::Unit::TestCase
     assert_equal( false, timeout )
   end
 
-
-
   def test_reactor_running
     a = false
     EM.run {
@@ -125,5 +122,4 @@ class TestPure < Test::Unit::TestCase
     assert a
   end
 
-
 end

data/tests/test_queue.rb

@@ -0,0 +1,44 @@
+$:.unshift "../lib"
+require 'eventmachine'
+require 'test/unit'
+
+class TestEventMachineQueue < Test::Unit::TestCase
+  def test_queue_push
+    s = 0
+    EM.run do
+      q = EM::Queue.new
+      q.push(1)
+      EM.next_tick { s = q.size; EM.stop }
+    end
+    assert_equal 1, s
+  end
+
+  def test_queue_pop
+    x,y,z = nil
+    EM.run do
+      q = EM::Queue.new
+      q.push(1,2,3)
+      q.pop { |v| x = v }
+      q.pop { |v| y = v }
+      q.pop { |v| z = v; EM.stop }
+    end
+    assert_equal 1, x
+    assert_equal 2, y
+    assert_equal 3, z
+  end
+
+  def test_queue_reactor_thread
+    q = EM::Queue.new
+
+    Thread.new { q.push(1,2,3) }.join
+    assert q.empty?
+    EM.run { EM.next_tick { EM.stop } }
+    assert_equal 3, q.size
+
+    x = nil
+    Thread.new { q.pop { |v| x = v } }.join
+    assert_equal nil, x
+    EM.run { EM.next_tick { EM.stop } }
+    assert_equal 1, x
+  end
+end

data/tests/test_running.rb

@@ -29,19 +29,14 @@ require 'eventmachine'
 require 'test/unit'
 
 class TestRunning < Test::Unit::TestCase
-	def setup
-	end
-	def teardown
-	end
-
-	def test_running
-		assert_equal( false, EM::reactor_running? )
-		r = false
-		EM.run {
-			r = EM::reactor_running?
-			EM.stop
-		}
-		assert_equal( true, r )
-	end
+  def test_running
+    assert_equal( false, EM::reactor_running? )
+    r = false
+    EM.run {
+      r = EM::reactor_running?
+      EM.stop
+    }
+    assert_equal( true, r )
+  end
 end
 

data/tests/test_sasl.rb

@@ -31,44 +31,42 @@ require 'test/unit'
 
 class TestSASL < Test::Unit::TestCase
 
-	# SASL authentication is usually done with UNIX-domain sockets, but
-	# we'll use TCP so this test will work on Windows. As far as the
-	# protocol handlers are concerned, there's no difference.
+  # SASL authentication is usually done with UNIX-domain sockets, but
+  # we'll use TCP so this test will work on Windows. As far as the
+  # protocol handlers are concerned, there's no difference.
 
+  Host,Port = "127.0.0.1",9560
+  TestUser,TestPsw = "someone", "password"
 
-	Host,Port = "127.0.0.1",9560
-	TestUser,TestPsw = "someone", "password"
+  class SaslServer < EM::Connection
+    include EM::Protocols::SASLauth
+    def validate usr, psw, sys, realm
+      usr == TestUser and psw == TestPsw
+    end
+  end
 
-	class SaslServer < EM::Connection
-		include EM::Protocols::SASLauth
-		def validate usr, psw, sys, realm
-			usr == TestUser and psw == TestPsw
-		end
-	end
+  class SaslClient < EM::Connection
+    include EM::Protocols::SASLauthclient
+  end
 
-	class SaslClient < EM::Connection
-		include EM::Protocols::SASLauthclient
-	end
+  def test_sasl
+    resp = nil
+    EM.run {
+      EM.start_server( Host, Port, SaslServer )
 
-	def test_sasl
-		resp = nil
-		EM.run {
-			EM.start_server( Host, Port, SaslServer )
-
-			c = EM.connect( Host, Port, SaslClient )
-			d = c.validate?( TestUser, TestPsw )
-			d.timeout 2
-			d.callback {
-				resp = true
-				EM.stop
-			}
-			d.errback {
-				resp = false
-				EM.stop
-			}
-		}
-		assert_equal( true, resp )
-	end
+      c = EM.connect( Host, Port, SaslClient )
+      d = c.validate?( TestUser, TestPsw )
+      d.timeout 2
+      d.callback {
+        resp = true
+        EM.stop
+      }
+      d.errback {
+        resp = false
+        EM.stop
+      }
+    }
+    assert_equal( true, resp )
+  end
 
 end
-