eventmachine 0.12.6-java

data/tests/test_exc.rb

@@ -0,0 +1,58 @@
+# $Id$
+#
+# Author:: Francis Cianfrocca (gmail: blackhedd)
+# Homepage::  http://rubyeventmachine.com
+# Date:: 8 April 2006
+# 
+# See EventMachine and EventMachine::Connection for documentation and
+# usage examples.
+#
+#----------------------------------------------------------------------------
+#
+# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
+# Gmail: blackhedd
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#
+#---------------------------------------------------------------------------
+#
+#
+
+$:.unshift "../lib"
+require 'eventmachine'
+require 'test/unit'
+
+class TestSomeExceptions < Test::Unit::TestCase
+
+
+    # Read the commentary in EventMachine#run.
+    # This test exercises the ensure block in #run that makes sure
+    # EventMachine#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 EventMachine#run will fail with a C++ exception
+    # because the machine wasn't cleaned up properly.
+
+    def test_a
+	assert_raises(RuntimeError) {
+	    EventMachine.run {
+		raise "some exception"
+	    }
+	}
+    end
+
+    def test_b
+	assert_raises(RuntimeError) {
+	    EventMachine.run {
+		raise "some exception"
+	    }
+	}
+    end
+
+
+end
+

data/tests/test_futures.rb

@@ -0,0 +1,214 @@
+# $Id$
+#
+# Author:: Francis Cianfrocca (gmail: blackhedd)
+# Homepage::  http://rubyeventmachine.com
+# Date:: 8 April 2006
+# 
+# See EventMachine and EventMachine::Connection for documentation and
+# usage examples.
+#
+#----------------------------------------------------------------------------
+#
+# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
+# Gmail: blackhedd
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#
+#---------------------------------------------------------------------------
+#
+#
+#
+
+$:.unshift "../lib"
+require 'eventmachine'
+require 'test/unit'
+
+
+
+class TestFutures < Test::Unit::TestCase
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  def test_future
+      assert_equal(100, EventMachine::Deferrable.future(100) )
+
+      p1 = proc { 100 + 1 }
+      assert_equal(101, EventMachine::Deferrable.future(p1) )
+  end
+
+
+
+  class MyFuture
+      include EventMachine::Deferrable
+      def initialize *args
+	  super
+	  set_deferred_status :succeeded, 40
+      end
+  end
+
+  class MyErrorFuture
+      include EventMachine::Deferrable
+      def initialize *args
+	  super
+	  set_deferred_status :failed, 41
+      end
+  end
+
+
+  def test_future_1
+      # Call future with one additional argument and it will be treated as a callback.
+      def my_future
+	  MyFuture.new
+      end
+
+      value = nil
+      EventMachine::Deferrable.future my_future, proc {|v| value=v}
+      assert_equal( 40, value )
+  end
+
+
+  def test_future_2
+      # Call future with two additional arguments and they will be treated as a callback
+      # and an errback.
+      value = nil
+      EventMachine::Deferrable.future MyErrorFuture.new, nil, proc {|v| value=v}
+      assert_equal( 41, value )
+  end
+
+
+  def test_future_3
+      # Call future with no additional arguments but with a block, and the block will be
+      # treated as a callback.
+      value = nil
+      EventMachine::Deferrable.future MyFuture.new do |v|
+	  value=v
+      end
+      assert_equal( 40, value )
+  end
+
+
+  class RecursiveCallback
+      include EventMachine::Deferrable
+  end
+
+  # A Deferrable callback can call #set_deferred_status to change the values
+  # passed to subsequent callbacks.
+  #
+  def test_recursive_callbacks
+      n = 0 # counter assures that all the tests actually run.
+      rc = RecursiveCallback.new
+      rc.callback {|a|
+	  assert_equal(100, a)
+	  n += 1
+	  rc.set_deferred_status :succeeded, 101, 101
+      }
+      rc.callback {|a,b|
+	  assert_equal(101, a)
+	  assert_equal(101, b)
+	  n += 1
+	  rc.set_deferred_status :succeeded, 102, 102, 102
+      }
+      rc.callback {|a,b,c|
+	  assert_equal(102, a)
+	  assert_equal(102, b)
+	  assert_equal(102, c)
+	  n += 1
+      }
+      rc.set_deferred_status :succeeded, 100
+      assert_equal(3, n)
+  end
+
+
+
+	def test_syntactic_sugar
+		rc = RecursiveCallback.new
+		rc.set_deferred_success 100
+		rc.set_deferred_failure 200
+	end
+
+
+
+	# It doesn't raise an error to set deferred status more than once.
+	# In fact, this is a desired and useful idiom when it happens INSIDE
+	# a callback or errback.
+	# However, it's less useful otherwise, and in fact would generally be
+	# indicative of a programming error. However, we would like to be resistant
+	# to such errors. So whenever we set deferred status, we also clear BOTH
+	# stacks of handlers.
+	#
+	def test_double_calls
+		s = 0
+		e = 0
+
+		d = EM::DefaultDeferrable.new
+		d.callback {s += 1}
+		d.errback {e += 1}
+
+		d.succeed	# We expect the callback to be called, and the errback to be DISCARDED.
+		d.fail	# Presumably an error. We expect the errback NOT to be called.
+		d.succeed	# We expect the callback to have been discarded and NOT to be called again.
+
+		assert_equal(1, s)
+		assert_equal(0, e)
+	end
+
+
+	# Adding a callback to a Deferrable that is already in a success state executes the callback
+	# immediately. The same applies to a an errback added to an already-failed Deferrable.
+	# HOWEVER, we expect NOT to be able to add errbacks to succeeded Deferrables, or callbacks
+	# to failed ones.
+	#
+	# We illustrate this with a rather contrived test. The test calls #fail after #succeed,
+	# which ordinarily would not happen in a real program.
+	#
+	# What we're NOT attempting to specify is what happens if a Deferrable is succeeded and then
+	# failed (or vice-versa). Should we then be able to add callbacks/errbacks of the appropriate
+	# type for immediate execution? For now at least, the official answer is "don't do that."
+	#
+	def test_delayed_callbacks
+		s1 = 0
+		s2 = 0
+		e = 0
+
+		d = EM::DefaultDeferrable.new
+		d.callback {s1 += 1}
+
+		d.succeed	# Triggers and discards the callback.
+
+		d.callback {s2 += 1}	# This callback is executed immediately and discarded.
+
+		d.errback {e += 1}	# This errback should be DISCARDED and never execute.
+		d.fail		# To prove it, let's 
+
+		assert_equal( [1,1], [s1,s2] )
+		assert_equal( 0, e )
+	end
+
+
+
+
+	#
+	#
+	#
+	def test_timeout
+		n = 0
+		EM.run {
+			d = EM::DefaultDeferrable.new
+			d.callback {n = 1; EM.stop}
+			d.errback {n = 2; EM.stop}
+			d.timeout(1)
+		}
+		assert_equal( 2, n )
+	end
+
+end
+

