eventmachine 0.12.0-i386-mswin32

data/tests/test_ltp2.rb

@@ -0,0 +1,261 @@
+# $Id: test_ltp2.rb 668 2008-01-04 23:00:34Z blackhedd $
+#
+# 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'
+
+# TODO!!! Need tests for overlength headers and text bodies.
+
+class TestLineText2 < Test::Unit::TestCase
+
+	# Run each of these tests two ways: passing in the whole test-dataset in one chunk,
+	# and passing it in one character at a time.
+
+	class Basic
+		include EM::Protocols::LineText2
+		attr_reader :lines
+		def receive_line line
+			(@lines ||= []) << line
+		end
+	end
+	def test_basic
+		testdata = "Line 1\nLine 2\r\nLine 3\n"
+
+		a = Basic.new
+		a.receive_data testdata
+		assert_equal( ["Line 1", "Line 2", "Line 3"], a.lines )
+
+		a = Basic.new
+		testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
+		assert_equal( ["Line 1", "Line 2", "Line 3"], a.lines )
+	end
+
+
+	class ChangeDelimiter
+		include EM::Protocols::LineText2
+		attr_reader :lines
+		def initialize *args
+			super
+			@delim = "A"
+			set_delimiter @delim
+		end
+		def receive_line line
+			(@lines ||= []) << line
+			set_delimiter( @delim.succ! )
+		end
+	end
+
+	def test_change_delimiter
+		testdata = %Q(LineaALinebBLinecCLinedD)
+
+		a = ChangeDelimiter.new
+		a.receive_data testdata
+		assert_equal( ["Linea", "Lineb", "Linec", "Lined"], a.lines )
+
+		a = ChangeDelimiter.new
+		testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
+		assert_equal( ["Linea", "Lineb", "Linec", "Lined"], a.lines )
+	end
+
+
+	#--
+	# Test two lines followed by an empty line, ten bytes of binary data, then
+	# two more lines.
+
+	class Binary
+		include EM::Protocols::LineText2
+		attr_reader :lines, :body
+		def initialize *args
+			super
+			@lines = []
+			@body = nil
+		end
+		def receive_line ln
+			if ln == ""
+				set_text_mode 10
+			else
+				@lines << ln
+			end
+		end
+		def receive_binary_data data
+			@body = data
+		end
+	end
+
+	def test_binary
+		testdata = %Q(Line 1
+Line 2
+
+0000000000Line 3
+Line 4
+)
+
+		a = Binary.new
+		a.receive_data testdata
+		assert_equal( ["Line 1", "Line 2", "Line 3", "Line 4"], a.lines)
+		assert_equal( "0000000000", a.body )
+
+		a = Binary.new
+		testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
+		assert_equal( ["Line 1", "Line 2", "Line 3", "Line 4"], a.lines)
+		assert_equal( "0000000000", a.body )
+	end
+
+
+	# Test unsized binary data. The expectation is that each chunk of it
+	# will be passed to us as it it received.
+	class UnsizedBinary
+		include EM::Protocols::LineText2
+		attr_reader :n_calls, :body
+		def initialize *args
+			super
+			set_text_mode
+		end
+		def receive_binary_data data
+			@n_calls ||= 0
+			@n_calls += 1
+			(@body ||= "") << data
+		end
+	end
+
+	def test_unsized_binary
+		testdata = "X\0" * 1000
+
+		a = UnsizedBinary.new
+		a.receive_data testdata
+		assert_equal( 1, a.n_calls )
+		assert_equal( testdata, a.body )
+
+		a = UnsizedBinary.new
+		testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
+		assert_equal( 2000, a.n_calls )
+		assert_equal( testdata, a.body )
+	end
+
+
+	# Test binary data with a "throw back" into line-mode.
+	class ThrowBack
+		include EM::Protocols::LineText2
+		attr_reader :headers
+		def initialize *args
+			super
+			@headers = []
+			@n_bytes = 0
+			set_text_mode
+		end
+		def receive_binary_data data
+			wanted = 25 - @n_bytes
+			will_take = if data.length > wanted
+				data.length - wanted
+			else
+				data.length
+			end
+			@n_bytes += will_take
+
+			if @n_bytes == 25
+				set_line_mode( data[will_take..-1] )
+			end
+		end
+		def receive_line ln
+			@headers << ln
+		end
+	end
+	def test_throw_back
+		testdata = "Line\n" * 10
+
+		a = ThrowBack.new
+		a.receive_data testdata
+		assert_equal( ["Line"] * 5, a.headers )
+
+		a = ThrowBack.new
+		testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
+		assert_equal( ["Line"] * 5, a.headers )
+	end
+
+	# Test multi-character line delimiters.
+	# Also note that the test data has a "tail" with no delimiter, that will be
+	# discarded, but cf. the BinaryTail test.
+	# TODO!!! This test doesn't work in the byte-by-byte case.
+	class Multichar
+		include EM::Protocols::LineText2
+		attr_reader :lines
+		def initialize *args
+			super
+			@lines = []
+			set_delimiter "012"
+		end
+		def receive_line ln
+			@lines << ln
+		end
+	end
+	def test_multichar
+		testdata = "Line012Line012Line012Line"
+
+		a = Multichar.new
+		a.receive_data testdata
+		assert_equal( ["Line"]*3, a.lines )
+
+		a = Multichar.new
+		testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
+		# DOESN'T WORK in this case. Multi-character delimiters are broken.
+		#assert_equal( ["Line"]*3, a.lines )
+	end
+
+	# Test a binary "tail," when a sized binary transfer doesn't complete because
+	# of an unbind. We get a partial result.
+	class BinaryTail
+		include EM::Protocols::LineText2
+		attr_reader :data
+		def initialize *args
+			super
+			@data = ""
+			set_text_mode 1000
+		end
+		def receive_binary_data data
+			# we expect to get all the data in one chunk, even in the byte-by-byte case,
+			# because sized transfers by definition give us exactly one call to
+			# #receive_binary_data.
+			@data = data
+		end
+	end
+	def test_binary_tail
+		testdata = "0" * 500
+
+		a = BinaryTail.new
+		a.receive_data testdata
+		a.unbind
+		assert_equal( "0" * 500, a.data )
+
+		a = BinaryTail.new
+		testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
+		a.unbind
+		assert_equal( "0" * 500, a.data )
+	end
+
+end
+

