eventmachine 1.0.9.1-java → 1.2.0.1-java

data/tests/test_basic.rb

@@ -93,15 +93,28 @@ class TestBasic < Test::Unit::TestCase
     end
   end
 
-  def test_unbind_error
+  def test_unbind_error_during_stop
     assert_raises( UnbindError::ERR ) {
       EM.run {
         EM.start_server "127.0.0.1", @port
-        EM.connect "127.0.0.1", @port, UnbindError
+        EM.connect "127.0.0.1", @port, UnbindError do
+          EM.stop
+        end
       }
     }
   end
 
+  def test_unbind_error
+    EM.run {
+      EM.error_handler do |e|
+        assert(e.is_a?(UnbindError::ERR))
+        EM.stop
+      end
+      EM.start_server "127.0.0.1", @port
+      EM.connect "127.0.0.1", @port, UnbindError
+    }
+  end
+
   module BrsTestSrv
     def receive_data data
       $received << data
@@ -131,6 +144,8 @@ class TestBasic < Test::Unit::TestCase
   end
 
   def test_bind_connect
+    pend('FIXME: this test is broken on Windows') if windows?
+
     local_ip = UDPSocket.open {|s| s.connect('google.com', 80); s.addr.last }
 
     bind_port = next_port
@@ -244,30 +259,6 @@ class TestBasic < Test::Unit::TestCase
     assert_equal 1, num_close_scheduled
   end
 
-  def test_fork_safe
-    omit_if(jruby?)
-    omit_if(rbx?, 'Omitting test on Rubinius because it hangs for unknown reasons')
-
-    read, write = IO.pipe
-    EM.run do
-      fork do
-        write.puts "forked"
-        EM.run do
-          EM.next_tick do
-            write.puts "EM ran"
-            EM.stop
-          end
-        end
-      end
-      EM.stop
-    end
-    assert_equal "forked\n", read.readline
-    assert_equal "EM ran\n", read.readline
-  ensure
-    read.close rescue nil
-    write.close rescue nil
-  end
-
   def test_error_handler_idempotent # issue 185
     errors = []
     ticks = []

data/tests/test_channel.rb

@@ -59,4 +59,17 @@ class TestEMChannel < Test::Unit::TestCase
 
     assert_equal [1,2,3], out
   end
-end
+
+  def test_channel_num_subscribers
+     subs = 0
+     EM.run do
+       c = EM::Channel.new
+       c.subscribe { |v| s = v }
+       c.subscribe { |v| s = v }
+       EM.next_tick { EM.stop }
+       subs = c.num_subscribers
+     end
+
+     assert_equal subs, 2
+  end
+end

data/tests/test_connection_write.rb

@@ -19,8 +19,8 @@ class TestConnectionWrite < Test::Unit::TestCase
 
   def test_with_naughty_callback
     EM.run do
-      r1, w1 = IO.pipe
-      r2, w2 = IO.pipe
+      r1, _ = IO.pipe
+      r2, _ = IO.pipe
 
       # Adding EM.watches
       $conn1 = EM.watch(r1, SimpleClient)

data/tests/test_defer.rb

@@ -15,4 +15,21 @@ class TestDefer < Test::Unit::TestCase
     assert_equal( n, n_times )
   end
 
+  def test_errbacks
+    iterations = 20
+    callback_parameter = rand(100)
+    callback_parameters = []
+    callback_op = proc { callback_parameter }
+    callback = proc { |result| callback_parameters << result }
+    errback_parameter = Exception.new
+    errback_parameters = []
+    errback_op = proc { raise errback_parameter }
+    errback = proc { |error| errback_parameters << error }
+    EventMachine.run do
+      (1..iterations).each { |index| EventMachine.defer(index.even? ? callback_op : errback_op, callback, errback) }
+      EventMachine.add_periodic_timer(0.1) { EventMachine.stop if EventMachine.defers_finished? }
+    end
+    assert_equal(callback_parameters.select { |parameter| parameter == callback_parameter }.length, iterations * 0.5)
+    assert_equal(errback_parameters.select{ |parameter| parameter == errback_parameter }.length, iterations * 0.5)
+  end
 end

data/tests/test_epoll.rb

