eventmachine-le 1.1.0.beta.1

data/tests/test_ssl_methods.rb

@@ -0,0 +1,48 @@
+require 'em_test_helper'
+
+class TestSSLMethods < Test::Unit::TestCase
+
+  module ServerHandler
+
+    def post_init
+      start_tls
+    end
+
+    def ssl_handshake_completed
+      $server_called_back = true
+      $server_cert_value = get_peer_cert
+    end
+
+  end
+
+  module ClientHandler
+
+    def post_init
+      start_tls
+    end
+
+    def ssl_handshake_completed
+      $client_called_back = true
+      $client_cert_value = get_peer_cert
+      EM.stop_event_loop
+    end
+
+  end
+
+  def test_ssl_methods
+    $server_called_back, $client_called_back = false, false
+    $server_cert_value, $client_cert_value = nil, nil
+
+    EM.run {
+      EM.start_server("127.0.0.1", 9999, ServerHandler)
+      EM.connect("127.0.0.1", 9999, ClientHandler)
+    }
+
+    assert($server_called_back)
+    assert($client_called_back)
+
+    assert($server_cert_value.is_a?(NilClass))
+    assert($client_cert_value.is_a?(String))
+  end
+
+end if EM.ssl?

data/tests/test_ssl_verify.rb

@@ -0,0 +1,82 @@
+require 'em_test_helper'
+
+if EM.ssl?
+  class TestSslVerify < Test::Unit::TestCase
+    def setup
+      $dir = File.dirname(File.expand_path(__FILE__)) + '/'
+      $cert_from_file = File.read($dir+'client.crt')
+    end
+
+    module Client
+      def connection_completed
+        start_tls(:private_key_file => $dir+'client.key', :cert_chain_file => $dir+'client.crt')
+      end
+
+      def ssl_handshake_completed
+        $client_handshake_completed = true
+        close_connection
+      end
+
+      def unbind
+        EM.stop_event_loop
+      end
+    end
+
+    module AcceptServer
+      def post_init
+        start_tls(:verify_peer => true)
+      end
+
+      def ssl_verify_peer(cert)
+        $cert_from_server = cert
+        true
+      end
+
+      def ssl_handshake_completed
+        $server_handshake_completed = true
+      end
+    end
+
+    module DenyServer
+      def post_init
+        start_tls(:verify_peer => true)
+      end
+
+      def ssl_verify_peer(cert)
+        $cert_from_server = cert
+        # Do not accept the peer. This should now cause the connection to shut down without the SSL handshake being completed.
+        false
+      end
+
+      def ssl_handshake_completed
+        $server_handshake_completed = true
+      end
+    end
+
+    def test_accept_server
+      $client_handshake_completed, $server_handshake_completed = false, false
+      EM.run {
+        EM.start_server("127.0.0.1", 16784, AcceptServer)
+        EM.connect("127.0.0.1", 16784, Client).instance_variable_get("@signature")
+      }
+
+      assert_equal($cert_from_file, $cert_from_server)
+      assert($client_handshake_completed)
+      assert($server_handshake_completed)
+    end
+
+    def test_deny_server
+      $client_handshake_completed, $server_handshake_completed = false, false
+      EM.run {
+        EM.start_server("127.0.0.1", 16784, DenyServer)
+        EM.connect("127.0.0.1", 16784, Client)
+      }
+
+      assert_equal($cert_from_file, $cert_from_server)
+      assert(!$client_handshake_completed)
+      assert(!$server_handshake_completed)
+    end
+  end
+else
+  warn "EM built without SSL support, skipping tests in #{__FILE__}"
+end

data/tests/test_threaded_resource.rb

@@ -0,0 +1,55 @@
+require 'em_test_helper'
+
+class TestThreadedResource < Test::Unit::TestCase
+  def object
+    @object ||= {}
+  end
+
+  def resource
+    @resource = EM::ThreadedResource.new do
+      object
+    end
+  end
+
+  def teardown
+    resource.shutdown
+  end
+
+  def test_dispatch_completion
+    EM.run do
+      completion = resource.dispatch do |o|
+        o[:foo] = :bar
+        :foo
+      end
+      completion.callback do |result|
+        assert_equal :foo, result
+        EM.stop
+      end
+    end
+    assert_equal :bar, object[:foo]
+  end
+
+  def test_dispatch_failure
+    completion = resource.dispatch do |o|
+      raise 'boom'
+    end
+    completion.errback do |error|
+      assert_kind_of RuntimeError, error
+      assert_equal 'boom', error.message
+    end
+  end
+
+  def test_dispatch_threading
+    main = Thread.current
+    resource.dispatch do |o|
+      o[:dispatch_thread] = Thread.current
+    end
+    assert_not_equal main, object[:dispatch_thread]
+  end
+
+  def test_shutdown
+    # This test should get improved sometime. The method returning thread is
+    # NOT an api that will be maintained.
+    assert !resource.shutdown.alive?
+  end
+end

