eventmachine-le 1.1.0.beta.1

data/tests/test_connection_count.rb

@@ -0,0 +1,33 @@
+require 'em_test_helper'
+
+class TestConnectionCount < Test::Unit::TestCase
+  def test_idle_connection_count
+    EM.run {
+      $count = EM.connection_count
+      EM.stop_event_loop
+    }
+
+    assert_equal(0, $count)
+  end
+
+  module Client
+    def connection_completed
+      $client_conns += 1
+      EM.stop if $client_conns == 3
+    end
+  end
+
+  def test_with_some_connections
+    EM.run {
+      $client_conns = 0
+      $initial_conns = EM.connection_count
+      EM.start_server("127.0.0.1", 9999)
+      $server_conns = EM.connection_count
+      3.times { EM.connect("127.0.0.1", 9999, Client) }
+    }
+
+    assert_equal(0, $initial_conns)
+    assert_equal(1, $server_conns)
+    assert_equal(4, $client_conns + $server_conns)
+  end
+end

data/tests/test_defer.rb

@@ -0,0 +1,18 @@
+require 'em_test_helper'
+
+class TestDefer < Test::Unit::TestCase
+
+  def test_defers
+    n = 0
+    n_times = 20
+    EM.run {
+      n_times.times {
+        work_proc = proc { n += 1 }
+        callback = proc { EM.stop if n == n_times }
+        EM.defer work_proc, callback
+      }
+    }
+    assert_equal( n, n_times )
+  end
+
+end

data/tests/test_deferrable.rb

@@ -0,0 +1,35 @@
+require 'em_test_helper'
+
+class TestDeferrable < Test::Unit::TestCase
+  class Later
+    include EM::Deferrable
+  end
+
+  def test_timeout_without_args
+    assert_nothing_raised do
+      EM.run {
+        df = Later.new
+        df.timeout(0)
+        df.errback { EM.stop }
+        EM.add_timer(0.01) { flunk "Deferrable was not timed out." }
+      }
+    end
+  end
+
+  def test_timeout_with_args
+    args = nil
+
+    EM.run {
+      df = Later.new
+      df.timeout(0, :timeout, :foo)
+      df.errback do |type, name|
+        args = [type, name]
+        EM.stop
+      end
+
+      EM.add_timer(0.01) { flunk "Deferrable was not timed out." }
+    }
+
+    assert_equal [:timeout, :foo], args
+  end
+end

data/tests/test_epoll.rb

@@ -0,0 +1,134 @@
+require 'em_test_helper'
+
+
+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
+
+
+  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 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
+  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
+    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 setup
+    @port = next_port
+  end
+
+  module TestDatagramServer
+    def receive_data dgm
+      $in = dgm
+      send_data "abcdefghij"
+    end
+  end
+  module TestDatagramClient
+    def initialize port
+      @port = port
+    end
+
+    def post_init
+      send_datagram "1234567890", $testing_localhost, @port
+    end
+
+    def receive_data dgm
+      $out = dgm
+      EM.stop
+    end
+  end
+
+  def test_datagrams
+    local_ips.each {  |localhost|
+      $testing_localhost = localhost
+      $in = $out = ""
+      EM.run {
+        setup_timeout(2)
+        EM.open_datagram_socket $testing_localhost, @port, TestDatagramServer
+        EM.open_datagram_socket $testing_localhost, 0, TestDatagramClient, @port
+      }
+      assert_equal( "1234567890", $in )
+      assert_equal( "abcdefghij", $out )
+    }
+  end
+
+  # XXX this test fails randomly..
+  def _test_unix_domain
+    fn = "/tmp/xxx.chain"
+    EM.epoll
+    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
+

data/tests/test_error_handler.rb