@@ -128,7 +128,7 @@ class TestEpoll < Test::Unit::TestCase
     EM.run {
       EM.add_timer(0.01) { EM.stop }
 
-      r, w = IO.pipe
+      r, _ = IO.pipe
 
       # This tests a regression where detach in the same tick as attach crashes EM
       EM.watch(r) do |connection|

data/tests/test_fork.rb

@@ -0,0 +1,75 @@
+require 'em_test_helper'
+
+class TestFork < Test::Unit::TestCase
+
+  def test_fork_safe
+    omit_if(jruby?)
+    omit_if(windows?)
+
+    fork_pid = nil
+    read, write = IO.pipe
+    EM.run do
+      fork_pid = fork do
+        write.puts "forked"
+        EM.run do
+          EM.next_tick do
+            write.puts "EM ran"
+            EM.stop
+          end
+        end
+      end
+      EM.stop
+    end
+
+    sleep 0.1
+    begin
+      Timeout::timeout 1 do
+        assert_equal "forked\n", read.readline
+        assert_equal "EM ran\n", read.readline
+      end
+    rescue Timeout::Error
+      Process.kill 'TERM', fork_pid
+      flunk "Timeout waiting for next_tick in new fork reactor"
+    end
+  ensure
+    read.close rescue nil
+    write.close rescue nil
+  end
+
+  def test_fork_reactor
+    omit_if(jruby?)
+    omit_if(windows?)
+
+    fork_pid = nil
+    read, write = IO.pipe
+    EM.run do
+      EM.defer do
+        write.puts Process.pid
+        EM.defer do
+          EM.stop
+        end
+      end
+      fork_pid = EM.fork_reactor do
+        EM.defer do
+          write.puts Process.pid
+          EM.stop
+        end
+      end
+    end
+
+    sleep 0.1
+    begin
+      Timeout::timeout 1 do
+        assert_equal Process.pid.to_s, read.readline.chomp
+        assert_equal fork_pid.to_s, read.readline.chomp
+      end
+    rescue Timeout::Error
+      Process.kill 'TERM', fork_pid
+      flunk "Timeout waiting for deferred block in fork_reactor"
+    end
+  ensure
+    read.close rescue nil
+    write.close rescue nil
+  end
+
+end

data/tests/test_ipv4.rb

@@ -0,0 +1,125 @@
+require 'em_test_helper'
+require 'socket'
+
+class TestIPv4 < Test::Unit::TestCase
+
+  if Test::Unit::TestCase.public_ipv4?
+
+    # Tries to connect to www.google.com port 80 via TCP.
+    # Timeout in 2 seconds.
+    def test_ipv4_tcp_client
+      conn = nil
+      setup_timeout(2)
+
+      EM.run do
+        conn = EM::connect("www.google.com", 80) do |c|
+          def c.connected
+            @connected
+          end
+
+          def c.connection_completed
+            @connected = true
+            EM.stop
+          end
+        end
+      end
+
+      assert conn.connected
+    end
+
+    # Runs a TCP server in the local IPv4 address, connects to it and sends a specific data.
+    # Timeout in 2 seconds.
+    def test_ipv4_tcp_local_server
+      @@received_data = nil
+      @local_port = next_port
+      setup_timeout(2)
+
+      EM.run do
+        EM::start_server(@@public_ipv4, @local_port) do |s|
+          def s.receive_data data
+            @@received_data = data
+            EM.stop
+          end
+        end
+
+        EM::connect(@@public_ipv4, @local_port) do |c|
+          c.send_data "ipv4/tcp"
+        end
+      end
+
+      assert_equal "ipv4/tcp", @@received_data
+    end
+
+    # Runs a UDP server in the local IPv4 address, connects to it and sends a specific data.
+    # Timeout in 2 seconds.
+    def test_ipv4_udp_local_server
+      @@received_data = nil
+      @local_port = next_port
+      setup_timeout(2)
+
+      EM.run do
+        EM::open_datagram_socket(@@public_ipv4, @local_port) do |s|
+          def s.receive_data data
+            @@received_data = data
+            EM.stop
+          end
+        end
+
+        EM::open_datagram_socket(@@public_ipv4, next_port) do |c|
+          c.send_datagram "ipv4/udp", @@public_ipv4, @local_port
+        end
+      end
+
+      assert_equal "ipv4/udp", @@received_data
+    end
+
+    # Try to connect via TCP to an invalid IPv4. EM.connect should raise
+    # EM::ConnectionError.
+    def test_tcp_connect_to_invalid_ipv4
+      invalid_ipv4 = "9.9:9"
+
+      EM.run do
+        begin
+          error = nil
+          EM.connect(invalid_ipv4, 1234)
+        rescue => e
+          error = e
+        ensure
+          EM.stop
+          assert_equal EM::ConnectionError, (error && error.class)
+        end
+      end
+    end
+
+    # Try to send a UDP datagram to an invalid IPv4. EM.send_datagram should raise
+    # EM::ConnectionError.
+    def test_udp_send_datagram_to_invalid_ipv4
+      invalid_ipv4 = "9.9:9"
+
+      EM.run do
+        begin
+          error = nil
+          EM.open_datagram_socket(@@public_ipv4, next_port) do |c|
+            c.send_datagram "hello", invalid_ipv4, 1234
+          end
+        rescue => e
+          error = e
+        ensure
+          EM.stop
+          assert_equal EM::ConnectionError, (error && error.class)
+        end
+      end
+    end
+
+
+  else
+    warn "no IPv4 in this host, skipping tests in #{__FILE__}"
+
+    # Because some rubies will complain if a TestCase class has no tests
+    def test_ipv4_unavailable
+      assert true
+    end
+
+  end
+
+end

data/tests/test_ipv6.rb

@@ -0,0 +1,131 @@
+require 'em_test_helper'
+
+class TestIPv6 < Test::Unit::TestCase
+
+  if Test::Unit::TestCase.public_ipv6?
+
+    # Tries to connect to ipv6.google.com (2607:f8b0:4010:800::1006) port 80 via TCP.
+    # Timeout in 6 seconds.
+    def test_ipv6_tcp_client_with_ipv6_google_com
+      conn = nil
+      setup_timeout(6)
+
+      EM.run do
+        conn = EM::connect("2607:f8b0:4010:800::1006", 80) do |c|
+          def c.connected
+            @connected
+          end
+
+          def c.unbind(reason)
+            warn "unbind: #{reason.inspect}" if reason # XXX at least find out why it failed
+          end
+
+          def c.connection_completed
+            @connected = true
+            EM.stop
+          end
+        end
+      end
+
+      assert conn.connected
+    end
+
+    # Runs a TCP server in the local IPv6 address, connects to it and sends a specific data.
+    # Timeout in 2 seconds.
+    def test_ipv6_tcp_local_server
+      @@received_data = nil
+      @local_port = next_port
+      setup_timeout(2)
+
+      EM.run do
+        EM.start_server(@@public_ipv6, @local_port) do |s|
+          def s.receive_data data
+            @@received_data = data
+            EM.stop
+          end
+        end
+
+        EM::connect(@@public_ipv6, @local_port) do |c|
+          def c.unbind(reason)
+            warn "unbind: #{reason.inspect}" if reason # XXX at least find out why it failed
+          end
+          c.send_data "ipv6/tcp"
+        end
+      end
+
+      assert_equal "ipv6/tcp", @@received_data
+    end
+
+    # Runs a UDP server in the local IPv6 address, connects to it and sends a specific data.
+    # Timeout in 2 seconds.
+    def test_ipv6_udp_local_server
+      @@received_data = nil
+      @local_port = next_port
+      setup_timeout(2)
+
+      EM.run do
+        EM.open_datagram_socket(@@public_ipv6, @local_port) do |s|
+          def s.receive_data data
+            @@received_data = data
+            EM.stop
+          end
+        end
+
+        EM.open_datagram_socket(@@public_ipv6, next_port) do |c|
+          c.send_datagram "ipv6/udp", @@public_ipv6, @local_port
+        end
+      end
+
+      assert_equal "ipv6/udp", @@received_data
+    end
+
+    # Try to connect via TCP to an invalid IPv6. EM.connect should raise
+    # EM::ConnectionError.
+    def test_tcp_connect_to_invalid_ipv6
+      invalid_ipv6 = "1:A"
+
+      EM.run do
+        begin
+          error = nil
+          EM.connect(invalid_ipv6, 1234)
+        rescue => e
+          error = e
+        ensure
+          EM.stop
+          assert_equal EM::ConnectionError, (error && error.class)
+        end
+      end
+    end
+
+    # Try to send a UDP datagram to an invalid IPv6. EM.send_datagram should raise
+    # EM::ConnectionError.
+    def test_udp_send_datagram_to_invalid_ipv6
+      invalid_ipv6 = "1:A"
+
+      EM.run do
+        begin
+          error = nil
+          EM.open_datagram_socket(@@public_ipv6, next_port) do |c|
+            c.send_datagram "hello", invalid_ipv6, 1234
+          end
+        rescue => e
+          error = e
+        ensure
+          EM.stop
+          assert_equal EM::ConnectionError, (error && error.class)
+        end
+      end
+    end
+
+
+  else
+    warn "no IPv6 in this host, skipping tests in #{__FILE__}"
+
+    # Because some rubies will complain if a TestCase class has no tests.
+    def test_ipv6_unavailable
+      assert true
+    end
+
+  end
+
+end