data/tests/test_tick_loop.rb

@@ -0,0 +1,59 @@
+require "test/unit"
+require 'em_test_helper'
+
+class TestEmTickLoop < Test::Unit::TestCase
+  def test_em_tick_loop
+    i = 0
+    EM.tick_loop { i += 1; EM.stop if i == 10 }
+    EM.run { EM.add_timer(1) { EM.stop } }
+    assert_equal i, 10
+  end
+  
+  def test_tick_loop_on_stop
+    t = nil
+    tick_loop = EM.tick_loop { :stop }
+    tick_loop.on_stop { t = true }
+    EM.run { EM.next_tick { EM.stop } }
+    assert t
+  end
+  
+  def test_start_twice
+    i = 0
+    s = 0
+    tick_loop = EM.tick_loop { i += 1; :stop }
+    tick_loop.on_stop { s += 1; EM.stop }
+    EM.run { EM.next_tick { EM.stop } }
+    assert_equal 1, i
+    assert_equal 1, s
+    tick_loop.start
+    EM.run { EM.next_tick { EM.stop } }
+    assert_equal 2, i
+    assert_equal 1, s # stop callbacks are only called once
+  end
+  
+  def test_stop
+    i, s = 0, 0
+    tick_loop = EM.tick_loop { i += 1 }
+    tick_loop.on_stop { s += 1 }
+    EM.run { EM.next_tick { tick_loop.stop; EM.next_tick { EM.stop } } }
+    assert tick_loop.stopped?
+    assert_equal 1, i
+    assert_equal 1, s
+  end
+  
+  def test_immediate_stops
+    s = 0
+    tick_loop = EM::TickLoop.new { }
+    tick_loop.on_stop { s += 1 }
+    tick_loop.on_stop { s += 1 }
+    assert_equal 2, s
+  end
+  
+  def test_stopped
+    tick_loop = EM::TickLoop.new { }
+    assert tick_loop.stopped?
+    tick_loop.start
+    assert !tick_loop.stopped?
+  end
+    
+end

data/tests/test_timers.rb

@@ -0,0 +1,180 @@
+require 'em_test_helper'
+
+class TestTimers < Test::Unit::TestCase
+
+  def test_timer_with_block
+    x = false
+    EM.run {
+      EM::Timer.new(0) {
+        x = true
+        EM.stop
+      }
+    }
+    assert x
+  end
+
+  def test_timer_with_proc
+    x = false
+    EM.run {
+      EM::Timer.new(0, proc {
+        x = true
+        EM.stop
+      })
+    }
+    assert x
+  end
+
+  def test_timer_cancel
+    assert_nothing_raised do
+      EM.run {
+        timer = EM::Timer.new(0.01) { flunk "Timer was not cancelled." }
+        timer.cancel
+
+        EM.add_timer(0.02) { EM.stop }
+      }
+    end
+  end
+
+  def test_periodic_timer
+    x = 0
+    EM.run {
+      EM::PeriodicTimer.new(0.01) do
+        x += 1
+        EM.stop if x == 4
+      end
+    }
+
+    assert_equal 4, x
+  end
+
+  def test_add_periodic_timer
+    x = 0
+    EM.run {
+      t = EM.add_periodic_timer(0.01) do
+        x += 1
+        EM.stop  if x == 4
+      end
+      assert t.respond_to?(:cancel)
+    }
+    assert_equal 4, x
+  end
+
+  def test_periodic_timer_cancel
+    x = 0
+    EM.run {
+      pt = EM::PeriodicTimer.new(0.01) { x += 1 }
+      pt.cancel
+      EM::Timer.new(0.02) { EM.stop }
+    }
+    assert_equal 0, x
+  end
+
+  def test_add_periodic_timer_cancel
+    x = 0
+    EM.run {
+      pt = EM.add_periodic_timer(0.01) { x += 1 }
+      EM.cancel_timer(pt)
+      EM.add_timer(0.02) { EM.stop }
+    }
+    assert_equal 0, x
+  end
+
+  def test_periodic_timer_self_cancel
+    x = 0
+    EM.run {
+      pt = EM::PeriodicTimer.new(0) {
+        x += 1
+        if x == 4
+          pt.cancel
+          EM.stop
+        end
+      }
+    }
+    assert_equal 4, x
+  end
+
+  def test_restartable_timer
+    x = false
+    EventMachine.run {
+      EventMachine::RestartableTimer.new(0.1) do
+        x = true
+        EventMachine.stop
+      end
+    }
+    assert x
+  end
+
+  def test_add_restartable_timer
+    x = false
+    EventMachine.run {
+      rt = EventMachine.add_restartable_timer(0.1) { x = true }
+      assert rt.respond_to?(:restart)
+      EventMachine.stop
+    }
+  end
+
+  def test_restart_restartable_timer
+    x = false
+    EventMachine.run {
+      EventMachine.add_timer(0.4) { x = 1 }
+      rt = EventMachine::RestartableTimer.new(0.3) do
+        x = true
+      end
+      EventMachine.add_timer(0.2) { rt.restart }
+      EventMachine.add_timer(0.6) { EventMachine.stop }
+    }
+    assert x == true
+  end
+
+  def test_cannot_restart_already_fired_restartable_timer
+    x = false
+    EventMachine.run {
+      rt = EventMachine::RestartableTimer.new(0.1) do
+        x = true
+      end
+      EventMachine.add_timer(0.2) {
+        x = false
+        rt.restart
+      }
+      EventMachine.add_timer(0.4) { EventMachine.stop }
+    }
+    assert !x
+  end
+
+  def test_restartable_timer_cancel
+    x = false
+    EventMachine.run {
+      rt = EventMachine::RestartableTimer.new(0.3) { x = true }
+      rt.cancel
+      EventMachine::Timer.new(0.1) { EventMachine.stop }
+    }
+    assert !x
+  end
+
+  def test_add_restartable_timer_cancel
+    x = false
+    EventMachine.run {
+      rt = EventMachine.add_restartable_timer(0.2) { x = true }
+      EventMachine.cancel_timer(rt)
+      EventMachine.add_timer(0.3) { EventMachine.stop }
+    }
+    assert !x
+  end
+
+  def test_cannot_restart_cancelled_restartable_timer
+    x = false
+    EventMachine.run {
+      rt = EventMachine::RestartableTimer.new(0.2) do
+        x = true
+      end
+      rt.cancel
+      EventMachine.add_timer(0.1) {
+        x = false
+        rt.restart
+      }
+      EventMachine.add_timer(0.4) { EventMachine.stop }
+    }
+    assert !x
+  end
+
+end