@@ -0,0 +1,38 @@
+require 'em_test_helper'
+
+class TestErrorHandler < Test::Unit::TestCase
+  def setup
+    @exception = Class.new(StandardError)
+  end
+
+  def test_error_handler
+    error = nil
+
+    EM.error_handler{ |e|
+      error = e
+      EM.error_handler(nil)
+      EM.stop
+    }
+
+    assert_nothing_raised do
+      EM.run{
+        EM.add_timer(0){
+          raise @exception, 'test'
+        }
+      }
+    end
+
+    assert_equal error.class, @exception
+    assert_equal error.message, 'test'
+  end
+
+  def test_without_error_handler
+    assert_raise @exception do
+      EM.run{
+        EM.add_timer(0){
+          raise @exception, 'test'
+        }
+      }
+    end
+  end
+end

data/tests/test_exc.rb

@@ -0,0 +1,28 @@
+require 'em_test_helper'
+
+class TestSomeExceptions < Test::Unit::TestCase
+
+  # Read the commentary in EM#run.
+  # This test exercises the ensure block in #run that makes sure
+  # EM#release_machine gets called even if an exception is
+  # thrown within the user code. Without the ensured call to release_machine,
+  # the second call to EM#run will fail with a C++ exception
+  # because the machine wasn't cleaned up properly.
+
+  def test_a
+    assert_raises(RuntimeError) {
+      EM.run {
+      raise "some exception"
+    }
+    }
+  end
+
+  def test_b
+    assert_raises(RuntimeError) {
+      EM.run {
+      raise "some exception"
+    }
+    }
+  end
+
+end

data/tests/test_file_watch.rb

@@ -0,0 +1,65 @@
+require 'em_test_helper'
+require 'tempfile'
+
+class TestFileWatch < Test::Unit::TestCase
+  if windows?
+    def test_watch_file_raises_unsupported_error
+      assert_raises(EM::Unsupported) do
+        EM.run do
+          file = Tempfile.new("fake_file")
+          EM.watch_file(file.path)
+        end
+      end
+    end
+  elsif EM.respond_to? :watch_filename
+    module FileWatcher
+      def file_modified
+        $modified = true
+      end
+      def file_deleted
+        $deleted = true
+      end
+      def unbind
+        $unbind = true
+        EM.stop
+      end
+    end
+
+    def setup
+      EM.kqueue = true if EM.kqueue?
+    end
+
+    def teardown
+      EM.kqueue = false if EM.kqueue?
+    end
+
+    def test_events
+      EM.run{
+        file = Tempfile.new('em-watch')
+        $tmp_path = file.path
+
+        # watch it
+        watch = EM.watch_file(file.path, FileWatcher)
+        $path = watch.path
+
+        # modify it
+        File.open(file.path, 'w'){ |f| f.puts 'hi' }
+
+        # delete it
+        EM.add_timer(0.01){ file.close; file.delete }
+      }
+
+      assert_equal($path, $tmp_path)
+      assert($modified)
+      assert($deleted)
+      assert($unbind)
+    end
+  else
+    warn "EM.watch_file not implemented, skipping tests in #{__FILE__}"
+
+    # Because some rubies will complain if a TestCase class has no tests
+    def test_em_watch_file_unsupported
+      assert true
+    end
+  end
+end

data/tests/test_futures.rb

