eventmachine 0.12.2 → 0.12.4

data/tests/test_epoll.rb

@@ -1,4 +1,4 @@
-# $Id: test_epoll.rb 668 2008-01-04 23:00:34Z blackhedd $
+# $Id$
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com
@@ -28,20 +28,12 @@
 # the result is a very confusing error message.
 #
 
-$:.unshift "../lib"
 require 'eventmachine'
 require 'test/unit'
 
 
 class TestEpoll < Test::Unit::TestCase
 
-	def setup
-	end
-
-	def teardown
-	end
-
-
 	module TestEchoServer
 		def receive_data data
 			send_data data
@@ -69,7 +61,7 @@ class TestEpoll < Test::Unit::TestCase
 	# On most systems, the default value is 1024.
 	# Java doesn't (currently) implement this.
 	def test_rlimit
-		unless RUBY_PLATFORM =~ /java/
+		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 )
@@ -97,16 +89,16 @@ class TestEpoll < Test::Unit::TestCase
 		assert_equal(100, $max)
 	end
 
-	def test_defer
-		$n = 0
-		EM.epoll
-		EM.run {
-			sleep_proc = proc {sleep 1}
-			return_proc = proc {$n += 1; EM.stop}
-			EM.defer sleep_proc, return_proc
-		}
-		assert_equal( 1, $n )
-	end
+  def test_defer
+    n = 0
+    work_proc = proc {n += 1}
+    callback_proc = proc {EM.stop}
+    EM.epoll
+    EM.run {
+      EM.defer work_proc, callback_proc
+    }
+    assert_equal( 1, n )
+  end unless RUBY_VERSION >= '1.9.0'
 
 
 	module TestDatagramServer
@@ -140,6 +132,7 @@ class TestEpoll < Test::Unit::TestCase
 
 
 	def test_unix_domain
