sonixlabs-eventmachine-java 1.0.0.rc.4-java

data/tests/test_pure.rb

@@ -0,0 +1,88 @@
+require 'em_test_helper'
+
+class TestPure < Test::Unit::TestCase
+
+  def setup
+    @port = next_port
+  end
+
+  # These tests are intended to exercise problems that come up in the
+  # pure-Ruby implementation. However, we DON'T constrain them such that
+  # they only run in pure-Ruby. These tests need to work identically in
+  # any implementation.
+
+  #-------------------------------------
+
+  # The EM reactor needs to run down open connections and release other resources
+  # when it stops running. Make sure this happens even if user code throws a Ruby
+  # exception.
+  # If exception handling is incorrect, the second test will fail with a no-bind error
+  # because the TCP server opened in the first test will not have been closed.
+
+  def test_exception_handling_releases_resources
+    exception = Class.new(StandardError)
+
+    2.times do
+      assert_raises(exception) do
+        EM.run do
+          EM.start_server "127.0.0.1", @port
+          raise exception
+        end
+      end
+    end
+  end
+
+  # Under some circumstances, the pure Ruby library would emit an Errno::ECONNREFUSED
+  # exception on certain kinds of TCP connect-errors.
+  # It's always been something of an open question whether EM should throw an exception
+  # in these cases but the defined answer has always been to catch it the unbind method.
+  # With a connect failure, the latter will always fire, but connection_completed will
+  # never fire. So even though the point is arguable, it's incorrect for the pure Ruby
+  # version to throw an exception.
+  module TestConnrefused
+    def unbind
+      EM.stop
+    end
+    def connection_completed
+      raise "should never get here"
+    end
+  end
+
+  def test_connrefused
+    assert_nothing_raised do
+      EM.run {
+        setup_timeout(2)
+        EM.connect "127.0.0.1", @port, TestConnrefused
+      }
+    end
+  end
+
+  # Make sure connection_completed gets called as expected with TCP clients. This is the
+  # opposite of test_connrefused.
+  # If the test fails, it will hang because EM.stop never gets called.
+  #
+  module TestConnaccepted
+    def connection_completed
+      EM.stop
+    end
+  end
+  def test_connaccepted
+    assert_nothing_raised do
+      EM.run {
+        EM.start_server "127.0.0.1", @port
+        EM.connect "127.0.0.1", @port, TestConnaccepted
+        setup_timeout(1)
+      }
+    end
+  end
+
+  def test_reactor_running
+    a = false
+    EM.run {
+      a = EM.reactor_running?
+      EM.next_tick {EM.stop}
+    }
+    assert a
+  end
+
+end

data/tests/test_queue.rb

@@ -0,0 +1,50 @@
+require 'em_test_helper'
+
+class TestEMQueue < Test::Unit::TestCase
+  def test_queue_push
+    s = 0
+    EM.run do
+      q = EM::Queue.new
+      q.push(1)
+      EM.next_tick { s = q.size; EM.stop }
+    end
+    assert_equal 1, s
+  end
+
+  def test_queue_pop
+    x,y,z = nil
+    EM.run do
+      q = EM::Queue.new
+      q.push(1,2,3)
+      q.pop { |v| x = v }
+      q.pop { |v| y = v }
+      q.pop { |v| z = v; EM.stop }
+    end
+    assert_equal 1, x
+    assert_equal 2, y
+    assert_equal 3, z
+  end
+
+  def test_queue_reactor_thread
+    q = EM::Queue.new
+
+    Thread.new { q.push(1,2,3) }.join
+    assert q.empty?
+    EM.run { EM.next_tick { EM.stop } }
+    assert_equal 3, q.size
+
+    x = nil
+    Thread.new { q.pop { |v| x = v } }.join
+    assert_equal nil, x
+    EM.run { EM.next_tick { EM.stop } }
+    assert_equal 1, x
+  end
+
+  def test_num_waiting
+    q = EM::Queue.new
+    many = 3
+    many.times { q.pop {} }
+    EM.run { EM.next_tick { EM.stop } }
+    assert_equal many, q.num_waiting
+  end
+end

data/tests/test_resolver.rb

