eventmachine 0.12.6 → 0.12.8

data/tests/test_attach.rb

@@ -80,4 +80,22 @@ class TestAttach < Test::Unit::TestCase
 
     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
 end

data/tests/test_basic.rb

@@ -26,6 +26,7 @@
 
 $:.unshift File.expand_path(File.dirname(__FILE__) + "/../lib")
 require 'eventmachine'
+require 'socket'
 require 'test/unit'
 
 class TestBasic < Test::Unit::TestCase
@@ -42,16 +43,16 @@ class TestBasic < Test::Unit::TestCase
 
   def test_libtype
     lt = EventMachine.library_type
-		em_lib = (ENV["EVENTMACHINE_LIBRARY"] || $eventmachine_library || :xxx).to_sym
-		
-		# Running from test runner, under jruby.
-		if RUBY_PLATFORM == 'java'
-			unless em_lib == :pure_ruby
-				assert_equal( :java, lt )
-				return
-			end
-		end
-		
+    em_lib = (ENV["EVENTMACHINE_LIBRARY"] || $eventmachine_library || :xxx).to_sym
+
+    # Running from test runner, under jruby.
+    if RUBY_PLATFORM == 'java'
+      unless em_lib == :pure_ruby
+        assert_equal( :java, lt )
+        return
+      end
+    end
+
     case em_lib
     when :pure_ruby
       assert_equal( :pure_ruby, lt )
@@ -60,12 +61,12 @@ class TestBasic < Test::Unit::TestCase
     when :java
       assert_equal( :java, lt )
     else
-			# Running from jruby as a standalone test.
-			if RUBY_PLATFORM == 'java'
-				assert_equal( :java, lt )
-			else
-      	assert_equal( :extension, lt )
-			end
+      # Running from jruby as a standalone test.
+      if RUBY_PLATFORM == 'java'
+        assert_equal( :java, lt )
+      else
+        assert_equal( :extension, lt )
+      end
     end
   end
 
@@ -116,10 +117,10 @@ class TestBasic < Test::Unit::TestCase
   # even after the supplied block completes.
   def test_run_block
     assert !EM.reactor_running?
-      a = nil
-      EM.run_block { a = "Worked" }
-      assert a
-      assert !EM.reactor_running?
+    a = nil
+    EM.run_block { a = "Worked" }
+    assert a
+    assert !EM.reactor_running?
   end
 
 
@@ -136,24 +137,24 @@ class TestBasic < Test::Unit::TestCase
   TestPort = 9070
 
   class UnbindError < EM::Connection
-	  def initialize *args
-		  super
-	  end
-	  def connection_completed
-		  close_connection_after_writing
-	  end
-	  def unbind
-		  raise "Blooey"
-	  end
+    def initialize *args
+      super
+    end
+    def connection_completed
+      close_connection_after_writing
+    end
+    def unbind
+      raise "Blooey"
+    end
   end
 
   def xxx_test_unbind_error
-	  assert_raises( RuntimeError ) {
-		  EM.run {
-			  EM.start_server TestHost, TestPort
-			  EM.connect TestHost, TestPort, UnbindError
-		  }
-	  }
+    assert_raises( RuntimeError ) {
+      EM.run {
+        EM.start_server TestHost, TestPort
+        EM.connect TestHost, TestPort, UnbindError
+      }
+    }
   end
 
   #------------------------------------
@@ -177,26 +178,26 @@ class TestBasic < Test::Unit::TestCase
   #
 
   class PostInitError < EM::Connection
-	  def post_init
-		  aaa bbb # should produce a Ruby exception
-	  end
+    def post_init
+      aaa bbb # should produce a Ruby exception
+    end
   end
   # This test causes issues, the machine becomes unreleasable after 
   # release_machine suffers an exception in event_callback.
   def xxx_test_post_init_error