@@ -0,0 +1,170 @@
+require 'em_test_helper'
+
+class TestFutures < Test::Unit::TestCase
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  def test_future
+      assert_equal(100, EM::Deferrable.future(100) )
+
+      p1 = proc { 100 + 1 }
+      assert_equal(101, EM::Deferrable.future(p1) )
+  end
+
+  class MyFuture
+      include EM::Deferrable
+      def initialize *args
+        super
+        set_deferred_status :succeeded, 40
+      end
+  end
+
+  class MyErrorFuture
+      include EM::Deferrable
+      def initialize *args
+        super
+        set_deferred_status :failed, 41
+      end
+  end
+
+
+  def test_future_1
+      # Call future with one additional argument and it will be treated as a callback.
+      def my_future
+        MyFuture.new
+      end
+
+      value = nil
+      EM::Deferrable.future my_future, proc {|v| value=v}
+      assert_equal( 40, value )
+  end
+
+
+  def test_future_2
+      # Call future with two additional arguments and they will be treated as a callback
+      # and an errback.
+      value = nil
+      EM::Deferrable.future MyErrorFuture.new, nil, proc {|v| value=v}
+      assert_equal( 41, value )
+  end
+
+
+  def test_future_3
+      # Call future with no additional arguments but with a block, and the block will be
+      # treated as a callback.
+      value = nil
+      EM::Deferrable.future MyFuture.new do |v|
+        value=v
+      end
+      assert_equal( 40, value )
+  end
+
+
+  class RecursiveCallback
+      include EM::Deferrable
+  end
+
+  # A Deferrable callback can call #set_deferred_status to change the values
+  # passed to subsequent callbacks.
+  #
+  def test_recursive_callbacks
+      n = 0 # counter assures that all the tests actually run.
+      rc = RecursiveCallback.new
+      rc.callback {|a|
+        assert_equal(100, a)
+        n += 1
+        rc.set_deferred_status :succeeded, 101, 101
+      }
+      rc.callback {|a,b|
+        assert_equal(101, a)
+        assert_equal(101, b)
+        n += 1
+        rc.set_deferred_status :succeeded, 102, 102, 102
+      }
+      rc.callback {|a,b,c|
+        assert_equal(102, a)
+        assert_equal(102, b)
+        assert_equal(102, c)
+        n += 1
+      }
+      rc.set_deferred_status :succeeded, 100
+      assert_equal(3, n)
+  end
+
+  def test_syntactic_sugar
+    rc = RecursiveCallback.new
+    rc.set_deferred_success 100
+    rc.set_deferred_failure 200
+  end
+
+  # It doesn't raise an error to set deferred status more than once.
+  # In fact, this is a desired and useful idiom when it happens INSIDE
+  # a callback or errback.
+  # However, it's less useful otherwise, and in fact would generally be
+  # indicative of a programming error. However, we would like to be resistant
+  # to such errors. So whenever we set deferred status, we also clear BOTH
+  # stacks of handlers.
+  #
+  def test_double_calls
+    s = 0
+    e = 0
+
+    d = EM::DefaultDeferrable.new
+    d.callback {s += 1}
+    d.errback {e += 1}
+
+    d.succeed	# We expect the callback to be called, and the errback to be DISCARDED.
+    d.fail	  # Presumably an error. We expect the errback NOT to be called.
+    d.succeed	# We expect the callback to have been discarded and NOT to be called again.
+
+    assert_equal(1, s)
+    assert_equal(0, e)
+  end
+
+  # Adding a callback to a Deferrable that is already in a success state executes the callback
+  # immediately. The same applies to a an errback added to an already-failed Deferrable.
+  # HOWEVER, we expect NOT to be able to add errbacks to succeeded Deferrables, or callbacks
+  # to failed ones.
+  #
+  # We illustrate this with a rather contrived test. The test calls #fail after #succeed,
+  # which ordinarily would not happen in a real program.
+  #
+  # What we're NOT attempting to specify is what happens if a Deferrable is succeeded and then
+  # failed (or vice-versa). Should we then be able to add callbacks/errbacks of the appropriate
+  # type for immediate execution? For now at least, the official answer is "don't do that."
+  #
+  def test_delayed_callbacks
+    s1 = 0
+    s2 = 0
+    e = 0
+
+    d = EM::DefaultDeferrable.new
+    d.callback {s1 += 1}
+
+    d.succeed # Triggers and discards the callback.
+
+    d.callback {s2 += 1} # This callback is executed immediately and discarded.
+
+    d.errback {e += 1} # This errback should be DISCARDED and never execute.
+    d.fail # To prove it, fail and assert e is 0
+
+    assert_equal( [1,1], [s1,s2] )
+    assert_equal( 0, e )
+  end
+
+  def test_timeout
+    n = 0
+    EM.run {
+      d = EM::DefaultDeferrable.new
+      d.callback {n = 1; EM.stop}
+      d.errback {n = 2; EM.stop}
+      d.timeout(0.01)
+    }
+    assert_equal( 2, n )
+  end
+
+end