roby 0.7

data/test/test_testcase.rb

@@ -0,0 +1,122 @@
+$LOAD_PATH.unshift File.expand_path('..', File.dirname(__FILE__))
+require 'roby/test/common'
+require 'roby/test/testcase'
+require 'roby/test/tasks/simple_task'
+require 'flexmock'
+
+class TC_Test_TestCase < Test::Unit::TestCase 
+    include Roby::Test
+    include Roby::Test::Assertions
+
+    def test_assert_any_event
+	plan.discover(t = SimpleTask.new)
+	t.start!
+	assert_nothing_raised do
+	    assert_any_event(t.event(:start))
+	end
+
+	t.success!
+	assert_nothing_raised do
+	    assert_any_event(t.event(:start))
+	    assert_any_event([t.event(:success)], [t.event(:stop)])
+	end
+
+	plan.discover(t = SimpleTask.new)
+	t.start!
+	t.failed!
+	assert_raises(Test::Unit::AssertionFailedError) do
+	    assert_any_event([t.event(:success)], [t.event(:stop)])
+	end
+
+	Roby.logger.level = Logger::FATAL
+	Roby.control.run :detach => true
+	plan.insert(t = SimpleTask.new)
+	assert_any_event(t.event(:success)) do 
+	    t.start!
+	    t.success!
+	end
+
+	# Make control quit and check that we get ControlQuitError
+	plan.insert(t = SimpleTask.new)
+	assert_raises(Test::Unit::AssertionFailedError) do
+	    assert_any_event(t.event(:success)) do
+		t.start!
+		t.failed!
+	    end
+	end
+
+	## Same test, but check that the assertion succeeds since we *are*
+	## checking that +failed+ happens
+	Roby.control.run :detach => true
+	plan.insert(t = SimpleTask.new)
+	assert_nothing_raised do
+	    assert_any_event(t.event(:failed)) do
+		t.start!
+		t.failed!
+	    end
+	end
+    end
+
+    def test_assert_succeeds
+	Roby.control.run :detach => true
+    
+	task = Class.new(SimpleTask) do
+	    forward :start => :success
+	end.new
+	assert_nothing_raised do
+	    assert_succeeds(task)
+	end
+
+	task = Class.new(SimpleTask) do
+	    forward :start => :failed
+	end.new
+	assert_raises(Test::Unit::AssertionFailedError) do
+	    assert_succeeds(task)
+	end
+    end
+
+    def test_sampling
+	Roby.control.run :cycle => 0.1, :detach => true
+
+	i = 0
+	samples = Roby::Test.sampling(1, 0.1, :time_test, :index, :dummy) do
+	    i += 1
+	    [Roby.control.cycle_start, rand / 10 - 0.05 + i, rand / 10 + 0.95]
+	end
+	cur_size = samples.size
+
+	# Check the result
+	samples.each { |a| assert_equal(a.time_test, a.t) }
+	samples.each_with_index do |a, i|
+	    next if i == 0
+	    assert(a.dt)
+	    assert_in_delta(0.1, a.dt, 0.01)
+	end
+	samples.each_with_index do |a, b| 
+	    assert_in_delta(b + 1, a.index, 0.05)
+	end
+
+	# Check that the handler has been removed
+	assert_equal(cur_size, samples.size)
+
+	samples
+    end
+
+    def test_stats
+	samples = test_sampling
+	stats = Roby::Test.stats(samples, :dummy => :absolute)
+	assert_in_delta(1, stats.index.mean, 0.05)
+	assert_in_delta(0.025, stats.index.stddev, 0.026)
+	assert_in_delta(1, stats.dummy.mean, 0.05)
+	assert_in_delta(0.025, stats.dummy.stddev, 0.026)
+	assert_in_delta(0.1, stats.dt.mean, 0.001, stats.dt)
+	assert_in_delta(0, stats.dt.stddev, 0.001)
+
+	stats = Roby::Test.stats(samples, :index => :rate, :dummy => :absolute_rate)
+	assert_in_delta(10, stats.index.mean,  1)
+	assert_in_delta(0.25, stats.index.stddev, 0.25)
+	assert_in_delta(10, stats.dummy.mean,  1)
+	assert_in_delta(0.25, stats.dummy.stddev, 0.25)
+    end
+end
+