-	  assert_raises( EventMachine::ConnectionNotBound ) {
-		  EM.run {
-		  	EM::Timer.new(1) {EM.stop}
-			EM.start_server TestHost, TestPort
-			EM.connect TestHost, TestPort, PostInitError
-		  }
-	  }
-	  EM.run {
-	    EM.stop
-	  }
-	  assert !EM.reactor_running?
+    assert_raises( EventMachine::ConnectionNotBound ) {
+      EM.run {
+        EM::Timer.new(1) {EM.stop}
+        EM.start_server TestHost, TestPort
+        EM.connect TestHost, TestPort, PostInitError
+      }
+    }
+    EM.run {
+      EM.stop
+    }
+    assert !EM.reactor_running?
   end
-  
+
   module BrsTestSrv
     def receive_data data
       $received << data
@@ -211,21 +212,74 @@ class TestBasic < Test::Unit::TestCase
       close_connection_after_writing
     end
   end
-  
+
   # From ticket #50
   def test_byte_range_send
     $received = ''
     $sent = (0..255).to_a.pack('C*')
     EM::run {
-      
       EM::start_server TestHost, TestPort, BrsTestSrv
-      
       EM::connect TestHost, TestPort, BrsTestCli
-      
+
       EM::add_timer(0.5) { assert(false, 'test timed out'); EM.stop; Kernel.warn "test timed out!" }
     }
     assert_equal($sent, $received)
   end
 
+  def test_bind_connect
+    local_ip = UDPSocket.open {|s| s.connect('google.com', 80); s.addr.last }
+
+    bind_port = rand(33333)+1025
+
+    test = self
+    EM.run do
+      EM.start_server(TestHost, TestPort, Module.new do
+        define_method :post_init do
+          begin
+            test.assert_equal bind_port, Socket.unpack_sockaddr_in(get_peername).first
+            test.assert_equal local_ip, Socket.unpack_sockaddr_in(get_peername).last
+          ensure
+            EM.stop_event_loop
+          end
+        end
+      end)
+      EM.bind_connect local_ip, bind_port, TestHost, TestPort
+    end
+  end
+
+  def test_reactor_thread?
+    assert !EM.reactor_thread?
+    EM.run { assert EM.reactor_thread?; EM.stop }
+    assert !EM.reactor_thread?
+  end
+
+  def test_schedule_on_reactor_thread
+    x = false
+    EM.run do
+      EM.schedule { x = true }
+      EM.stop
+    end
+    assert x
+  end
+  
+  def test_schedule_from_thread
+    x = false
+    assert !x
+    EM.run do
+      Thread.new { EM.schedule { x = true } }.join
+      EM.stop
+    end
+    assert x
+  end
+
+  def test_set_heartbeat_interval
+    interval = 0.5
+    EM.run {
+      EM.set_heartbeat_interval interval
+      $interval = EM.get_heartbeat_interval
+      EM.stop
+    }
+    assert_equal(interval, $interval)
+  end
 end
 

data/tests/test_channel.rb

@@ -0,0 +1,63 @@
+$:.unshift "../lib"
+require 'eventmachine'
+require 'test/unit'
+
+class TestEventMachineChannel < Test::Unit::TestCase
+  def test_channel_subscribe
+    s = 0
+    EM.run do
+      c = EM::Channel.new
+      c.subscribe { |v| s = v; EM.stop }
+      c << 1
+    end
+    assert_equal 1, s
+  end
+
+  def test_channel_unsubscribe
+    s = 0
+    EM.run do
+      c = EM::Channel.new
+      subscription = c.subscribe { |v| s = v }
+      c.unsubscribe(subscription)
+      c << 1
+      EM.next_tick { EM.stop }
+    end
+    assert_not_equal 1, s
+  end
+
+  def test_channel_pop
+    s = 0
+    EM.run do
+      c = EM::Channel.new
+      c.pop{ |v| s = v }
+      c << 1
+      c << 2
+      EM.next_tick { EM.stop }
+    end
+    assert_equal 1, s
+  end
+
+  def test_channel_reactor_thread_push
+    out = []
+    c = EM::Channel.new
+    c.subscribe { |v| out << v }
+    Thread.new { c.push(1,2,3) }.join
+    assert out.empty?
+
+    EM.run { EM.next_tick { EM.stop } }
+
+    assert_equal [1,2,3], out
+  end
+
+  def test_channel_reactor_thread_callback
+    out = []
+    c = EM::Channel.new
+    Thread.new { c.subscribe { |v| out << v } }.join
+    c.push(1,2,3)
+    assert out.empty?
+
+    EM.run { EM.next_tick { EM.stop } }
+
+    assert_equal [1,2,3], out
+  end
+end

