eventmachine 0.12.6-x86-mswin32-60 → 0.12.8-x86-mswin32-60

data/tests/test_proxy_connection.rb

@@ -0,0 +1,92 @@
+$:.unshift "../lib"
+require 'eventmachine'
+require 'test/unit'
+
+class TestProxyConnection < Test::Unit::TestCase
+
+  module ProxyConnection
+    def initialize(client, request)
+      @client, @request = client, request
+    end
+
+    def post_init
+      EM::enable_proxy(self, @client)
+    end
+
+    def connection_completed
+      EM.next_tick {
+        send_data @request
+      }
+    end
+
+    def proxy_target_unbound
+      $unbound_early = true
+      EM.stop
+    end
+
+    def unbind
+      @client.close_connection_after_writing
+    end
+  end
+
+  module Client
+    def connection_completed
+      send_data "EventMachine rocks!"
+    end
+
+    def receive_data(data)
+      $client_data = data
+    end
+
+    def unbind
+      EM.stop
+    end
+  end
+
+  module Client2
+    include Client
+    def unbind; end
+  end
+
+  module Server
+    def receive_data(data)
+      send_data "I know!" if data == "EventMachine rocks!"
+      close_connection_after_writing
+    end
+  end
+
+  module ProxyServer
+    def receive_data(data)
+      EM.connect("127.0.0.1", 54321, ProxyConnection, self, data)
+    end
+  end
+
+  module EarlyClosingProxy
+    def receive_data(data)
+      EM.connect("127.0.0.1", 54321, ProxyConnection, self, data)
+      close_connection
+    end
+  end
+
+  def test_proxy_connection
+    EM.run {
+      EM.start_server("127.0.0.1", 54321, Server)
+      EM.start_server("127.0.0.1", 12345, ProxyServer)
+      EM.connect("127.0.0.1", 12345, Client)
+    }
+
+    assert_equal("I know!", $client_data)
+  end
+
+  def test_early_close
+    $client_data = nil
+    EM.run {
+      EM.start_server("127.0.0.1", 54321, Server)
+      EM.start_server("127.0.0.1", 12345, EarlyClosingProxy)
+      EM.connect("127.0.0.1", 12345, Client2)
+    }
+
+    assert($unbound_early)
+  end
+
+end

data/tests/test_pure.rb

@@ -67,12 +67,11 @@ class TestPure < Test::Unit::TestCase
     assert_raises( RuntimeError ) { run_exception }
   end
   def test_exception_2
-		ex_class = RUBY_PLATFORM == 'java' ? NativeException : RuntimeError
+    ex_class = RUBY_PLATFORM == 'java' ? NativeException : RuntimeError
     assert_raises( ex_class ) { run_exception }
   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
@@ -114,8 +113,6 @@ class TestPure < Test::Unit::TestCase
     assert_equal( false, timeout )
   end
 
