eventmachine 0.12.2 → 0.12.4

data/tests/test_httpclient.rb

@@ -1,4 +1,4 @@
-# $Id: test_httpclient.rb 786 2008-09-16 07:33:27Z francis $
+# $Id$
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com

data/tests/test_httpclient2.rb

@@ -1,4 +1,4 @@
-# $Id: test_httpclient2.rb 668 2008-01-04 23:00:34Z blackhedd $
+# $Id$
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com
@@ -68,52 +68,61 @@ class TestHttpClient2 < Test::Unit::TestCase
 	end
 
 	def test_bad_server
+	  err = nil
 		EM.run {
 			http = EM::P::HttpClient2.connect Localhost, 9999
 			d = http.get "/"
-			d.errback {p d.internal_error; EM.stop }
+			d.errback { err = true; d.internal_error; EM.stop }
 		}
+		assert(err)
 	end
 
 	def test_get
+	  content = nil
 		EM.run {
 			http = EM::P::HttpClient2.connect "www.bayshorenetworks.com", 80
 			d = http.get "/"
 			d.callback {
-				p d.content
+				content = d.content
 				EM.stop
 			}
 		}
+		assert(content)
 	end
 
 	# Not a pipelined request because we wait for one response before we request the next.
 	def test_get_multiple
+	  content = nil
 		EM.run {
 			http = EM::P::HttpClient2.connect "www.bayshorenetworks.com", 80
 			d = http.get "/"
 			d.callback {
 				e = http.get "/"
 				e.callback {
-					p e.content
+					content = e.content
 					EM.stop
 				}
 			}
 		}
+		assert(content)
 	end
 
 	def test_get_pipeline
+	  headers, headers2 = nil, nil
 		EM.run {
 			http = EM::P::HttpClient2.connect "www.microsoft.com", 80
 			d = http.get("/")
 			d.callback {
-				p d.headers
+				headers = d.headers
 			}
 			e = http.get("/")
 			e.callback {
-				p e.headers
+				headers2 = e.headers
 			}
 			EM::Timer.new(1) {EM.stop}
 		}
+		assert(headers)
+		assert(headers2)
 	end
 
 
@@ -126,6 +135,19 @@ class TestHttpClient2 < Test::Unit::TestCase
 			d.errback {EM.stop}
 		}
 	end
+	
+  def test_https_get
+    d = nil
+    EM.run {
+      http = EM::P::HttpClient2.connect :host => 'www.amazon.com', :port => 443, :ssl => true
+      d = http.get "/"
+      d.callback {
+        EM.stop
+      }
+    }
+    assert_equal(200, d.status)
+  end
+
 
 
 end

data/tests/test_kb.rb

@@ -1,4 +1,4 @@
-# $Id: test_kb.rb 668 2008-01-04 23:00:34Z blackhedd $
+# $Id$
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com
@@ -55,7 +55,7 @@ class TestKeyboardEvents < Test::Unit::TestCase
 		  EM.open_keyboard KbHandler
 		  EM::Timer.new(1) { EM.stop }
 	  }
-  end
+  end if $stdout.tty? # don't run the test unless it stands a chance of validity.
 
 end
 

data/tests/test_ltp.rb

@@ -1,4 +1,4 @@
-# $Id: test_ltp.rb 668 2008-01-04 23:00:34Z blackhedd $
+# $Id$
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com
@@ -25,166 +25,164 @@
 #
 #
 
-$:.unshift "../lib"
 require 'eventmachine'
-require 'socket'
 require 'test/unit'
 
 class TestLineAndTextProtocol < Test::Unit::TestCase
 
-    TestHost = "127.0.0.1"
-    TestPort = 8905
+  TestHost = "127.0.0.1"
+  TestPort = 8905
 
 
-    #--------------------------------------------------------------------
+  #--------------------------------------------------------------------
 
-    class SimpleLineTest < EventMachine::Protocols::LineAndTextProtocol
-	def receive_line line
-	    @line_buffer << line
-	end
+  class SimpleLineTest < EventMachine::Protocols::LineAndTextProtocol
+    def receive_line line
+      @line_buffer << line
     end
+  end
 
-    def test_simple_lines
-        # THIS TEST CURRENTLY FAILS IN JRUBY.
-        assert( RUBY_PLATFORM !~ /java/ )
-
-	lines_received = []
-	Thread.abort_on_exception = true
-	EventMachine.run {
-	    EventMachine.start_server( TestHost, TestPort, SimpleLineTest ) do |conn|
-		conn.instance_eval "@line_buffer = lines_received"
-	    end
-	    EventMachine.add_timer(4) {raise "test timed out"}
-	    EventMachine.defer proc {
-		t = TCPSocket.new TestHost, TestPort
-		t.write [
-		    "aaa\n", "bbb\r\n", "ccc\n"
-		].join
-		t.close
-	    }, proc {
-		EventMachine.stop
-	    }
-	}
-	assert_equal( %w(aaa bbb ccc), lines_received )
+  module StopClient
+    def set_receive_data(&blk)
+      @rdb = blk
     end