data/tests/test_connection_count.rb

@@ -29,10 +29,10 @@ class TestConnectionCount < Test::Unit::TestCase
 
   def test_with_some_connections
     EM.run {
-      EM.start_server("127.0.0.1", 9999, Server)
       $initial = EM.connection_count
+      EM.start_server("127.0.0.1", 9999, Server)
+      $server_started = EM.connection_count
       EM.next_tick{
-        $server_started = EM.connection_count
         EM.connect("127.0.0.1", 9999, Client)
       }
     }

data/tests/test_epoll.rb

@@ -34,60 +34,61 @@ require 'test/unit'
 
 class TestEpoll < Test::Unit::TestCase
 
-	module TestEchoServer
-		def receive_data data
-			send_data data
-			close_connection_after_writing
-		end
-	end
-
-	module TestEchoClient
-		def connection_completed
-			send_data "ABCDE"
-			$max += 1
-		end
-		def receive_data data
-			raise "bad response" unless data == "ABCDE"
-		end
-		def unbind
-			$n -= 1
-			EM.stop if $n == 0
-		end
-	end
-
-
-	# We can set the rlimit/nofile of a process but we can only set it
-	# higher if we're running as root.
-	# On most systems, the default value is 1024.
-	# Java doesn't (currently) implement this.
-	def test_rlimit
-		unless RUBY_PLATFORM =~ /java/ or EM.set_descriptor_table_size >= 1024
-			a = EM.set_descriptor_table_size
-			assert( a <= 1024 )
-			a = EM.set_descriptor_table_size( 1024 )
-			assert( a == 1024 )
-		end
-	end
-
-	# Run a high-volume version of this test by kicking the number of connections
-	# up past 512. (Each connection uses two sockets, a client and a server.)
-	# (Will require running the test as root)
-	# This test exercises TCP clients and servers.
-	#
-	def test_descriptors
-		EM.epoll
-		s = EM.set_descriptor_table_size 60000
-		EM.run {
-			EM.start_server "127.0.0.1", 9800, TestEchoServer
-			$n = 0
-			$max = 0
-			100.times {
-				EM.connect("127.0.0.1", 9800, TestEchoClient) {$n += 1}
-			}
-		}
-		assert_equal(0, $n)
-		assert_equal(100, $max)
-	end
+  module TestEchoServer
+    def receive_data data
+      send_data data
+      close_connection_after_writing
+    end
+  end
+
+  module TestEchoClient
+    def connection_completed
+      send_data "ABCDE"
+      $max += 1
+    end
+    def receive_data data
+      raise "bad response" unless data == "ABCDE"
+    end
+    def unbind
+      $n -= 1
+      EM.stop if $n == 0
+    end
+  end
+
+
+  # We can set the rlimit/nofile of a process but we can only set it
+  # higher if we're running as root.
+  # On most systems, the default value is 1024.
+  # Java doesn't (currently) implement this.
+  def test_rlimit
+    unless RUBY_PLATFORM =~ /java/ or EM.set_descriptor_table_size >= 1024
+      a = EM.set_descriptor_table_size
+      assert( a <= 1024 )
+      a = EM.set_descriptor_table_size( 1024 )
+      assert( a == 1024 )
+    end
+  end
+
+  # Run a high-volume version of this test by kicking the number of connections
+  # up past 512. (Each connection uses two sockets, a client and a server.)
+  # (Will require running the test as root)
+  # This test exercises TCP clients and servers.
+  #
+  # XXX this test causes all sort of weird issues on OSX (when run as part of the suite)
+  def _test_descriptors
+    EM.epoll
+    s = EM.set_descriptor_table_size 60000
+    EM.run {
+      EM.start_server "127.0.0.1", 9800, TestEchoServer
+      $n = 0
+      $max = 0
+      100.times {
+        EM.connect("127.0.0.1", 9800, TestEchoClient) {$n += 1}
+      }
+    }
+    assert_equal(0, $n)
+    assert_equal(100, $max)
+  end
 
   def test_defer
     n = 0