data/tests/test_next_tick.rb

@@ -0,0 +1,58 @@
+# $Id: test_next_tick.rb 668 2008-01-04 23:00:34Z blackhedd $
+#
+# 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 TestNextTick < Test::Unit::TestCase
+
+	def setup
+	end
+
+	def teardown
+	end
+
+	def test_tick_arg
+		pr = proc {EM.stop}
+		EM.epoll
+		EM.run {
+			EM.next_tick pr
+		}
+		assert true
+	end
+
+	def test_tick_block
+		EM.epoll
+		EM.run {
+			EM.next_tick {EM.stop}
+		}
+		assert true
+	end
+end

data/tests/test_processes.rb

@@ -0,0 +1,56 @@
+# $Id: test_processes.rb 668 2008-01-04 23:00:34Z blackhedd $
+#
+# 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 TestProcesses < Test::Unit::TestCase
+
+	# EM::DeferrableChildProcess is a sugaring of a common use-case
+	# involving EM::popen.
+	# Call the #open method on EM::DeferrableChildProcess, passing
+	# a command-string. #open immediately returns an EM::Deferrable
+	# object. It also schedules the forking of a child process, which
+	# will execute the command passed to #open.
+	# When the forked child terminates, the Deferrable will be signalled
+	# and execute its callbacks, passing the data that the child process
+	# wrote to stdout.
+	#
+	def test_deferrable_child_process
+		ls = ""
+		EM.run {
+			d = EM::DeferrableChildProcess.open( "ls -ltr" )
+			d.callback {|data_from_child|
+				ls = data_from_child
+				EM.stop
+			}
+		}
+		assert( ls.length > 0)
+	end
+
+end
+

data/tests/test_pure.rb

@@ -0,0 +1,128 @@
+# $Id: test_pure.rb 668 2008-01-04 23:00:34Z blackhedd $
+#
+# 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 TestPure < Test::Unit::TestCase
+
+
+  Host,Port = "0.0.0.0", 9060
+
+
+  # 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.
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  #-------------------------------------
+
+  # 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.
+  # One way to see this is to run identical tests that open a TCP server and throw
+  # an exception. (We do this twice because an exception aborts a test. We make the
+  # two tests identical except for the method name because we can't predict the order
+  # in which the test harness will run them.)
+  # 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 run_exception
+      EM.run {
+        EM.start_server Host, Port
+        raise "an exception"
+      }
+  end
+  def test_exception_1
+    assert_raise( RuntimeError ) { run_exception }
+  end
+  def test_exception_2
+    assert_raise( RuntimeError ) { 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
+  # 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
+    EM.run {
+      EM.connect "0.0.0.0", 60001, TestConnrefused
+    }
+  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
+    timeout = false
+    EM.run {
+      EM.start_server "0.0.0.0", 60002
+      EM.connect "0.0.0.0", 60002, TestConnaccepted
+      EM::Timer.new(1) {timeout = true; EM.stop}
+    }
+    assert_equal( false, timeout )
+  end
+
+
+
+  def test_reactor_running
+    a = false
+    EM.run {
+      a = EM.reactor_running?
+      EM.next_tick {EM.stop}
+    }
+    assert a
+  end
+
+
+end