data/test/test_thread_task.rb

@@ -0,0 +1,73 @@
+$LOAD_PATH.unshift File.expand_path('..', File.dirname(__FILE__))
+require 'roby/test/common'
+require 'roby/thread_task'
+require 'roby/test/tasks/simple_task'
+require 'roby/test/tasks/empty_task'
+
+class TC_ThreadTask < Test::Unit::TestCase 
+    include Roby::Test
+
+    def test_normal
+        model = Class.new(Roby::ThreadTask) do
+            implementation do
+                1
+            end
+        end
+
+        plan.insert(task = model.new)
+        task.start!
+        while task.thread
+            process_events
+            sleep 0.1
+        end
+
+        assert task.success?
+        assert_equal 1, task.result
+    end
+
+    def test_implementation_fails
+        Thread.abort_on_exception = false
+        Roby.control.abort_on_exception = false
+        model = Class.new(Roby::ThreadTask) do
+            implementation do
+                raise ArgumentError, "blaaaaaaaaah"
+            end
+        end
+
+        plan.discover(task = model.new)
+        task.start!
+        while task.thread
+            process_events
+            sleep 0.1
+        end
+
+        assert task.failed?
+        assert_kind_of ArgumentError, task.event(:failed).last.context.first
+        assert_equal nil, task.result
+    end
+
+    def test_interruptible
+        Thread.abort_on_exception = false
+        model = Class.new(Roby::ThreadTask) do
+            interruptible
+            implementation do
+                loop do
+                    interruption_point
+                    sleep 0.1
+                end
+            end
+        end
+
+        plan.discover(task = model.new)
+        task.start!
+        while task.thread
+            process_events
+            sleep 0.1
+        end
+
+        assert task.failed?
+        assert_kind_of Interrupt, task.event(:failed).last.context.first
+        assert_equal nil, task.result
+    end
+end
+

data/test/test_transactions.rb