data/tests/test_handler_check.rb

@@ -0,0 +1,37 @@
+$:.unshift "../lib"
+require 'eventmachine'
+require 'test/unit'
+
+class TestHandlerCheck < Test::Unit::TestCase
+
+  class Foo < EM::Connection; end;
+  module TestModule; end;
+
+  def test_with_correct_class
+    assert_nothing_raised do
+      EM.run {
+        EM.connect("127.0.0.1", 80, Foo)
+        EM.stop_event_loop
+      }
+    end
+  end
+
+  def test_with_incorrect_class
+    assert_raise(ArgumentError) do
+      EM.run {
+        EM.connect("127.0.0.1", 80, String)
+        EM.stop_event_loop
+      }
+    end
+  end
+
+  def test_with_module
+    assert_nothing_raised do
+      EM.run {
+        EM.connect("127.0.0.1", 80, TestModule)
+        EM.stop_event_loop
+      }
+    end
+  end
+
+end

data/tests/test_hc.rb

@@ -0,0 +1,218 @@
+# $Id$
+#
+# Author:: Francis Cianfrocca (gmail: blackhedd)
+# Homepage::  http://rubyeventmachine.com
+# Date:: 8 April 2006
+# 
+# See EventMachine and EventMachine::Connection for documentation and
+# usage examples.
+#
+#----------------------------------------------------------------------------
+#
+# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
+# Gmail: blackhedd
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#
+#---------------------------------------------------------------------------
+#
+#
+#
+
+# $:.unshift "../lib"
+require 'eventmachine'
+require 'test/unit'
+
+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
+    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