-
-
   def test_reactor_running
     a = false
     EM.run {
@@ -125,5 +122,4 @@ class TestPure < Test::Unit::TestCase
     assert a
   end
 
-
 end

data/tests/test_queue.rb

@@ -0,0 +1,44 @@
+$:.unshift "../lib"
+require 'eventmachine'
+require 'test/unit'
+
+class TestEventMachineQueue < 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
+end

data/tests/test_running.rb

@@ -29,19 +29,14 @@ require 'eventmachine'
 require 'test/unit'
 
 class TestRunning < Test::Unit::TestCase
-	def setup
-	end
-	def teardown
-	end
-
-	def test_running
-		assert_equal( false, EM::reactor_running? )
-		r = false
-		EM.run {
-			r = EM::reactor_running?
-			EM.stop
-		}
-		assert_equal( true, r )
-	end
+  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

@@ -31,44 +31,42 @@ require 'test/unit'
 
 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.
+  # 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.
 
+  Host,Port = "127.0.0.1",9560
+  TestUser,TestPsw = "someone", "password"
 
-	Host,Port = "127.0.0.1",9560
-	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 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
 
-	class SaslClient < EM::Connection
-		include EM::Protocols::SASLauthclient
-	end
+  def test_sasl
+    resp = nil
+    EM.run {
+      EM.start_server( Host, Port, SaslServer )
 
-	def test_sasl
-		resp = nil
-		EM.run {
-			EM.start_server( Host, Port, SaslServer )
-
-			c = EM.connect( Host, Port, SaslClient )
-			d = c.validate?( TestUser, TestPsw )
-			d.timeout 2
-			d.callback {
-				resp = true
-				EM.stop
-			}
-			d.errback {
-				resp = false
-				EM.stop
-			}
-		}
-		assert_equal( true, resp )
-	end
+      c = EM.connect( Host, Port, SaslClient )
+      d = c.validate?( TestUser, TestPsw )
+      d.timeout 2
+      d.callback {
+        resp = true
+        EM.stop
+      }
+      d.errback {
+        resp = false
+        EM.stop
+      }
+    }
+    assert_equal( true, resp )
+  end
 
 end
-

data/tests/test_send_file.rb

@@ -31,16 +31,16 @@ require 'test/unit'
 
 class TestSendFile < Test::Unit::TestCase
 
-	module TestModule
-		def post_init
-			send_file_data TestFilename
-			close_connection_after_writing
-		end
-	end
-	
-	module TestClient
-	  def data_to(&blk)
-	    @data_to = blk
+  module TestModule
+    def post_init
+      send_file_data TestFilename
+      close_connection_after_writing
+    end
+  end
+
+  module TestClient
+    def data_to(&blk)
+      @data_to = blk
     end
     
     def receive_data(data)
@@ -52,192 +52,191 @@ class TestSendFile < Test::Unit::TestCase
     end
   end
 
-	TestHost = "0.0.0.0"
-	TestPort = 9055
-	TestFilename = "./xxxxxx"
+  TestHost = "0.0.0.0"
+  TestPort = 9055
+  TestFilename = "./xxxxxx"
 
-	def setup
-	end
+  def setup
+  end
 
-	def teardown
-		File.unlink( TestFilename ) if File.exist?( TestFilename )
-	end
+  def teardown
+    File.unlink( TestFilename ) if File.exist?( TestFilename )
+  end
 
-	def test_send_file
-		File.open( TestFilename, "w" ) {|f|
-			f << ("A" * 5000)
-		}
+  def test_send_file
+    File.open( TestFilename, "w" ) {|f|
+      f << ("A" * 5000)
+    }
 
-		data = ''
+    data = ''
 
-		EM.run {
-			EM.start_server TestHost, TestPort, TestModule
-			EM.add_timer(2) {EM.stop} # avoid hanging in case of error
-			
-			EM.connect TestHost, TestPort, TestClient do |c|
-			  c.data_to { |d| data << d }
-		  end
-		}
+    EM.run {
+      EM.start_server TestHost, TestPort, TestModule
+      EM.add_timer(2) {EM.stop} # avoid hanging in case of error
 
-		assert_equal( "A" * 5000, data )
-		File.unlink TestFilename
-	end
+      EM.connect TestHost, TestPort, TestClient do |c|
+        c.data_to { |d| data << d }
+      end
+    }
 
-	# EventMachine::Connection#send_file_data has a strict upper limit on the filesize it will work with.
-	def test_send_large_file
-		File.open( TestFilename, "w" ) {|f|
-			f << ("A" * 1000000)
-		}
+    assert_equal( "A" * 5000, data )
+    File.unlink TestFilename
+  end
+
+  # EventMachine::Connection#send_file_data has a strict upper limit on the filesize it will work with.
+  def test_send_large_file
+    File.open( TestFilename, "w" ) {|f|
+      f << ("A" * 1000000)
+    }
 
-		data = ''
+    data = ''
 
-		ex_class = RUBY_PLATFORM == 'java' ? NativeException : RuntimeError
+    ex_class = RUBY_PLATFORM == 'java' ? NativeException : RuntimeError
     assert_raises( ex_class ) {
-			EM.run {
-				EM.start_server TestHost, TestPort, TestModule
-				EM.add_timer(2) {EM.stop} # avoid hanging in case of error
-  			EM.connect TestHost, TestPort, TestClient do |c|
-  			  c.data_to { |d| data << d }
-  		  end
-			}
-		}
-
-		File.unlink TestFilename
-	end
-
-
-	module StreamTestModule
-		def post_init
-			EM::Deferrable.future( stream_file_data(TestFilename)) {
-				close_connection_after_writing
-			}
-		end
-	end
-
-	module ChunkStreamTestModule
-		def post_init
-			EM::Deferrable.future( stream_file_data(TestFilename, :http_chunks=>true)) {
-				close_connection_after_writing
-			}
-		end
-	end
-
-	def test_stream_file_data
-		File.open( TestFilename, "w" ) {|f|
-			f << ("A" * 1000)
-		}
-
-		data = ''
-
-		EM.run {
-			EM.start_server TestHost, TestPort, StreamTestModule
-			EM.add_timer(2) {EM.stop} # avoid hanging in case of error
-			EM.connect TestHost, TestPort, TestClient do |c|
-			  c.data_to { |d| data << d }
-		  end
-		}
-
-		assert_equal( "A" * 1000, data )
-
-		File.unlink TestFilename
-	end
-
-	def test_stream_chunked_file_data
-		File.open( TestFilename, "w" ) {|f|
-			f << ("A" * 1000)
-		}
-
-		data = ''
-
-		EM.run {
-			EM.start_server TestHost, TestPort, ChunkStreamTestModule
-			EM.add_timer(2) {EM.stop} # avoid hanging in case of error
-			EM.connect TestHost, TestPort, TestClient do |c|
-			  c.data_to { |d| data << d }
-		  end
-		}
-
-		assert_equal( "3e8\r\n#{"A" * 1000}\r\n0\r\n\r\n", data )
-
-		File.unlink TestFilename
-	end
-
-	module BadFileTestModule
-		def post_init
-			de = stream_file_data( TestFilename+"..." )
-			de.errback {|msg|
-				send_data msg
-				close_connection_after_writing
-			}
-		end
-	end
-	def test_stream_bad_file
-		data = ''
-		EM.run {
-			EM.start_server TestHost, TestPort, BadFileTestModule
-			EM.add_timer(2) {EM.stop} # avoid hanging in case of error
-			EM.connect TestHost, TestPort, TestClient do |c|
-			  c.data_to { |d| data << d }
-		  end
-		}
-
-		assert_equal( "file not found", data )
-	end
-
-	def test_stream_large_file_data
-	  begin
-	    require 'fastfilereaderext'
+      EM.run {
+        EM.start_server TestHost, TestPort, TestModule
+        EM.add_timer(2) {EM.stop} # avoid hanging in case of error
+        EM.connect TestHost, TestPort, TestClient do |c|
+          c.data_to { |d| data << d }
+        end
+      }
+    }
+
+    File.unlink TestFilename
+  end
+
+
+  module StreamTestModule
+    def post_init
+      EM::Deferrable.future( stream_file_data(TestFilename)) {
+        close_connection_after_writing
+      }
+    end
+  end
+
+  module ChunkStreamTestModule
+    def post_init
+      EM::Deferrable.future( stream_file_data(TestFilename, :http_chunks=>true)) {
+        close_connection_after_writing
+      }
+    end
+  end
+
+  def test_stream_file_data
+    File.open( TestFilename, "w" ) {|f|
+      f << ("A" * 1000)
+    }
+
+    data = ''
+
+    EM.run {
+      EM.start_server TestHost, TestPort, StreamTestModule
+      EM.add_timer(2) {EM.stop} # avoid hanging in case of error
+      EM.connect TestHost, TestPort, TestClient do |c|
+        c.data_to { |d| data << d }
+      end
+    }
+
+    assert_equal( "A" * 1000, data )
+
+    File.unlink TestFilename
+  end
+
+  def test_stream_chunked_file_data
+    File.open( TestFilename, "w" ) {|f|
+      f << ("A" * 1000)
+    }
+
+    data = ''
+
+    EM.run {
+      EM.start_server TestHost, TestPort, ChunkStreamTestModule
+      EM.add_timer(2) {EM.stop} # avoid hanging in case of error
+      EM.connect TestHost, TestPort, TestClient do |c|
+        c.data_to { |d| data << d }
+      end
+    }
+
+    assert_equal( "3e8\r\n#{"A" * 1000}\r\n0\r\n\r\n", data )
+
+    File.unlink TestFilename
+  end
+
+  module BadFileTestModule
+    def post_init
+      de = stream_file_data( TestFilename+"..." )
+      de.errback {|msg|
+        send_data msg
+        close_connection_after_writing
+      }
+    end
+  end
+  def test_stream_bad_file
+    data = ''
+    EM.run {
+      EM.start_server TestHost, TestPort, BadFileTestModule
+      EM.add_timer(2) {EM.stop} # avoid hanging in case of error
+      EM.connect TestHost, TestPort, TestClient do |c|
+        c.data_to { |d| data << d }
+      end
+    }
+
+    assert_equal( "file not found", data )
+  end
+
+  def test_stream_large_file_data
+    begin
+      require 'fastfilereaderext'
     rescue LoadError
       return
     end