@@ -0,0 +1,569 @@
+$LOAD_PATH.unshift File.expand_path('..', File.dirname(__FILE__))
+require 'roby/test/common'
+require 'roby/test/tasks/simple_task'
+require 'flexmock'
+
+require 'test/test_plan'
+
+# Check that a transaction behaves like a plan
+class TC_TransactionAsPlan < Test::Unit::TestCase
+    include TC_PlanStatic
+    include Roby::Test
+
+    alias :real_plan :plan
+    attr_reader :plan
+    def setup
+	@plan = Transaction.new(real_plan)
+	super
+    end
+    def teardown
+	@plan.discard_transaction
+	real_plan.clear
+	super
+    end
+end
+
+module TC_TransactionBehaviour
+    include Roby::Transactions
+
+    Hierarchy = Roby::TaskStructure::Hierarchy
+    PlannedBy = Roby::TaskStructure::PlannedBy
+    Signal = Roby::EventStructure::Signal
+    Forwarding = Roby::EventStructure::Forwarding
+
+    SimpleTask = Roby::Test::SimpleTask
+
+    def transaction_op(plan, op, *needed_proxies)
+	trsc = Roby::Transaction.new(plan)
+	proxies = needed_proxies.map do |o|
+	    plan.discover(o) unless o.plan
+
+	    p = trsc[o]
+	    assert_not_equal(p, o)
+	    p
+	end
+	yield(trsc, *proxies)
+
+	# Check that no task in trsc are in plan, and that no task of plan are in trsc
+	assert( (trsc.known_tasks & plan.known_tasks).empty?, (trsc.known_tasks & plan.known_tasks))
+
+	plan = trsc.plan
+	trsc.send(op)
+	assert(!trsc.plan)
+	assert(plan.transactions.empty?)
+
+	# Check that there is no proxy left in the graph
+	[[Roby::TaskStructure, Roby::Task], [Roby::EventStructure, Roby::EventGenerator]].each do |structure, klass|
+	    structure.each_relation do |rel|
+		rel.each_vertex do |v|
+		    assert_kind_of(klass, v)
+		end
+	    end
+	end
+	plan.known_tasks.each do |t|
+	    assert_kind_of(Roby::Task, t, t.class.ancestors.inspect)
+	end
+
+    rescue
+	trsc.discard_transaction rescue nil
+	raise
+    end
+
+    def transaction_commit(plan, *needed_proxies, &block)
+	transaction_op(plan, :commit_transaction, *needed_proxies, &block)
+    end
+    def transaction_discard(plan, *needed_proxies, &block)
+	transaction_op(plan, :discard_transaction, *needed_proxies, &block)
+    end
+
+    # Checks that model-level task relations are kept if a task is modified by a transaction
+    def test_commit_task
+	t = prepare_plan :tasks => 1
+	transaction_commit(plan, t) do |trsc, p|
+	    trsc.discover(p)
+	    assert(p.event(:start).child_object?(p.event(:updated_data), Roby::EventStructure::Precedence))
+	    assert(p.event(:failed).child_object?(p.event(:stop), Roby::EventStructure::Forwarding))
+	end
+	assert(t.event(:start).child_object?(t.event(:updated_data), Roby::EventStructure::Precedence))
+	assert(t.event(:failed).child_object?(t.event(:stop), Roby::EventStructure::Forwarding))
+
+	t = prepare_plan :discover => 1
+	transaction_commit(plan, t) do |trsc, p|
+	    trsc.insert(p)
+	end
+	assert(t.event(:start).child_object?(t.event(:updated_data), Roby::EventStructure::Precedence))
+	assert(t.event(:failed).child_object?(t.event(:stop), Roby::EventStructure::Forwarding))
+    end
+
+    def test_commit_arguments
+	(t1, t2), t = prepare_plan :discover => 2, :tasks => 1
+	t1.arguments[:first] = 10
+	transaction_commit(plan, t1, t2) do |trsc, p1, p2|
+	    p1.arguments[:first] = 20
+	    p1.arguments[:second] = p2
+	    trsc.discover(t)
+	    t.arguments[:task] = p2
+	end
+
+	assert_equal(20, t1.arguments[:first])
+	assert_equal(t2, t1.arguments[:second])
+	assert_equal(t2, t.arguments[:task])
+
+	transaction_discard(plan, t1, t2) do |trsc, p1, p2|
+	    p1.arguments[:first] = 10
+	    assert_equal(p2, p1.arguments[:second])
+	end
+
+	assert_equal(20, t1.arguments[:first])
+	assert_equal(t2, t1.arguments[:second])
+    end
+
+    # Tests insertion and removal of tasks
+    def test_commit_plan_tasks
+	t1, (t2, t3) = prepare_plan(:missions => 1, :tasks => 2)
+
+	transaction_commit(plan, t1) do |trsc, p1|
+	    assert(trsc.include?(p1))
+	    assert(trsc.mission?(p1))
+	end
+
+	transaction_commit(plan) do |trsc| 
+	    assert(!trsc.include?(t3))
+	    trsc.discover(t3)
+	    assert(trsc.include?(t3))
+	    assert(!trsc.mission?(t3))
+	    assert(!plan.include?(t3))
+	    assert(!plan.mission?(t3))
+	end
+	assert(plan.include?(t3))
+	assert(!plan.mission?(t3))
+
+	transaction_commit(plan) do |trsc| 
+	    assert(!trsc.include?(t2))
+	    trsc.insert(t2) 
+	    assert(trsc.include?(t2))
+	    assert(trsc.mission?(t2))
+	    assert(!plan.include?(t2))
+	    assert(!plan.mission?(t2))
+	end
+	assert(plan.include?(t2))
+	assert(plan.mission?(t2))
+
+	transaction_commit(plan, t2) do |trsc, p2|
+	    assert(trsc.mission?(p2))
+	    trsc.discard(p2)
+	    assert(trsc.include?(p2))
+	    assert(!trsc.mission?(p2))
+	    assert(plan.include?(t2))
+	    assert(plan.mission?(t2))
+	end
+	assert(plan.include?(t2))
+	assert(!plan.mission?(t2))
+
+	transaction_commit(plan, t3) do |trsc, p3|
+	    assert(trsc.include?(p3))
+	    trsc.remove_object(p3) 
+	    assert(!trsc.include?(p3))
+	    assert(!trsc.wrap(t3, false))
+	    assert(!trsc.include?(t3))
+	    assert(plan.include?(t3))
+	end
+	assert(!plan.include?(t3))
+	assert(!plan.mission?(t3))
+
+	plan.permanent(t3 = Roby::Task.new)
+	transaction_commit(plan, t3) do |trsc, p3|
+	    assert(trsc.permanent?(p3))
+	    trsc.auto(t3)
+	    assert(!trsc.permanent?(p3))
+	    assert(plan.permanent?(t3))
+	end
+	assert(!plan.permanent?(t3))
+
+	transaction_commit(plan, t3) do |trsc, p3|
+	    trsc.permanent(p3)
+	    assert(trsc.permanent?(p3))
+	    assert(!plan.permanent?(t3))
+	end
+	assert(plan.permanent?(t3))
+    end
+
+    def test_commit_task_relations
+	(t1, t2), (t3, t4) = prepare_plan(:missions => 2, :tasks => 2)
+	t1.realized_by t2
+
+	transaction_commit(plan) do |trsc|
+	    trsc.discover t3
+	    trsc.discover t4
+	    t3.planned_by t4
+	end
+	assert(PlannedBy.linked?(t3, t4))
+
+	t = Roby::Task.new
+	transaction_commit(plan, t1, t2) do |trsc, p1, p2|
+	    t.realized_by p1
+	    assert(Hierarchy.linked?(t, p1))
+	    assert(!Hierarchy.linked?(t, t1))
+	end
+	assert(Hierarchy.linked?(t, t1))
+
+	t = Roby::Task.new
+	transaction_commit(plan, t1, t2) do |trsc, p1, p2|
+	    p2.realized_by t
+	    assert(Hierarchy.linked?(p2, t))
+	    assert(!Hierarchy.linked?(t2, t))
+	end
+	assert(Hierarchy.linked?(t2, t))
+
+	transaction_commit(plan, t1, t2) do |trsc, p1, p2|
+	    p1.remove_child_object(p2, Hierarchy)
+	    assert(!Hierarchy.linked?(p1, p2))
+	    assert(Hierarchy.linked?(t1, t2))
+	end
+	assert(!Hierarchy.linked?(t1, t2))
+
+	transaction_commit(plan, t3, t4) do |trsc, p3, p4|
+	    trsc.remove_task(p3)
+	    assert(!trsc.include?(p3))
+	    assert(!PlannedBy.linked?(p3, p4))
+	    assert(PlannedBy.linked?(t3, t4))
+	end
+	assert(!PlannedBy.linked?(t3, t4))
+    end
+
+    def test_commit_event_relations
+	(t1, t2), (t3, t4) = prepare_plan :missions => 2, :tasks => 2,
+	    :model => SimpleTask
+	t1.on(:start, t2, :success)
+
+	transaction_commit(plan, t1, t2) do |trsc, p1, p2|
+	    trsc.discover t3
+	    t3.event(:stop).on p2.event(:start)
+	    assert(Signal.linked?(t3.event(:stop), p2.event(:start)))
+	    assert(!Signal.linked?(t3.event(:stop), t2.event(:start)))
+	end
+	assert(Signal.linked?(t3.event(:stop), t2.event(:start)))
+
+	transaction_commit(plan, t1, t2) do |trsc, p1, p2|
+	    p1.event(:stop).on p2.event(:start)
+	    assert(Signal.linked?(p1.event(:stop), p2.event(:start)))
+	    assert(!Signal.linked?(t1.event(:stop), t2.event(:start)))
+	end
+	assert(Signal.linked?(t1.event(:stop), t2.event(:start)))
+
+	transaction_commit(plan, t1, t2) do |trsc, p1, p2|
+	    trsc.discover t4
+	    p1.event(:stop).on t4.event(:start)
+	    assert(Signal.linked?(p1.event(:stop), t4.event(:start)))
+	end
+	assert(Signal.linked?(t1.event(:stop), t4.event(:start)))
+
+	transaction_commit(plan, t1, t2) do |trsc, p1, p2|
+	    p1.event(:start).remove_child_object(p2.event(:success), Signal)
+	    assert(!Signal.linked?(p1.event(:start), p2.event(:success)))
+	    assert(Signal.linked?(t1.event(:start), t2.event(:success)))
+	end
+	assert(!Signal.linked?(t1.event(:start), t2.event(:success)))
+    end
+    
+    def test_commit_replace
+	task, (planned, mission, child, r) = prepare_plan :missions => 1, :tasks => 4, :model => SimpleTask
+	mission.realized_by task
+	planned.planned_by task
+	task.realized_by child
+	task.on(:stop, mission, :stop)
+	task.forward(:stop, planned, :success)
+	task.on(:start, child, :start)
+
+	transaction_commit(plan, mission, planned, task, child) do |trsc, pm, pp, pt, pc|
+	    trsc.replace(pt, r)
+
+	    assert([r], trsc.missions.to_a)
+	    assert(Hierarchy.linked?(pm, r))
+	    assert(!Hierarchy.linked?(mission, r))
+	    assert(!Hierarchy.linked?(r, pc))
+	    assert(PlannedBy.linked?(pp, r))
+	    assert(!PlannedBy.linked?(planned, r))
+
+	    assert(Signal.linked?(r.event(:stop), pm.event(:stop)))
+	    assert(!Signal.linked?(r.event(:stop), mission.event(:stop)))
+	    assert(Forwarding.linked?(r.event(:stop), pp.event(:success)))
+	    assert(!Forwarding.linked?(r.event(:stop), planned.event(:success)))
+	    assert(!Signal.linked?(r.event(:stop), pc.event(:stop)))
+	    assert(!Signal.linked?(r.event(:stop), mission.event(:stop)))
+	end
+	assert(Hierarchy.linked?(mission, r))
+	assert(!Hierarchy.linked?(mission, task))
+	assert(PlannedBy.linked?(planned, r))
+	assert(!PlannedBy.linked?(planned, task))
+	assert(Hierarchy.linked?(task, child))
+	assert(!Hierarchy.linked?(r, child))
+	assert(Signal.linked?(r.event(:stop), mission.event(:stop)))
+	assert(!Signal.linked?(task.event(:stop), mission.event(:stop)))
+	assert(Forwarding.linked?(r.event(:stop), planned.event(:success)))
+	assert(!Forwarding.linked?(task.event(:stop), planned.event(:success)))
+	assert(Signal.linked?(task.event(:start), child.event(:start)))
+	assert(!Signal.linked?(r.event(:start), child.event(:start)))
+	assert_equal([r], plan.missions.to_a)
+    end
+
+    def test_relation_validation
+	t1, t2 = prepare_plan :tasks => 2
+	transaction_commit(plan, t1) do |trsc, p1|
+	    trsc.insert(t2)
+	    assert_equal(plan, t1.plan)
+	    assert_equal(trsc, p1.plan)
+	    assert_equal(trsc, t2.plan)
+	    assert_raises(RuntimeError) { t1.realized_by t2 }
+	    assert_equal(plan, t1.event(:start).plan)
+	    assert_equal(trsc, p1.event(:start).plan)
+	    assert_equal(trsc, t2.event(:start).plan)
+	    assert_raises(RuntimeError) { t1.event(:start).on t2.event(:start) }
+	end
+    end
+
+    def test_discard_modifications
+	t1, t2, t3 = prepare_plan :missions => 1, :discover => 1, :tasks => 1
+	t1.realized_by t2
+	transaction_commit(plan, t1, t2) do |trsc, p1, p2|
+	    p1.realized_by(t3)
+	    trsc.remove_object(p1)
+	    trsc.discard_modifications(t1)
+	end
+	assert(plan.include?(t1))
+	assert_equal([t2], t1.children.to_a)
+ 
+ 	t3 = SimpleTask.new
+ 	transaction_commit(plan, t1, t2) do |trsc, p1, p2|
+ 	    p1.realized_by t3
+ 	    p1.remove_child p2
+ 	    trsc.discard_modifications(t1)
+ 	end
+ 	assert(plan.include?(t1))
+ 	assert_equal([t2], t1.children.to_a)
+     end
+
+    def test_plan_finalized_task
+	t1, t2, t3 = prepare_plan :missions => 1, :discover => 1
+	t1.realized_by t2
+
+	t3 = SimpleTask.new
+	assert_raises(Roby::InvalidTransaction) do
+	    transaction_commit(plan, t1, t2) do |trsc, p1, p2|
+		p1.realized_by(t3)
+		assert(trsc.wrap(t1, false))
+		plan.remove_object(t1)
+		assert(trsc.invalid?)
+		assert(!trsc.wrap(t1, false))
+	    end
+	end
+    end
+
+    def test_plan_add_remove_invalidate
+	t1 = prepare_plan :discover => 1
+	assert_raises(Roby::InvalidTransaction) do
+	    transaction_commit(plan, t1) do |trsc, p1|
+		trsc.conflict_solver = :invalidate
+		plan.remove_object(t1)
+		assert(trsc.invalid?)
+	    end
+	end
+
+	t1 = prepare_plan :discover => 1
+	assert_nothing_raised do
+	    transaction_commit(plan, t1) do |trsc, p1|
+		trsc.conflict_solver = :invalidate
+		trsc.remove_object(p1)
+		plan.remove_object(t1)
+		assert(!trsc.invalid?)
+	    end
+	end
+    end
+
+    def test_plan_relation_update_invalidate
+	t1, t2 = prepare_plan :discover => 2
+
+	t1.realized_by t2
+	assert_raises(Roby::InvalidTransaction) do
+	    transaction_commit(plan, t1, t2) do |trsc, p1, p2|
+		trsc.conflict_solver = :invalidate
+		assert(p1.child_object?(p2, Roby::TaskStructure::Hierarchy))
+		t1.remove_child t2
+		assert(trsc.invalid?)
+	    end
+	end
+
+	t1.realized_by t2
+	assert_nothing_raised do
+	    transaction_commit(plan, t1, t2) do |trsc, p1, p2|
+		trsc.conflict_solver = :invalidate
+		p1.remove_child p2
+		t1.remove_child t2
+		assert(!trsc.invalid?)
+	    end
+	end
+
+	t1.remove_child t2
+	assert_raises(Roby::InvalidTransaction) do
+	    transaction_commit(plan, t1, t2) do |trsc, p1, p2|
+		trsc.conflict_solver = :invalidate
+		t1.realized_by(t2)
+		assert(trsc.invalid?)
+	    end
+	end
+
+	t1.remove_child t2
+	assert_nothing_raised do
+	    transaction_commit(plan, t1, t2) do |trsc, p1, p2|
+		trsc.conflict_solver = :invalidate
+		p1.realized_by p2
+		t1.realized_by t2
+		assert(!trsc.invalid?)
+	    end
+	end
+    end
+
+    def test_plan_relation_update_solver
+	solver = Roby::SolverIgnoreUpdate.new
+
+	t1, t2, t3 = (1..3).map { SimpleTask.new }
+	t1.realized_by t2
+	plan.insert(t1)
+
+	assert_nothing_raised do
+	    transaction_commit(plan, t1, t2) do |trsc, p1, p2|
+		trsc.conflict_solver = solver
+		p1.realized_by(t3)
+		t1.remove_child(t2)
+		assert(!trsc.invalid?)
+	    end
+	end
+
+	t3 = SimpleTask.new
+	t1.remove_child t2
+	assert_nothing_raised do
+	    transaction_commit(plan, t1) do |trsc, p1|
+		trsc.conflict_solver = solver
+		p1.realized_by(t3)
+		t1.realized_by(t2)
+		assert(!trsc.invalid?)
+	    end
+	end
+    end
+
+    def test_plan_relation_update_update
+	t1, t2, t3 = (1..3).map { SimpleTask.new }
+	t1.realized_by t2
+	plan.insert(t1)
+
+	transaction_commit(plan, t1, t2) do |trsc, p1, p2|
+	    trsc.conflict_solver = :update
+	    p1.realized_by(t3)
+	    assert(p1.child_object?(p2))
+	    t1.remove_child(t2)
+	    assert(!trsc.invalid?)
+	    assert(!p1.child_object?(p2))
+	end
+
+	t3 = SimpleTask.new
+	t1.remove_child t2
+	transaction_commit(plan, t1, t2) do |trsc, p1, p2|
+	    trsc.conflict_solver = :update
+	    p1.realized_by(t3)
+	    assert(!p1.child_object?(p2))
+
+	    t1.realized_by(t2)
+	    assert(p1.child_object?(p2))
+	    assert(!trsc.invalid?)
+	end
+    end
+
+end
+
+class TC_Transactions < Test::Unit::TestCase
+    include TC_TransactionBehaviour
+    include Roby::Test
+
+    def test_and_event_aggregator
+	t1, t2, t3 = (1..3).map { SimpleTask.new }
+	transaction_commit(plan, t1) do |trsc, p1|
+	    trsc.insert(t2)
+	    trsc.insert(t3)
+	    and_generator = (p1.event(:start) & t2.event(:start))
+	    assert_equal(trsc, and_generator.plan)
+	    and_generator.on t3.event(:start)
+	end
+
+	t1.start!
+	assert(!t3.running?)
+	t2.start!
+	assert(t3.running?)
+    end
+
+    def test_or_event_aggregator
+	t1, t2, t3 = (1..3).map { SimpleTask.new }
+	transaction_commit(plan, t1) do |trsc, p1|
+	    trsc.insert(t2)
+	    trsc.insert(t3)
+	    (p1.event(:start) | t2.event(:start)).on t3.event(:start)
+	end
+
+	t1.start!
+	assert(t3.running?)
+	assert_nothing_raised { t2.start! }
+    end
+
+    def test_commit_event_handlers
+	plan.discover(e = Roby::EventGenerator.new(true))
+	def e.called_by_handler(mock)
+	    mock.called_by_handler
+	end
+
+	FlexMock.use do |mock|
+	    transaction_commit(plan, e) do |trsc, pe|
+		pe.on { mock.handler_called }
+		pe.on { pe.called_by_handler(mock) }
+	    end
+
+	    mock.should_receive(:handler_called).once
+	    mock.should_receive(:called_by_handler).once
+	    e.call(nil)
+	end
+    end
+
+    def test_forwarder_behaviour
+	t1, t2, t3 = (1..3).map { SimpleTask.new }
+
+	ev = nil
+	transaction_commit(plan, t1) do |trsc, p1|
+	    ev = EventGenerator.new do
+		p1.forward(:start, t2, :start)
+		p1.on(:start, t3, :start)
+	    end
+	    trsc.discover(ev)
+	    ev
+	end
+	ev.call
+
+	assert(t1.event(:start).child_object?(t2.event(:start), Roby::EventStructure::Forwarding))
+	assert(t1.event(:start).child_object?(t3.event(:start), Roby::EventStructure::Signal))
+    end
+end
+
+class TC_RecursiveTransaction < Test::Unit::TestCase
+    include TC_TransactionBehaviour
+    include Roby::Test
+
+    alias :real_plan :plan
+    attr_reader :plan
+    def setup
+	@plan = Roby::Transaction.new(real_plan)
+	super
+    end
+    def teardown
+	plan.discard_transaction
+	real_plan.clear
+	super
+    end
+end
+