+		fn = "/tmp/xxx.chain"
 		EM.epoll
 		s = EM.set_descriptor_table_size 60000
 		EM.run {
@@ -151,7 +144,6 @@ class TestEpoll < Test::Unit::TestCase
 			# Let's not sweat the Unix-ness of the filename, since this test can't possibly
 			# work on Windows anyway.
 			#
-			fn = "/tmp/xxx.chain"
 			File.unlink(fn) if File.exist?(fn)
 			EM.start_unix_domain_server fn, TestEchoServer
 			$n = 0
@@ -159,9 +151,12 @@ class TestEpoll < Test::Unit::TestCase
 			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_errors.rb

@@ -1,4 +1,4 @@
-# $Id: test_errors.rb 668 2008-01-04 23:00:34Z blackhedd $
+# $Id$
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com

data/tests/test_eventables.rb

@@ -1,4 +1,4 @@
-# $Id: test_eventables.rb 668 2008-01-04 23:00:34Z blackhedd $
+# $Id$
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com
@@ -27,10 +27,6 @@
 $:.unshift "../lib"
 require 'eventmachine'
 
-require 'test/unit/testsuite'
-require 'test/unit/ui/console/testrunner'
-
-
 class TestEventables < Test::Unit::TestCase
 
   class EvTest
@@ -68,6 +64,9 @@ end
 #--------------------------------------
 
 if __FILE__ == $0
+  require 'test/unit/testsuite'
+  require 'test/unit/ui/console/testrunner'
+
   runner = Test::Unit::UI::Console::TestRunner
   suite = Test::Unit::TestSuite.new("name")
   ObjectSpace.each_object(Class) do |testcase|

data/tests/test_exc.rb

@@ -1,4 +1,4 @@
-# $Id: test_exc.rb 668 2008-01-04 23:00:34Z blackhedd $
+# $Id$
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com

data/tests/test_futures.rb

@@ -1,4 +1,4 @@
-# $Id: test_futures.rb 668 2008-01-04 23:00:34Z blackhedd $
+# $Id$
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com

data/tests/test_hc.rb

@@ -1,4 +1,4 @@
-# $Id: test_hc.rb 721 2008-06-21 00:45:57Z francis $
+# $Id$
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com
@@ -24,246 +24,195 @@
 #
 #
 
-$:.unshift "../lib"
+# $:.unshift "../lib"
 require 'eventmachine'
-require 'socket'
 require 'test/unit'
 
-# This doesn't completely work under Ruby 1.9.
-# Part of it is thread race conditions. I added some sleeps to make these
-# tests work. Native threads do strange things when you do I/O on them.
-#
-# And it's even worse in Java, where I/O on native threads doesn't seem
-# to be reliable at all.
-#
-
-
 class TestHeaderAndContentProtocol < Test::Unit::TestCase
 
-	TestHost = "127.0.0.1"
-	TestPort = 8905
-
-
-	#--------------------------------------------------------------------
-
-	class SimpleTest < EventMachine::Protocols::HeaderAndContentProtocol
-		attr_reader :first_header, :my_headers, :request
-
-		def receive_first_header_line hdr
-			@first_header ||= []
-			@first_header << hdr
-		end
-		def receive_headers hdrs
-			@my_headers ||= []
-			@my_headers << hdrs
-		end
-		def receive_request hdrs, content
-			@request ||= []
-			@request << [hdrs, content]
-		end
-	end
-
-
-	def test_no_content
-		Thread.abort_on_exception = true
-		the_connection = nil
-		EventMachine.run {
-			EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
-				the_connection = conn
-			end
-			EventMachine.add_timer(4) {raise "test timed out"}
-
-			pr = proc {
-				t = TCPSocket.new TestHost, TestPort
-				t.write [ "aaa\n", "bbb\r\n", "ccc\n", "\n" ].join
-				t.close
-			}
-
-			if RUBY_PLATFORM =~ /java/i
-				pr.call
-				EM.add_timer(0.5) {EM.stop}
-			else
-				EventMachine.defer proc {
-					pr.call
-					if RUBY_VERSION =~ /\A1\.9\./
-						sleep 0.1
-						STDERR.puts "Introducing extraneous sleep for Ruby 1.9"
-					end
-				}, proc {
-					EventMachine.stop
-				}
-			end
-		}
-		assert_equal( ["aaa"], the_connection.first_header )
-		assert_equal( [%w(aaa bbb ccc)], the_connection.my_headers )
-		assert_equal( [[%w(aaa bbb ccc), ""]], the_connection.request )
-	end
-
-
-
-
-	def test_content
-		Thread.abort_on_exception = true
-		the_connection = nil
-		content = "A" * 50
-		headers = ["aaa", "bbb", "Content-length: #{content.length}", "ccc"]
-		EventMachine.run {
-			EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
-				the_connection = conn
-			end
-			EventMachine.add_timer(4) {raise "test timed out"}
-
-			pr = proc {
-				t = TCPSocket.new TestHost, TestPort
-				headers.each {|h| t.write "#{h}\r\n" }
-				t.write "\n"
-				t.write content
-				t.close
-			}
+  TestHost = "127.0.0.1"
+  TestPort = 8905
 
-			if RUBY_PLATFORM =~ /java/i
-				# I/O on threads seems completely unreliable in Java.
-				pr.call
-				EM.add_timer(0.5) {EM.stop}
-			else
-				EventMachine.defer proc {
-					pr.call
-					if RUBY_VERSION =~ /\A1\.9\./
-						sleep 0.1
-						STDERR.puts "Introducing extraneous sleep for Ruby 1.9"
-					end
-				}, proc {
-					EM.stop
-				}
-			end
-		}
-		assert_equal( ["aaa"], the_connection.first_header )
-		assert_equal( [headers], the_connection.my_headers )
-		assert_equal( [[headers, content]], the_connection.request )
-	end
+  class SimpleTest < EventMachine::Protocols::HeaderAndContentProtocol
+    attr_reader :first_header, :my_headers, :request
 
-
-
-	def test_several_requests
-		Thread.abort_on_exception = true
-		the_connection = nil
-		content = "A" * 50
-		headers = ["aaa", "bbb", "Content-length: #{content.length}", "ccc"]
-		EventMachine.run {
-			EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
-				the_connection = conn
-			end
-			EventMachine.add_timer(4) {raise "test timed out"}
-
-			pr = proc {
-				t = TCPSocket.new TestHost, TestPort
-				5.times {
-					headers.each {|h| t.write "#{h}\r\n" }
-					t.write "\n"
-					t.write content
-				}
-				t.close
-			}
-
-			if RUBY_PLATFORM =~ /java/i
-				pr.call
-				EM.add_timer(1) {EM.stop}
-			else
-				EventMachine.defer proc {
-					pr.call
-					if RUBY_VERSION =~ /\A1\.9\./
-						sleep 0.1
-						STDERR.puts "Introducing extraneous sleep for Ruby 1.9"
-					end
-				}, proc {
-					EventMachine.stop
-				}
-			end
-		}
-		assert_equal( ["aaa"] * 5, the_connection.first_header )
-		assert_equal( [headers] * 5, the_connection.my_headers )
-		assert_equal( [[headers, content]] * 5, the_connection.request )
-	end
-
-
-    def x_test_multiple_content_length_headers
-	# This is supposed to throw a RuntimeError but it throws a C++ exception instead.
-	Thread.abort_on_exception = true
-	the_connection = nil
-	content = "A" * 50
-	headers = ["aaa", "bbb", ["Content-length: #{content.length}"]*2, "ccc"].flatten
-	EventMachine.run {
-	    EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
-		the_connection = conn
-	    end
-	    EventMachine.add_timer(4) {raise "test timed out"}
-	    EventMachine.defer proc {
-		t = TCPSocket.new TestHost, TestPort
-		headers.each {|h| t.write "#{h}\r\n" }
-		t.write "\n"
-		t.write content
-		t.close
-	    }, proc {
-		EventMachine.stop
-	    }
-	}
+    def receive_first_header_line hdr
+      @first_header ||= []
+      @first_header << hdr
     end
-
-	def test_interpret_headers
-		Thread.abort_on_exception = true
-		the_connection = nil
-		content = "A" * 50
-		headers = [
-			"GET / HTTP/1.0",
-			"Accept: aaa",
-			"User-Agent: bbb",
-			"Host:	    ccc",
-			"x-tempest-header:ddd"
-		]
-
-		EventMachine.run {
-			EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
-				the_connection = conn
-			end
-			EventMachine.add_timer(4) {raise "test timed out"}
-
-			pr = proc {
-				t = TCPSocket.new TestHost, TestPort
-				headers.each {|h| t.write "#{h}\r\n" }
-				t.write "\n"
-				t.write content
-				t.close
-			}
-
-			if RUBY_PLATFORM =~ /java/i
-				pr.call
-				EM.add_timer(0.5) {EM.stop}
-			else
-				EventMachine.defer proc {
-					pr.call
-					if RUBY_VERSION =~ /\A1\.9\./
-						sleep 0.1
-						STDERR.puts "Introducing extraneous sleep for Ruby 1.9"
-					end
-				}, proc {
-					EventMachine.stop
-				}
-			end
-		}
-
-		hsh = the_connection.headers_2_hash( the_connection.my_headers.shift )
-		assert_equal(
-			{
-				:accept => "aaa",
-				:user_agent => "bbb",
-				:host => "ccc",
-				:x_tempest_header => "ddd"
-			},
-			hsh
-		)
-	end
-
-
-end
-
-
+    def receive_headers hdrs
+      @my_headers ||= []
+      @my_headers << hdrs
+    end
+    def receive_request hdrs, content
+      @request ||= []
+      @request << [hdrs, content]
+    end
+  end
+
+  def test_no_content
+    the_connection = nil
+    EventMachine.run {
+      EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
+        the_connection = conn
+      end
+      EventMachine.add_timer(4) {raise "test timed out"}
+
+      client = Module.new do
+        def unbind
+          EM.add_timer(0.1) { EM.stop }
+        end
+
+        def post_init
+          send_data [ "aaa\n", "bbb\r\n", "ccc\n", "\n" ].join
+          close_connection_after_writing
+        end
+      end
+
+      EventMachine.connect( TestHost, TestPort, client )
+    }
+    assert_equal( ["aaa"], the_connection.first_header )
+    assert_equal( [%w(aaa bbb ccc)], the_connection.my_headers )
+    assert_equal( [[%w(aaa bbb ccc), ""]], the_connection.request )
+  end
+
+  def test_content
+    the_connection = nil
+    content = "A" * 50
+    headers = ["aaa", "bbb", "Content-length: #{content.length}", "ccc"]
+    EventMachine.run {
+      EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
+        the_connection = conn
+      end
+      EventMachine.add_timer(4) { assert(false, 'test timeout'); EM.stop }
+
+      client = Module.new do
+        define_method(:headers) { headers }
+        define_method(:content) { content }
+
+        def unbind
+          EM.add_timer(0.1) { EM.stop }
+        end
+
+        def post_init
+          headers.each { |h| send_data "#{h}\r\n" }
+          send_data "\n"
+          send_data content
+          close_connection_after_writing
+        end
+      end
+
+      EventMachine.connect( TestHost, TestPort, client )
+
+    }
+    assert_equal( ["aaa"], the_connection.first_header )
+    assert_equal( [headers], the_connection.my_headers )
+    assert_equal( [[headers, content]], the_connection.request )
+  end
+
+  def test_several_requests
+    the_connection = nil
+    content = "A" * 50
+    headers = ["aaa", "bbb", "Content-length: #{content.length}", "ccc"]
+    EventMachine.run {
+      EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
+        the_connection = conn
+      end
+      EventMachine.add_timer(4) { assert(false, 'test timeout'); EM.stop }
+
+      client = Module.new do
+        define_method(:headers) { headers }
+        define_method(:content) { content }
+
+        def unbind
+          EM.add_timer(0.1) { EM.stop }
+        end
+
+        def post_init
+          5.times do
+            headers.each { |h| send_data "#{h}\r\n" }
+            send_data "\n"
+            send_data content
+          end
+          close_connection_after_writing
+        end
+      end
+
+      EventMachine.connect( TestHost, TestPort, client )
+    }
+    assert_equal( ["aaa"] * 5, the_connection.first_header )
+    assert_equal( [headers] * 5, the_connection.my_headers )
+    assert_equal( [[headers, content]] * 5, the_connection.request )
+  end
+
+
+  # def x_test_multiple_content_length_headers
+  #   # This is supposed to throw a RuntimeError but it throws a C++ exception instead.
+  #   the_connection = nil
+  #   content = "A" * 50
+  #   headers = ["aaa", "bbb", ["Content-length: #{content.length}"]*2, "ccc"].flatten
+  #   EventMachine.run {
+  #     EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
+  #       the_connection = conn
+  #     end
+  #     EventMachine.add_timer(4) {raise "test timed out"}
+  #     test_proc = proc {
+  #       t = TCPSocket.new TestHost, TestPort
+  #       headers.each {|h| t.write "#{h}\r\n" }
+  #       t.write "\n"
+  #       t.write content
+  #       t.close
+  #     }
+  #     EventMachine.defer test_proc, proc {
+  #       EventMachine.stop
+  #     }
+  #   }
+  # end
+
+  def test_interpret_headers
+    the_connection = nil
+    content = "A" * 50
+    headers = [
+      "GET / HTTP/1.0",
+      "Accept: aaa",
+      "User-Agent: bbb",
+      "Host:	    ccc",
+      "x-tempest-header:ddd"
+    ]
+
+    EventMachine.run {
+      EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
+        the_connection = conn
+      end
+      EventMachine.add_timer(4) {raise "test timed out"}
+
+      client = Module.new do
+        define_method(:headers) { headers }
+        define_method(:content) { content }
+
+        def unbind
+          EM.add_timer(0.1) { EM.stop }
+        end
+
+        def post_init
+          headers.each { |h| send_data "#{h}\r\n" }
+          send_data "\n"
+          send_data content
+          close_connection_after_writing
+        end
+      end
+
+      EventMachine.connect( TestHost, TestPort, client )
+    }
+
+    hsh = the_connection.headers_2_hash( the_connection.my_headers.shift )
+    expect = {
+      :accept => "aaa",
+      :user_agent => "bbb",
+      :host => "ccc",
+      :x_tempest_header => "ddd"
+    }
+    assert_equal(expect, hsh)
+  end
+
+end