eventmachine 1.0.9.1-java → 1.2.0.1-java

data/tests/test_iterator.rb

@@ -21,6 +21,22 @@ class TestIterator < Test::Unit::TestCase
     assert_equal(list.to_a.sort, items.values.flatten.sort)
   end
 
+  def test_default_concurrency_with_a_proc
+    items = {}
+    list = (1..10).to_a
+    original_list = list.dup
+    EM.run {
+      EM::Iterator.new(proc{list.pop || EM::Iterator::Stop}).each( proc {|num,iter|
+        time = get_time
+        items[time] ||= []
+        items[time] << num
+        EM::Timer.new(1) {iter.next}
+      }, proc {EM.stop})
+    }
+    assert_equal(10, items.keys.size)
+    assert_equal(original_list.to_a.sort, items.values.flatten.sort)
+  end
+
   def test_concurrency_bigger_than_list_size
     items = {}
     list = [1,2,3]
@@ -72,6 +88,8 @@ class TestIterator < Test::Unit::TestCase
   end
 
   def test_inject
+    omit_if(windows?)
+
     list = %w[ pwd uptime uname date ]
     EM.run {
       EM::Iterator.new(list, 2).inject({}, proc{ |hash,cmd,iter|

data/tests/test_many_fds.rb

@@ -9,7 +9,7 @@ class TestManyFDs < Test::Unit::TestCase
   def test_connection_class_cache
     mod = Module.new
     a = nil
-    Process.setrlimit(Process::RLIMIT_NOFILE,4096);
+    Process.setrlimit(Process::RLIMIT_NOFILE, 4096) rescue nil
     EM.run {
       EM.start_server '127.0.0.1', @port, mod
       1100.times do

data/tests/test_queue.rb

@@ -47,4 +47,18 @@ class TestEMQueue < Test::Unit::TestCase
     EM.run { EM.next_tick { EM.stop } }
     assert_equal many, q.num_waiting
   end
+
+  def test_big_queue
+    EM.run do
+      q = EM::Queue.new
+      2000.times do |i|
+        q.push(*0..1000)
+        q.pop { |v| assert_equal v, i % 1001 }
+      end
+      q.pop do
+        assert_equal 1_999_999, q.size
+        EM.stop
+      end
+    end
+  end
 end

data/tests/test_resolver.rb

@@ -1,7 +1,24 @@
 require 'em_test_helper'
 
 class TestResolver < Test::Unit::TestCase
+  def test_nameserver
+    assert_kind_of(String, EM::DNS::Resolver.nameserver)
+  end
+
+  def test_nameservers
+    assert_kind_of(Array, EM::DNS::Resolver.nameservers)
+  end
+
+  def test_hosts
+    assert_kind_of(Hash, EM::DNS::Resolver.hosts)
+
+    # Make sure that blank or comment lines are skipped
+    refute(EM::DNS::Resolver.hosts.include? nil)
+  end
+
   def test_a
+    pend('FIXME: this test is broken on Windows') if windows?
+
     EM.run {
       d = EM::DNS::Resolver.resolve "google.com"
       d.errback { assert false }
@@ -29,6 +46,8 @@ class TestResolver < Test::Unit::TestCase
   end
 
   def test_a_pair
+    pend('FIXME: this test is broken on Windows') if windows?
+
     EM.run {
       d = EM::DNS::Resolver.resolve "yahoo.com"
       d.errback { |err| assert false, "failed to resolve yahoo.com: #{err}" }
@@ -41,6 +60,8 @@ class TestResolver < Test::Unit::TestCase
   end
 
   def test_localhost
+    pend('FIXME: this test is broken on Windows') if windows?
+
     EM.run {
       d = EM::DNS::Resolver.resolve "localhost"
       d.errback { assert false }
@@ -54,6 +75,8 @@ class TestResolver < Test::Unit::TestCase
   end
 
   def test_timer_cleanup
+    pend('FIXME: this test is broken on Windows') if windows?
+
     EM.run {
       d = EM::DNS::Resolver.resolve "google.com"
       d.errback { |err| assert false, "failed to resolve google.com: #{err}" }

data/tests/test_set_sock_opt.rb

@@ -15,6 +15,8 @@ class TestSetSockOpt < Test::Unit::TestCase
     #-------------------------------------
 
     def test_set_sock_opt
+      omit_if(windows?)
+
       test = self
       EM.run do
         EM.connect 'google.com', 80, Module.new {

data/tests/test_ssl_dhparam.rb

@@ -0,0 +1,83 @@
+require 'em_test_helper'
+
+class TestSslDhParam < Test::Unit::TestCase
+  def setup
+    $dir = File.dirname(File.expand_path(__FILE__)) + '/'
+    $dhparam_file = File.join($dir, 'dhparam.pem')
+  end
+
+  module Client
+    def connection_completed
+      start_tls
+    end
+
+    def ssl_handshake_completed
+      $client_handshake_completed = true
+      $client_cipher_name = get_cipher_name
+      close_connection
+    end
+
+    def unbind
+      EM.stop_event_loop
+    end
+  end
+
+  module Server
+    def post_init
+      start_tls(:dhparam => $dhparam_file, :cipher_list => "DHE,EDH")
+    end
+
+    def ssl_handshake_completed
+      $server_handshake_completed = true
+      $server_cipher_name = get_cipher_name
+    end
+  end
+
+  module NoDhServer
+    def post_init
+      start_tls(:cipher_list => "DHE,EDH")
+    end
+
+    def ssl_handshake_completed
+      $server_handshake_completed = true
+      $server_cipher_name = get_cipher_name
+    end
+  end
+
+  def test_no_dhparam
+    omit_unless(EM.ssl?)
+    omit_if(rbx?)
+
+    $client_handshake_completed, $server_handshake_completed = false, false
+    $server_cipher_name, $client_cipher_name = nil, nil
+
+    EM.run {
+      EM.start_server("127.0.0.1", 16784, NoDhServer)
+      EM.connect("127.0.0.1", 16784, Client)
+    }
+
+    assert(!$client_handshake_completed)
+    assert(!$server_handshake_completed)
+  end
+
+  def test_dhparam
+    omit_unless(EM.ssl?)
+    omit_if(rbx?)
+
+    $client_handshake_completed, $server_handshake_completed = false, false
+    $server_cipher_name, $client_cipher_name = nil, nil
+
+    EM.run {
+      EM.start_server("127.0.0.1", 16784, Server)
+      EM.connect("127.0.0.1", 16784, Client)
+    }
+
+    assert($client_handshake_completed)
+    assert($server_handshake_completed)
+
+    assert($client_cipher_name.length > 0)
+    assert_equal($client_cipher_name, $server_cipher_name)
+
+    assert_match(/^(DHE|EDH)/, $client_cipher_name)
+  end
+end

data/tests/test_ssl_ecdh_curve.rb

@@ -0,0 +1,79 @@
+require 'em_test_helper'
+
+class TestSslEcdhCurve < Test::Unit::TestCase
+  module Client
+    def connection_completed
+      start_tls
+    end
+
+    def ssl_handshake_completed
+      $client_handshake_completed = true
+      $client_cipher_name = get_cipher_name
+      close_connection
+    end
+
+    def unbind
+      EM.stop_event_loop
+    end
+  end
+
+  module Server
+    def post_init
+      start_tls(:ecdh_curve => "prime256v1", :cipher_list => "ECDH")
+    end
+
+    def ssl_handshake_completed
+      $server_handshake_completed = true
+      $server_cipher_name = get_cipher_name
+    end
+  end
+
+  module NoCurveServer
+    def post_init
+      start_tls(:cipher_list => "ECDH")
+    end
+
+    def ssl_handshake_completed
+      $server_handshake_completed = true
+      $server_cipher_name = get_cipher_name
+    end
+  end
+
+  def test_no_ecdh_curve
+    omit_unless(EM.ssl?)
+    omit_if(rbx?)
+
+    $client_handshake_completed, $server_handshake_completed = false, false
+
+    EM.run {
+      EM.start_server("127.0.0.1", 16784, NoCurveServer)
+      EM.connect("127.0.0.1", 16784, Client)
+    }
+
+    assert(!$client_handshake_completed)
+    assert(!$server_handshake_completed)
+  end
+
+  def test_ecdh_curve
+    omit_unless(EM.ssl?)
+    omit_if(rbx?)
+
+    $client_handshake_completed, $server_handshake_completed = false, false
+    $server_cipher_name, $client_cipher_name = nil, nil
+
+    EM.run {
+      EM.start_server("127.0.0.1", 16784, Server)
+      EM.connect("127.0.0.1", 16784, Client)
+    }
+
+    assert($client_handshake_completed)
+    assert($server_handshake_completed)
+
+    assert($client_cipher_name.length > 0)
+    assert_equal($client_cipher_name, $server_cipher_name)
+
+    assert_match(/^(AECDH|ECDHE)/, $client_cipher_name)
+  end
+
+
+end

data/tests/test_ssl_extensions.rb

@@ -0,0 +1,49 @@
+require 'em_test_helper'
+
+require 'socket'
+require 'openssl'
+
+if EM.ssl?
+  class TestSslExtensions < Test::Unit::TestCase
+
+    module Client
+      def ssl_handshake_completed
+        $client_handshake_completed = true
+        close_connection
+      end
+
+      def unbind
+        EM.stop_event_loop
+      end
+
+      def connection_completed
+        start_tls(:ssl_version => :tlsv1, :sni_hostname => 'example.com')
+      end
+    end
+
+    module Server
+      def ssl_handshake_completed
+        $server_handshake_completed = true
+        $server_sni_hostname = get_sni_hostname
+      end
+
+      def post_init
+        start_tls(:ssl_version => :TLSv1)
+      end
+    end
+
+    def test_tlsext_sni_hostname
+      $server_handshake_completed = false
+
+      EM.run do
+        EM.start_server("127.0.0.1", 16784, Server)
+        EM.connect("127.0.0.1", 16784, Client)
+      end
+
+      assert($server_handshake_completed)
+      assert_equal('example.com', $server_sni_hostname)
+    end
+  end
+else
+  warn "EM built without SSL support, skipping tests in #{__FILE__}"
+end

data/tests/test_ssl_methods.rb

@@ -10,6 +10,9 @@ class TestSSLMethods < Test::Unit::TestCase
     def ssl_handshake_completed
       $server_called_back = true
       $server_cert_value = get_peer_cert
+      $server_cipher_bits = get_cipher_bits
+      $server_cipher_name = get_cipher_name
+      $server_cipher_protocol = get_cipher_protocol
     end
   end
 
@@ -21,6 +24,9 @@ class TestSSLMethods < Test::Unit::TestCase
     def ssl_handshake_completed
       $client_called_back = true
       $client_cert_value = get_peer_cert
+      $client_cipher_bits = get_cipher_bits
+      $client_cipher_name = get_cipher_name
+      $client_cipher_protocol = get_cipher_protocol
       EM.stop_event_loop
     end
   end
@@ -30,6 +36,9 @@ class TestSSLMethods < Test::Unit::TestCase
     omit_if(rbx?)
     $server_called_back, $client_called_back = false, false
     $server_cert_value, $client_cert_value = nil, nil
+    $server_cipher_bits, $client_cipher_bits = nil, nil
+    $server_cipher_name, $client_cipher_name = nil, nil
+    $server_cipher_protocol, $client_cipher_protocol = nil, nil
 
     EM.run {
       EM.start_server("127.0.0.1", 9999, ServerHandler)
@@ -41,6 +50,16 @@ class TestSSLMethods < Test::Unit::TestCase
 
     assert($server_cert_value.is_a?(NilClass))
     assert($client_cert_value.is_a?(String))
+
+    assert($client_cipher_bits > 0)
+    assert_equal($client_cipher_bits, $server_cipher_bits)
+
+    assert($client_cipher_name.length > 0)
+    assert_match(/AES/, $client_cipher_name)
+    assert_equal($client_cipher_name, $server_cipher_name)
+
+    assert_match(/TLS/, $client_cipher_protocol)
+    assert_equal($client_cipher_protocol, $server_cipher_protocol)
   end
 
 end

data/tests/test_ssl_protocols.rb

@@ -0,0 +1,246 @@
+require 'em_test_helper'
+
+require 'socket'
+require 'openssl'
+
+if EM.ssl?
+  class TestSslProtocols < Test::Unit::TestCase
+
+    module Client
+      def ssl_handshake_completed
+        $client_handshake_completed = true
+        close_connection
+      end
+
+      def unbind
+        EM.stop_event_loop
+      end
+    end
+
+    module Server
+      def ssl_handshake_completed
+        $server_handshake_completed = true
+      end
+    end
+
+    module ClientAny
+      include Client
+      def connection_completed
+        start_tls(:ssl_version => %w(sslv2 sslv3 tlsv1 tlsv1_1 tlsv1_2))
+      end
+    end
+
+    module ClientDefault
+      include Client
+      def connection_completed
+        start_tls
+      end
+    end
+
+    module ClientSSLv3
+      include Client
+      def connection_completed
+        start_tls(:ssl_version => %w(SSLv3))
+      end
+    end
+
+    module ServerSSLv3
+      include Server
+      def post_init
+        start_tls(:ssl_version => %w(SSLv3))
+      end
+    end
+
+    module ServerTLSv1CaseInsensitive
+      include Server
+      def post_init
+        start_tls(:ssl_version => %w(tlsv1))
+      end
+    end
+
+    module ServerAny
+      include Server
+      def post_init
+        start_tls(:ssl_version => %w(sslv2 sslv3 tlsv1 tlsv1_1 tlsv1_2))
+      end
+    end
+
+    module ServerDefault
+      include Server
+      def post_init
+        start_tls
+      end
+    end
+
+    module InvalidProtocol
+      include Client
+      def post_init
+        start_tls(:ssl_version => %w(tlsv1 badinput))
+      end
+    end
+
+    def test_invalid_ssl_version
+      assert_raises(RuntimeError, "Unrecognized SSL/TLS Version: badinput") do
+        EM.run do
+          EM.start_server("127.0.0.1", 16784, InvalidProtocol)
+          EM.connect("127.0.0.1", 16784, InvalidProtocol)
+        end
+      end
+    end
+
+    def test_any_to_v3
+      $client_handshake_completed, $server_handshake_completed = false, false
+      EM.run do
+        EM.start_server("127.0.0.1", 16784, ServerSSLv3)
+        EM.connect("127.0.0.1", 16784, ClientAny)
+      end
+
+      assert($client_handshake_completed)
+      assert($server_handshake_completed)
+    end
+
+    def test_case_insensitivity
+      $client_handshake_completed, $server_handshake_completed = false, false
+      EM.run do
+        EM.start_server("127.0.0.1", 16784, ServerTLSv1CaseInsensitive)
+        EM.connect("127.0.0.1", 16784, ClientAny)
+      end
+
+      assert($client_handshake_completed)
+      assert($server_handshake_completed)
+    end
+
+    def test_v3_to_any
+      $client_handshake_completed, $server_handshake_completed = false, false
+      EM.run do
+        EM.start_server("127.0.0.1", 16784, ServerAny)
+        EM.connect("127.0.0.1", 16784, ClientSSLv3)
+      end
+
+      assert($client_handshake_completed)
+      assert($server_handshake_completed)
+    end
+
+    def test_v3_to_v3
+      $client_handshake_completed, $server_handshake_completed = false, false
+      EM.run do
+        EM.start_server("127.0.0.1", 16784, ServerSSLv3)
+        EM.connect("127.0.0.1", 16784, ClientSSLv3)
+      end
+
+      assert($client_handshake_completed)
+      assert($server_handshake_completed)
+    end
+
+    def test_any_to_any
+      $client_handshake_completed, $server_handshake_completed = false, false
+      EM.run do
+        EM.start_server("127.0.0.1", 16784, ServerAny)
+        EM.connect("127.0.0.1", 16784, ClientAny)
+      end
+
+      assert($client_handshake_completed)
+      assert($server_handshake_completed)
+    end
+
+    def test_default_to_default
+      $client_handshake_completed, $server_handshake_completed = false, false
+      EM.run do
+        EM.start_server("127.0.0.1", 16784, ServerDefault)
+        EM.connect("127.0.0.1", 16784, ClientDefault)
+      end
+
+      assert($client_handshake_completed)
+      assert($server_handshake_completed)
+    end
+
+    module ServerV3StopAfterHandshake
+      def post_init
+        start_tls(:ssl_version => %w(SSLv3))
+      end
+
+      def ssl_handshake_completed
+        $server_handshake_completed = true
+        EM.stop_event_loop
+      end
+    end
+
+    module ServerTLSv1StopAfterHandshake
+      def post_init
+        start_tls(:ssl_version => %w(TLSv1))
+      end
+
+      def ssl_handshake_completed
+        $server_handshake_completed = true
+        EM.stop_event_loop
+      end
+    end
+
+    def test_v3_with_external_client
+      $server_handshake_completed = false
+      EM.run do
+        setup_timeout(2)
+        EM.start_server("127.0.0.1", 16784, ServerV3StopAfterHandshake)
+        EM.defer do
+          sock = TCPSocket.new("127.0.0.1", 16784)
+          ctx = OpenSSL::SSL::SSLContext.new
+          ctx.ssl_version = :SSLv3_client
+          ssl = OpenSSL::SSL::SSLSocket.new(sock, ctx)
+          ssl.connect
+          ssl.close rescue nil
+          sock.close rescue nil
+        end
+      end
+
+      assert($server_handshake_completed)
+    end
+
+    def test_tlsv1_with_external_client
+      $server_handshake_completed = false
+      EM.run do
+        setup_timeout(2)
+        EM.start_server("127.0.0.1", 16784, ServerTLSv1StopAfterHandshake)
+        EM.defer do
+          sock = TCPSocket.new("127.0.0.1", 16784)
+          ctx = OpenSSL::SSL::SSLContext.new
+          ctx.ssl_version = :TLSv1_client
+          ssl = OpenSSL::SSL::SSLSocket.new(sock, ctx)
+          ssl.connect
+          ssl.close rescue nil
+          sock.close rescue nil
+        end
+      end
+
+      assert($server_handshake_completed)
+    end
+
+    def test_tlsv1_required_with_external_client
+      $server_handshake_completed = false
+
+      EM.run do
+        n = 0
+        EM.add_periodic_timer(0.5) do
+          n += 1
+          (EM.stop rescue nil) if n == 2
+        end
+        EM.start_server("127.0.0.1", 16784, ServerTLSv1StopAfterHandshake)
+        EM.defer do
+          sock = TCPSocket.new("127.0.0.1", 16784)
+          ctx = OpenSSL::SSL::SSLContext.new
+          ctx.ssl_version = :SSLv3_client
+          ssl = OpenSSL::SSL::SSLSocket.new(sock, ctx)
+          assert_raise OpenSSL::SSL::SSLError do
+            ssl.connect
+          end
+          ssl.close rescue nil
+          sock.close rescue nil
+          EM.stop rescue nil
+        end
+      end
+
+      assert(!$server_handshake_completed)
+    end
+  end
+else
+  warn "EM built without SSL support, skipping tests in #{__FILE__}"
+end