@@ -0,0 +1,55 @@
+require 'em_test_helper'
+
+class TestResolver < Test::Unit::TestCase
+  def test_a
+    EM.run {
+      d = EM::DNS::Resolver.resolve "google.com"
+      d.errback { assert false }
+      d.callback { |r|
+        assert r
+        EM.stop
+      }
+    }
+  end
+
+  def test_bad_host
+    EM.run {
+      d = EM::DNS::Resolver.resolve "asdfasasdf"
+      d.callback { assert false }
+      d.errback  { assert true; EM.stop }
+    }
+  end
+
+  def test_garbage
+    assert_raises( ArgumentError ) {
+      EM.run {
+        EM::DNS::Resolver.resolve 123
+      }
+    }
+  end
+
+  def test_a_pair
+    EM.run {
+      d = EM::DNS::Resolver.resolve "google.com"
+      d.errback { assert false }
+      d.callback { |r|
+        assert_equal(Array, r.class)
+        assert r.size > 1
+        EM.stop
+      }
+    }
+  end
+
+  def test_localhost
+    EM.run {
+      d = EM::DNS::Resolver.resolve "localhost"
+      d.errback { assert false }
+      d.callback { |r|
+        assert_equal("127.0.0.1", r.first)
+        assert_equal(Array, r.class)
+
+        EM.stop
+      }
+    }
+  end
+end

data/tests/test_running.rb

@@ -0,0 +1,14 @@
+require 'em_test_helper'
+
+class TestRunning < Test::Unit::TestCase
+  def test_running
+    assert_equal( false, EM::reactor_running? )
+    r = false
+    EM.run {
+      r = EM::reactor_running?
+      EM.stop
+    }
+    assert_equal( true, r )
+  end
+end
+

data/tests/test_sasl.rb

@@ -0,0 +1,47 @@
+require 'em_test_helper'
+
+
+class TestSASL < Test::Unit::TestCase
+
+  # SASL authentication is usually done with UNIX-domain sockets, but
+  # we'll use TCP so this test will work on Windows. As far as the
+  # protocol handlers are concerned, there's no difference.
+
+  TestUser,TestPsw = "someone", "password"
+
+  class SaslServer < EM::Connection
+    include EM::Protocols::SASLauth
+    def validate usr, psw, sys, realm
+      usr == TestUser and psw == TestPsw
+    end
+  end
+
+  class SaslClient < EM::Connection
+    include EM::Protocols::SASLauthclient
+  end
+
+  def setup
+    @port = next_port
+  end
+
+  def test_sasl
+    resp = nil
+    EM.run {
+      EM.start_server( "127.0.0.1", @port, SaslServer )
+
+      c = EM.connect( "127.0.0.1", @port, SaslClient )
+      d = c.validate?( TestUser, TestPsw )
+      d.timeout 1
+      d.callback {
+        resp = true
+        EM.stop
+      }
+      d.errback {
+        resp = false
+        EM.stop
+      }
+    }
+    assert_equal( true, resp )
+  end
+
+end

data/tests/test_send_file.rb