-		File.open( TestFilename, "w" ) {|f|
-			f << ("A" * 10000)
-		}
+    File.open( TestFilename, "w" ) {|f|
+      f << ("A" * 10000)
+    }
 
-		data = ''
+    data = ''
 
-		EM.run {
-			EM.start_server TestHost, TestPort, StreamTestModule
-			EM.add_timer(2) {EM.stop} # avoid hanging in case of error
-			EM.connect TestHost, TestPort, TestClient do |c|
-			  c.data_to { |d| data << d }
-		  end
-		}
+    EM.run {
+      EM.start_server TestHost, TestPort, StreamTestModule
+      EM.add_timer(2) {EM.stop} # avoid hanging in case of error
+      EM.connect TestHost, TestPort, TestClient do |c|
+        c.data_to { |d| data << d }
+      end
+    }
 
-		assert_equal( "A" * 10000, data )
+    assert_equal( "A" * 10000, data )
 
-		File.unlink TestFilename
-	end
+    File.unlink TestFilename
+  end
 
-	def test_stream_large_chunked_file_data
-	  begin
-	    require 'fastfilereaderext'
+  def test_stream_large_chunked_file_data
+    begin
+      require 'fastfilereaderext'
     rescue LoadError
       return
     end
-		File.open( TestFilename, "w" ) {|f|
-			f << ("A" * 100000)
-		}
-
-		data = ''
-
-		EM.run {
-			EM.start_server TestHost, TestPort, ChunkStreamTestModule
-			EM.add_timer(2) {EM.stop} # avoid hanging in case of error
-			EM.connect TestHost, TestPort, 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 )
-
-		File.unlink TestFilename
-	end
+    File.open( TestFilename, "w" ) {|f|
+      f << ("A" * 100000)
+    }
+
+    data = ''
+
+    EM.run {
+      EM.start_server TestHost, TestPort, ChunkStreamTestModule
+      EM.add_timer(2) {EM.stop} # avoid hanging in case of error
+      EM.connect TestHost, TestPort, 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 )
+
+    File.unlink TestFilename
+  end
 
 end
-