test_next_tick.rb

# $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

	# 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