eventmachine 1.0.3-x86-mingw32 → 1.2.0.dev.2-x86-mingw32

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

@@ -25,19 +25,16 @@ class TestEpoll < Test::Unit::TestCase
   end
 
 
-  if windows? || jruby?
-    warn "EM.set_descriptor_table_size not implemented, skipping test in #{__FILE__}"
-  else
-    # 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.
-    def test_rlimit
-      unless 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
+  # 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.
+  def test_rlimit
+    omit_if(windows? || jruby?)
+    unless 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
 
@@ -97,7 +94,7 @@ class TestEpoll < Test::Unit::TestCase
     assert_equal( "abcdefghij", $out )
   end
 
-  # XXX this test fails randomly..
+  # XXX this test fails randomly...
   def _test_unix_domain
     fn = "/tmp/xxx.chain"
     EM.epoll
@@ -126,5 +123,20 @@ class TestEpoll < Test::Unit::TestCase
     File.unlink(fn) if File.exist?(fn)
   end
 
+  def test_attach_detach
+    EM.epoll
+    EM.run {
+      EM.add_timer(0.01) { EM.stop }
+
+      r, _ = IO.pipe
+
+      # This tests a regression where detach in the same tick as attach crashes EM
+      EM.watch(r) do |connection|
+        connection.detach
+      end
+    }
+
+    assert true
+  end
 end
 

data/tests/test_file_watch.rb

@@ -34,6 +34,7 @@ class TestFileWatch < Test::Unit::TestCase
     end
 
     def test_events
+      omit_if(solaris?)
       EM.run{
         file = Tempfile.new('em-watch')
         $tmp_path = file.path

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_httpclient.rb

@@ -187,4 +187,47 @@ class TestHttpClient < Test::Unit::TestCase
     assert ok
   end
 
+  #-----------------------------------------
+
+  # Test a server that returns chunked encoding
+  #
+  class ChunkedEncodingContent < EventMachine::Connection
+    def initialize *args
+      super
+    end
+    def receive_data data
+      send_data ["HTTP/1.1 200 OK",
+                "Server: nginx/0.7.67", 
+                "Date: Sat, 23 Oct 2010 16:41:32 GMT",
+                "Content-Type: application/json",
+                "Transfer-Encoding: chunked",
+                "Connection: keep-alive",
+                "", 
+                "1800",
+                "chunk1" * 1024,
+                "5a",
+                "chunk2" * 15,
+                "0",
+                ""].join("\r\n")
+      close_connection_after_writing
+    end
+  end
+
+  def test_http_chunked_encoding_content
+    ok = false
+    EventMachine.run {
+      EventMachine.start_server "127.0.0.1", 9701, ChunkedEncodingContent
+      c = EventMachine::Protocols::HttpClient.send :request, :host => "127.0.0.1", :port => 9701
+      c.callback {|result|
+        if result[:content] == "chunk1" * 1024 + "chunk2" * 15
+          ok = true
+        end
+        EventMachine.stop
+      }
+    }
+    assert ok
+  end
+
 end
+
+

data/tests/test_idle_connection.rb

@@ -9,15 +9,17 @@ class TestIdleConnection < Test::Unit::TestCase
           $idle_time = conn.get_idle_time
           conn.send_data "GET / HTTP/1.0\r\n\r\n"
           EM.next_tick{
-            $idle_time_after_send = conn.get_idle_time
-            conn.close_connection
-            EM.stop
+            EM.next_tick{
+              $idle_time_after_send = conn.get_idle_time
+              conn.close_connection
+              EM.stop
+            }
           }
         }
       }
 
       assert_in_delta 3, $idle_time, 0.2
-      assert_equal 0, $idle_time_after_send
+      assert_in_delta 0, $idle_time_after_send, 0.1
     end
   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