+    
+    def receive_data data
+      @rdb.call(data) if @rdb
+    end
+    
+    def unbind
+      EM.add_timer(0.1) { EM.stop }
+    end
+  end
 
-    #--------------------------------------------------------------------
 
-    class SimpleLineTest < EventMachine::Protocols::LineAndTextProtocol
-	def receive_error text
-	    @error_message << text
-	end
-    end
+  def test_simple_lines
+    # THIS TEST CURRENTLY FAILS IN JRUBY.
+    assert( RUBY_PLATFORM !~ /java/ )
 
-    def test_overlength_lines
-        # THIS TEST CURRENTLY FAILS IN JRUBY.
-        assert( RUBY_PLATFORM !~ /java/ )
-
-	lines_received = []
-	Thread.abort_on_exception = true
-	EventMachine.run {
-	    EventMachine.start_server( TestHost, TestPort, SimpleLineTest ) do |conn|
-		conn.instance_eval "@error_message = lines_received"
-	    end
-	    EventMachine.add_timer(4) {raise "test timed out"}
-	    EventMachine.defer proc {
-		t = TCPSocket.new TestHost, TestPort
-		t.write "a" * (16*1024 + 1)
-		t.write "\n"
-		t.close
-	    }, proc {
-		EventMachine.stop
-	    }
-	}
-	assert_equal( ["overlength line"], lines_received )
-    end
+    lines_received = []
+    EventMachine.run {
+      EventMachine.start_server( TestHost, TestPort, SimpleLineTest ) do |conn|
+        conn.instance_eval "@line_buffer = lines_received"
+      end
+      EventMachine.add_timer(4) {assert(false, "test timed out")}
 
+      EventMachine.connect TestHost, TestPort, StopClient do |c|
+        c.send_data "aaa\nbbb\r\nccc\n"
+        c.close_connection_after_writing
+      end
+    }
+    assert_equal( %w(aaa bbb ccc), lines_received )
+  end
 
-    #--------------------------------------------------------------------
-
-    class LineAndTextTest < EventMachine::Protocols::LineAndTextProtocol
-	def post_init
-	end
-	def receive_line line
-	    if line =~ /content-length:\s*(\d+)/i
-		@content_length = $1.to_i
-	    elsif line.length == 0
-		set_binary_mode @content_length
-	    end
-	end
-	def receive_binary_data text
-	    send_data "received #{text.length} bytes"
-	    close_connection_after_writing
-	end
-    end
+  #--------------------------------------------------------------------
 
-    def test_lines_and_text
-	output = nil
-	lines_received = []
-	text_received = []
-	Thread.abort_on_exception = true
-	EventMachine.run {
-	    EventMachine.start_server( TestHost, TestPort, LineAndTextTest ) do |conn|
-		conn.instance_eval "@lines = lines_received; @text = text_received"
-	    end
-	    EventMachine.add_timer(2) {raise "test timed out"}
-	    EventMachine.defer proc {
-		t = TCPSocket.new TestHost, TestPort
-		t.puts "Content-length: 400"
-		t.puts
-		t.write "A" * 400
-		output = t.read
-		t.close
-	    }, proc {
-		EventMachine.stop
-	    }
-	}
-	assert_equal( "received 400 bytes", output )
+  class SimpleLineTest < EventMachine::Protocols::LineAndTextProtocol
+    def receive_error text
+      @error_message << text
     end
+  end
 
-    #--------------------------------------------------------------------
-
-
-    class BinaryTextTest < EventMachine::Protocols::LineAndTextProtocol
-	def post_init
-	end
-	def receive_line line
-	    if line =~ /content-length:\s*(\d+)/i
-		set_binary_mode $1.to_i
-	    else
-		raise "protocol error"
-	    end
-	end
-	def receive_binary_data text
-	    send_data "received #{text.length} bytes"
-	    close_connection_after_writing
-	end
-    end
+  def test_overlength_lines
+    # THIS TEST CURRENTLY FAILS IN JRUBY.
+    assert( RUBY_PLATFORM !~ /java/ )
 