@@ -0,0 +1,217 @@
+require 'em_test_helper'
+require 'tempfile'
+
+class TestSendFile < Test::Unit::TestCase
+
+  if EM.respond_to?(:send_file_data)
+    module TestModule
+      def initialize filename
+        @filename = filename
+      end
+
+      def post_init
+        send_file_data @filename
+        close_connection_after_writing
+      end
+    end
+
+    module TestClient
+      def data_to(&blk)
+        @data_to = blk
+      end
+
+      def receive_data(data)
+        @data_to.call(data) if @data_to
+      end
+
+      def unbind
+        EM.stop
+      end
+    end
+
+    def setup
+      @file = Tempfile.new("em_test_file")
+      @filename = @file.path
+      @port = next_port
+    end
+
+    def test_send_file
+      File.open( @filename, "w" ) {|f|
+        f << ("A" * 5000)
+      }
+
+      data = ''
+
+      EM.run {
+        EM.start_server "127.0.0.1", @port, TestModule, @filename
+        setup_timeout
+
+        EM.connect "127.0.0.1", @port, TestClient do |c|
+          c.data_to { |d| data << d }
+        end
+      }
+
+      assert_equal( "A" * 5000, data )
+    end
+
+    # EM::Connection#send_file_data has a strict upper limit on the filesize it will work with.
+    def test_send_large_file
+      File.open( @filename, "w" ) {|f|
+        f << ("A" * 1000000)
+      }
+
+      data = ''
+
+      assert_raises(RuntimeError) {
+        EM.run {
+          EM.start_server "127.0.0.1", @port, TestModule, @filename
+          setup_timeout
+          EM.connect "127.0.0.1", @port, TestClient do |c|
+            c.data_to { |d| data << d }
+          end
+        }
+      }
+    end
+
+    module StreamTestModule
+      def initialize filename
+        @filename = filename
+      end
+
+      def post_init
+        EM::Deferrable.future( stream_file_data(@filename)) {
+          close_connection_after_writing
+        }
+      end
+    end
+
+    module ChunkStreamTestModule
+      def initialize filename
+        @filename = filename
+      end
+
+      def post_init
+        EM::Deferrable.future( stream_file_data(@filename, :http_chunks=>true)) {
+          close_connection_after_writing
+        }
+      end
+    end
+
+    def test_stream_file_data
+      File.open( @filename, "w" ) {|f|
+        f << ("A" * 1000)
+      }
+
+      data = ''
+
+      EM.run {
+        EM.start_server "127.0.0.1", @port, StreamTestModule, @filename
+        setup_timeout
+        EM.connect "127.0.0.1", @port, TestClient do |c|
+          c.data_to { |d| data << d }
+        end
+      }
+
+      assert_equal( "A" * 1000, data )
+    end
+
+    def test_stream_chunked_file_data
+      File.open( @filename, "w" ) {|f|
+        f << ("A" * 1000)
+      }
+
+      data = ''
+
+      EM.run {
+        EM.start_server "127.0.0.1", @port, ChunkStreamTestModule, @filename
+        setup_timeout
+        EM.connect "127.0.0.1", @port, TestClient do |c|
+          c.data_to { |d| data << d }
+        end
+      }
+
+      assert_equal( "3e8\r\n#{"A" * 1000}\r\n0\r\n\r\n", data )
+    end
+
+    module BadFileTestModule
+      def initialize filename
+        @filename = filename
+      end
+
+      def post_init
+        de = stream_file_data( @filename+".wrong" )
+        de.errback {|msg|
+          send_data msg
+          close_connection_after_writing
+        }
+      end
+    end
+    def test_stream_bad_file
+      data = ''
+      EM.run {
+        EM.start_server "127.0.0.1", @port, BadFileTestModule, @filename
+        setup_timeout(5)
+        EM.connect "127.0.0.1", @port, TestClient do |c|
+          c.data_to { |d| data << d }
+        end
+      }
+
+      assert_equal( "file not found", data )
+    end
+  else
+    warn "EM.send_file_data not implemented, skipping tests in #{__FILE__}"
+
+    # Because some rubies will complain if a TestCase class has no tests
+    def test_em_send_file_data_not_implemented
+      assert !EM.respond_to?(:send_file_data)
+    end
+  end
+
+  begin
+    require 'fastfilereaderext'
+
+    def test_stream_large_file_data
+      File.open( @filename, "w" ) {|f|
+        f << ("A" * 10000)
+      }
+
+      data = ''
+
+      EM.run {
+        EM.start_server "127.0.0.1", @port, StreamTestModule, @filename
+        setup_timeout
+        EM.connect "127.0.0.1", @port, TestClient do |c|
+          c.data_to { |d| data << d }
+        end
+      }
+
+      assert_equal( "A" * 10000, data )
+    end
+
+    def test_stream_large_chunked_file_data
+      File.open( @filename, "w" ) {|f|
+        f << ("A" * 100000)
+      }
+
+      data = ''
+
+      EM.run {
+        EM.start_server "127.0.0.1", @port, ChunkStreamTestModule, @filename
+        setup_timeout
+        EM.connect "127.0.0.1", @port, TestClient do |c|
+          c.data_to { |d| data << d }
+        end
+      }
+
+      expected = [
+        "4000\r\n#{"A" * 16384}\r\n" * 6,
+        "6a0\r\n#{"A" * 0x6a0}\r\n",
+        "0\r\n\r\n"
+      ].join
+      assert_equal( expected, data )
+    end
+  rescue LoadError
+    warn "require 'fastfilereaderext' failed, skipping tests in #{__FILE__}"
+  end
+
+end