data/tests/test_ud.rb

@@ -0,0 +1,8 @@
+require 'em_test_helper'
+
+class TestUserDefinedEvents < Test::Unit::TestCase
+
+  def test_a
+  end
+
+end

data/tests/test_udp46.rb

@@ -0,0 +1,53 @@
+require 'em_test_helper'
+
+class TestUDP46 < Test::Unit::TestCase
+
+  # this is a bit brittle.  Maybe do not test for the actual error...
+  WANT_ALL = [
+              ( RUBY_PLATFORM =~ /darwin1/ and # not an error in Linux (!?),
+                # strange handling in OSX 10.5.x (darwin9)
+                ["::1", "::241.1.2.3", 5555, Errno::EHOSTUNREACH]),
+              ["::1", "241.2.3.4", 5555,
+               (RUBY_PLATFORM =~ /linux/ ? Errno::ENETUNREACH : Errno::EINVAL)],
+              ["127.0.0.1", "241.4.5.6", 5555,
+               (RUBY_PLATFORM =~ /linux/ ? Errno::EINVAL : Errno::ENETUNREACH)]
+             ].compact
+
+  # Open a UDP socket listening on, say, ::1, and try to send a UDP
+  # datagram to IP address, say, ::241.1.2.3 (so no network route).
+  # Without the error handling fix, it makes EM close the UDP socket.
+  def test_udp_no_route
+    WANT_ALL.each do |want|
+      @@udp_socket_alive = false
+      @@udp_socket_unbind_cause = nil
+      @@error_came_in = false
+
+      EM.run do
+
+        EM::open_datagram_socket(want[0], next_port, EM::Connection) do |c|
+          c.send_error_handling = :ERRORHANDLING_REPORT
+
+          def c.unbind cause=nil
+            @@udp_socket_unbind_cause = cause
+            EM.stop
+          end
+
+          def c.receive_senderror(error, data)
+            @@error_came_in = [error, data]
+          end
+
+          c.send_datagram "no-route", want[1], want[2]
+          EM.add_timer(0.2) do
+            @@udp_socket_alive = true  unless c.error?
+            EM.stop
+          end
+        end
+
+      end
+
+      assert @@udp_socket_alive, "UDP socket was killed (unbind cause: #{@@udp_socket_unbind_cause})"
+      assert_equal [want[3], [want[1], want[2].to_s]], @@error_came_in
+
+    end
+  end
+end