-    def test_binary_text
-	output = nil
-	lines_received = []
-	text_received = []
-	Thread.abort_on_exception = true
-	EventMachine.run {
-	    EventMachine.start_server( TestHost, TestPort, BinaryTextTest ) do |conn|
-		conn.instance_eval "@lines = lines_received; @text = text_received"
-	    end
-	    EventMachine.add_timer(4) {raise "test timed out"}
-	    EventMachine.defer proc {
-		t = TCPSocket.new TestHost, TestPort
-		t.puts "Content-length: 10000"
-		t.write "A" * 10000
-		output = t.read
-		t.close
-	    }, proc {
-		EventMachine.stop
-	    }
-	}
-	assert_equal( "received 10000 bytes", output )
-    end
+    lines_received = []
+    EventMachine.run {
+      EventMachine.start_server( TestHost, TestPort, SimpleLineTest ) do |conn|
+        conn.instance_eval "@error_message = lines_received"
+      end
+      EventMachine.add_timer(4) {assert(false, "test timed out")}
 
-    #--------------------------------------------------------------------
-end
+      EventMachine.connect TestHost, TestPort, StopClient do |c|
+        c.send_data "a" * (16*1024 + 1)
+        c.send_data "\n"
+        c.close_connection_after_writing
+      end
+
+    }
+    assert_equal( ["overlength line"], lines_received )
+  end
 
 
+  #--------------------------------------------------------------------
+
+  class LineAndTextTest < EventMachine::Protocols::LineAndTextProtocol
+    def post_init
+    end
+    def receive_line line
+      if line =~ /content-length:\s*(\d+)/i
+        @content_length = $1.to_i
+      elsif line.length == 0
+        set_binary_mode @content_length
+      end
+    end
+    def receive_binary_data text
+      send_data "received #{text.length} bytes"
+      close_connection_after_writing
+    end
+  end
+
+  def test_lines_and_text
+    output = ''
+    lines_received = []
+    text_received = []
+    EventMachine.run {
+      EventMachine.start_server( TestHost, TestPort, LineAndTextTest ) do |conn|
+        conn.instance_eval "@lines = lines_received; @text = text_received"
+      end
+      EventMachine.add_timer(4) {assert(false, "test timed out")}
+
+      EventMachine.connect TestHost, TestPort, StopClient do |c|
+        c.set_receive_data { |data| output << data }
+        c.send_data "Content-length: 400\n"
+        c.send_data "\n"
+        c.send_data "A" * 400
+        EM.add_timer(0.1) { c.close_connection_after_writing }
+      end
+    }
+    assert_equal( "received 400 bytes", output )
+  end
+
+  #--------------------------------------------------------------------
+
+
+  class BinaryTextTest < EventMachine::Protocols::LineAndTextProtocol
+    def post_init
+    end
+    def receive_line line
+      if line =~ /content-length:\s*(\d+)/i
+        set_binary_mode $1.to_i
+      else
+        raise "protocol error"
+      end
+    end
+    def receive_binary_data text
+      send_data "received #{text.length} bytes"
+      close_connection_after_writing
+    end
+  end
+
+  def test_binary_text
+    output = ''
+    lines_received = []
+    text_received = []
+    EventMachine.run {
+      EventMachine.start_server( TestHost, TestPort, BinaryTextTest ) do |conn|
+        conn.instance_eval "@lines = lines_received; @text = text_received"
+      end
+      EventMachine.add_timer(4) {assert(false, "test timed out")}
+
+      EventMachine.connect TestHost, TestPort, StopClient do |c|
+        c.set_receive_data { |data| output << data }
+        c.send_data "Content-length: 10000\n"
+        c.send_data "A" * 10000
+        EM.add_timer(0.2) { c.close_connection_after_writing }
+      end
+    }
+    assert_equal( "received 10000 bytes", output )
+  end
+
+  #--------------------------------------------------------------------
+end

data/tests/test_ltp2.rb

@@ -1,4 +1,4 @@
-# $Id: test_ltp2.rb 725 2008-06-29 23:04:48Z francis $
+# $Id$
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com

data/tests/test_next_tick.rb

@@ -1,4 +1,4 @@
-# $Id: test_next_tick.rb 697 2008-06-15 22:00:00Z francis $
+# $Id$
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com

data/tests/test_processes.rb

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

data/tests/test_pure.rb

@@ -1,4 +1,4 @@
-# $Id: test_pure.rb 668 2008-01-04 23:00:34Z blackhedd $
+# $Id$
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com
@@ -67,7 +67,8 @@ class TestPure < Test::Unit::TestCase
     assert_raise( RuntimeError ) { run_exception }
   end
   def test_exception_2
-    assert_raise( RuntimeError ) { run_exception }
+		ex_class = RUBY_PLATFORM == 'java' ? NativeException : RuntimeError
+    assert_raise( ex_class ) { run_exception }
   end