eventmachine 0.12.6-java

data/tests/test_ltp2.rb

@@ -0,0 +1,320 @@
+# $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'
+
+# 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
+
+
+
+	# Test an end-of-binary call. Arrange to receive binary data but don't bother counting it
+	# as it comes. Rely on getting receive_end_of_binary_data to signal the transition back to
+	# line mode.
+	# At the present time, this isn't strictly necessary with sized binary chunks because by
+	# definition we accumulate them and make exactly one call to receive_binary_data, but
+	# we may want to support a mode in the future that would break up large chunks into multiple
+	# calls.
+	class LazyBinary
+		include EM::Protocols::LineText2
+		attr_reader :data, :end
+		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
+		def receive_end_of_binary_data
+			@end = true
+		end
+	end
+	def test_receive_end_of_binary_data
+		testdata = "_" * 1000
+		a = LazyBinary.new
+		testdata.length.times {|i| a.receive_data( testdata[i...i+1] ) }
+		assert_equal( "_" * 1000, a.data )
+		assert( a.end )
+	end
+
+
+	# This tests a bug fix in which calling set_text_mode failed when called
+	# inside receive_binary_data.
+	#
+	class BinaryPair
+		include EM::Protocols::LineText2
+		attr_reader :sizes
+		def initialize *args
+			super
+			set_text_mode 1
+			@sizes = []
+		end
+		def receive_binary_data dt
+			@sizes <<  dt.length
+			set_text_mode( (dt.length == 1) ? 2 : 1 )
+		end
+	end
+	def test_binary_pairs
+		test_data = "123" * 5
+		a = BinaryPair.new
+		a.receive_data test_data
+		assert_equal( [1,2,1,2,1,2,1,2,1,2], a.sizes )
+	end
+
+end
+

data/tests/test_next_tick.rb

@@ -0,0 +1,109 @@
+# $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 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
+
+	# This illustrates the solution to a long-standing problem.
+	# It's now possible to correctly nest calls to EM#run.
+	# See the source code commentary for EM#run for more info.
+	#
+	def test_run_run
+		EM.run {
+			EM.run {
+				EM.next_tick {EM.stop}
+			}
+		}
+	end
+
+	def test_pre_run_queue
+		x = false
+		EM.next_tick { EM.stop; x = true }
+		EM.run { EM.add_timer(0.2) { EM.stop } }
+		assert x
+	end
+
+	# We now support an additional parameter for EM#run.
+	# You can pass two procs to EM#run now. The first is executed as the normal
+	# run block. The second (if given) is scheduled for execution after the
+	# reactor loop completes.
+	# The reason for supporting this is subtle. There has always been an expectation
+	# that EM#run doesn't return until after the reactor loop ends. But now it's
+	# possible to nest calls to EM#run, which means that a nested call WILL
+	# RETURN. In order to write code that will run correctly either way, it's
+	# recommended to put any code which must execute after the reactor completes
+	# in the second parameter.
+	#
+	def test_run_run_2
+		a = proc {EM.stop}
+		b = proc {assert true}
+		EM.run a, b
+	end
+
+
+	# This illustrates that EM#run returns when it's called nested.
+	# This isn't a feature, rather it's something to be wary of when writing code
+	# that must run correctly even if EM#run is called while a reactor is already
+	# running.
+	def test_run_run_3
+		a = []
+		EM.run {
+			EM.run proc {EM.stop}, proc {a << 2}
+			a << 1
+		}
+		assert_equal( [1,2], a )
+	end
+
+end

data/tests/test_processes.rb

@@ -0,0 +1,95 @@
+# $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 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
+
+  def setup
+    $out = nil
+    $status = nil
+  end
+
+  def test_em_system
+    EM.run{
+      EM.system('ls'){ |out,status| $out, $status = out, status; EM.stop }
+    }
+
+    assert( $out.length > 0 )
+    assert_equal($status.exitstatus, 0)
+    assert_equal($status.class, Process::Status)
+  end
+
+  def test_em_system_with_proc
+    EM.run{
+      EM.system('ls', proc{ |out,status| $out, $status = out, status; EM.stop })
+    }
+
+    assert( $out.length > 0 )
+    assert_equal($status.exitstatus, 0)
+    assert_equal($status.class, Process::Status)
+  end
+
+  def test_em_system_with_two_procs
+    EM.run{
+      EM.system('sh', proc{ |process|
+        process.send_data("echo hello\n")
+        process.send_data("exit\n")
+      }, proc{ |out,status|
+        $out = out
+        $status = status
+        EM.stop
+      })
+    }
+
+    assert_equal($out, "hello\n")
+  end
+end
+