sensu-em 2.0.0-java

data/tests/test_completion.rb

@@ -0,0 +1,177 @@
+require 'em/completion'
+
+class TestCompletion < Test::Unit::TestCase
+  def completion
+    @completion ||= EM::Completion.new
+  end
+
+  def crank
+    # This is a slow solution, but this just executes the next tick queue
+    # once. It's the easiest way for now.
+    EM.run { EM.stop }
+  end
+
+  def results
+    @results ||= []
+  end
+
+  def test_state
+    assert_equal :unknown, completion.state
+  end
+
+  def test_succeed
+    completion.callback { |val| results << val }
+    completion.succeed :object
+    crank
+    assert_equal :succeeded, completion.state
+    assert_equal [:object], results
+  end
+
+  def test_fail
+    completion.errback { |val| results << val }
+    completion.fail :object
+    crank
+    assert_equal :failed, completion.state
+    assert_equal [:object], results
+  end
+
+  def test_callback
+    completion.callback { results << :callback }
+    completion.errback  { results << :errback  }
+    completion.succeed
+    crank
+    assert_equal [:callback], results
+  end
+
+  def test_errback
+    completion.callback { results << :callback }
+    completion.errback  { results << :errback  }
+    completion.fail
+    crank
+    assert_equal [:errback], results
+  end
+
+  def test_stateback
+    completion.stateback(:magic) { results << :stateback }
+    completion.change_state(:magic)
+    crank
+    assert_equal [:stateback], results
+  end
+
+  def test_does_not_enqueue_when_completed
+    completion.callback { results << :callback }
+    completion.succeed
+    completion.errback  { results << :errback  }
+    completion.fail
+    crank
+    assert_equal [:callback], results
+  end
+
+  def test_completed
+    assert_equal false, completion.completed?
+    completion.succeed
+    assert_equal true, completion.completed?
+    completion.fail
+    assert_equal true, completion.completed?
+    completion.change_state :magic
+    assert_equal false, completion.completed?
+  end
+
+  def test_recursive_callbacks
+    completion.callback do |val|
+      results << val
+      completion.succeed :two
+    end
+    completion.callback do |val|
+      results << val
+      completion.succeed :three
+    end
+    completion.callback do |val|
+      results << val
+    end
+    completion.succeed :one
+    crank
+    assert_equal [:one, :two, :three], results
+  end
+
+  def test_late_defined_callbacks
+    completion.callback { results << :one }
+    completion.succeed
+    crank
+    assert_equal [:one], results
+    completion.callback { results << :two }
+    crank
+    assert_equal [:one, :two], results
+  end
+
+  def test_cleared_completions
+    completion.callback { results << :callback }
+    completion.errback  { results << :errback  }
+
+    completion.succeed
+    crank
+    completion.fail
+    crank
+    completion.succeed
+    crank
+
+    assert_equal [:callback], results
+  end
+
+  def test_skip_completed_callbacks
+    completion.callback { results << :callback }
+    completion.succeed
+    crank
+
+    completion.errback  { results << :errback  }
+    completion.fail
+    crank
+
+    assert_equal [:callback], results
+  end
+
+  def test_completions
+    completion.completion { results << :completion }
+    completion.succeed
+    crank
+    assert_equal [:completion], results
+
+    completion.change_state(:unknown)
+    results.clear
+
+    completion.completion { results << :completion }
+    completion.fail
+    crank
+    assert_equal [:completion], results
+  end
+
+  def test_latent_completion
+    completion.completion { results << :completion }
+    completion.succeed
+    crank
+    completion.completion { results << :completion }
+    crank
+    assert_equal [:completion, :completion], results
+  end
+
+  def test_timeout
+    args = [1, 2, 3]
+    EM.run do
+      completion.timeout(0.0001, *args)
+      completion.errback { |*errargs| results << errargs }
+      completion.completion { EM.stop }
+      EM.add_timer(0.1) { flunk 'test timed out' }
+    end
+    assert_equal [[1,2,3]], results
+  end
+
+  def test_timeout_gets_cancelled
+    EM.run do
+      completion.timeout(0.0001, :timeout)
+      completion.errback  { results << :errback  }
+      completion.succeed
+      EM.add_timer(0.0002) { EM.stop }
+    end
+    assert_equal [], results
+  end
+end

data/tests/test_connection_count.rb

@@ -0,0 +1,53 @@
+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
+
+  module DoubleCloseClient
+    def unbind
+      close_connection
+      $num_close_scheduled_1 = EM.num_close_scheduled
+      EM.next_tick do
+        $num_close_scheduled_2 = EM.num_close_scheduled
+        EM.stop
+      end
+    end
+  end
+
+  def test_num_close_scheduled
+    EM.run {
+      assert_equal(0, EM.num_close_scheduled)
+      EM.connect("127.0.0.1", 9999, DoubleCloseClient) # nothing listening on 9999
+    }
+    assert_equal(1, $num_close_scheduled_1)
+    assert_equal(0, $num_close_scheduled_2)
+  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,145 @@
+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 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", "127.0.0.1", @port
+    end
+
+    def receive_data dgm
+      $out = dgm
+      EM.stop
+    end
+  end
+
+  def test_datagrams
+    $in = $out = ""
+    EM.run {
+      EM.open_datagram_socket "127.0.0.1", @port, TestDatagramServer
+      EM.open_datagram_socket "127.0.0.1", 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
+
+  def test_attach_detach
+    EM.epoll
+    EM.run {
+      EM.add_timer(0.01) { EM.stop }
+
+      r, w = 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_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