@@ -101,63 +102,61 @@ class TestEpoll < Test::Unit::TestCase
   end unless RUBY_VERSION >= '1.9.0'
 
 
-	module TestDatagramServer
-		def receive_data dgm
-			$in = dgm
-			send_data "abcdefghij"
-		end
-	end
-	module TestDatagramClient
-		def post_init
-			send_datagram "1234567890", "127.0.0.1", 9500
-		end
-		def receive_data dgm
-			$out = dgm
-			EM.stop
-		end
-	end
-
-	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
-		}
-		assert_equal( "1234567890", $in )
-		assert_equal( "abcdefghij", $out )
-	end
-
-
-
+  module TestDatagramServer
+    def receive_data dgm
+      $in = dgm
+      send_data "abcdefghij"
+    end
+  end
+  module TestDatagramClient
+    def post_init
+      send_datagram "1234567890", "127.0.0.1", 9500
+    end
+    def receive_data dgm
+      $out = dgm
+      EM.stop
+    end
+  end
+
+  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
+    }
+    assert_equal( "1234567890", $in )
+    assert_equal( "abcdefghij", $out )
+  end
 
-	def test_unix_domain
-		fn = "/tmp/xxx.chain"
-		EM.epoll
-		s = EM.set_descriptor_table_size 60000
-		EM.run {
-			# The pure-Ruby version won't let us open the socket if the node already exists.
-			# Not sure, that actually may be correct and the compiled version is wrong.
-			# Pure Ruby also oddly won't let us make that many connections. This test used
-			# to run 100 times. Not sure where that lower connection-limit is coming from in
-			# pure Ruby.
-			# Let's not sweat the Unix-ness of the filename, since this test can't possibly
-			# work on Windows anyway.
-			#
-			File.unlink(fn) if File.exist?(fn)
-			EM.start_unix_domain_server fn, TestEchoServer
-			$n = 0
-			$max = 0
-			50.times {
-				EM.connect_unix_domain(fn, TestEchoClient) {$n += 1}
-			}
-			EM::add_timer(1) { $stderr.puts("test_unix_domain timed out!"); EM::stop }
-		}
-		assert_equal(0, $n)
-		assert_equal(50, $max)
-	ensure
-		File.unlink(fn) if File.exist?(fn)
-	end
+  # XXX this test fails randomly..
+  def _test_unix_domain
+    fn = "/tmp/xxx.chain"
+    EM.epoll
+    s = EM.set_descriptor_table_size 60000
+    EM.run {
+      # The pure-Ruby version won't let us open the socket if the node already exists.
+      # Not sure, that actually may be correct and the compiled version is wrong.
+      # Pure Ruby also oddly won't let us make that many connections. This test used
+      # to run 100 times. Not sure where that lower connection-limit is coming from in
+      # pure Ruby.
+      # Let's not sweat the Unix-ness of the filename, since this test can't possibly
+      # work on Windows anyway.
+      #
+      File.unlink(fn) if File.exist?(fn)
+      EM.start_unix_domain_server fn, TestEchoServer
+      $n = 0
+      $max = 0
+      50.times {
+        EM.connect_unix_domain(fn, TestEchoClient) {$n += 1}
+      }
+      EM::add_timer(1) { $stderr.puts("test_unix_domain timed out!"); EM::stop }
+    }
+    assert_equal(0, $n)
+    assert_equal(50, $max)
+  ensure
+    File.unlink(fn) if File.exist?(fn)
+  end
 
 end