roby 0.7.3 → 0.8.0

data/test/test_testcase.rb

@@ -1,4 +1,4 @@
-$LOAD_PATH.unshift File.expand_path('..', File.dirname(__FILE__))
+$LOAD_PATH.unshift File.expand_path(File.join('..', 'lib'), File.dirname(__FILE__))
 require 'roby/test/common'
 require 'roby/test/testcase'
 require 'roby/test/tasks/simple_task'
@@ -7,9 +7,25 @@ require 'flexmock'
 class TC_Test_TestCase < Test::Unit::TestCase 
     include Roby::Test
     include Roby::Test::Assertions
+    
+    def setup
+        Roby.app.setup_global_singletons
+
+        Roby.engine.at_cycle_end(&Test.method(:check_event_assertions))
+        Roby.engine.finalizers << Test.method(:finalize_event_assertions)
+        @plan    = Roby.plan
+        @control = Roby.control
+        @engine  = Roby.engine
+        super
+    end
+    def teardown
+        Roby.engine.at_cycle_end_handlers.delete(Test.method(:check_event_assertions))
+        Roby.engine.finalizers.delete(Test.method(:finalize_event_assertions))
+        super
+    end
 
     def test_assert_any_event
-	plan.discover(t = SimpleTask.new)
+	plan.add(t = SimpleTask.new)
 	t.start!
 	assert_nothing_raised do
 	    assert_any_event(t.event(:start))
@@ -21,7 +37,7 @@ class TC_Test_TestCase < Test::Unit::TestCase
 	    assert_any_event([t.event(:success)], [t.event(:stop)])
 	end
 
-	plan.discover(t = SimpleTask.new)
+	plan.add(t = SimpleTask.new)
 	t.start!
 	t.failed!
 	assert_raises(Test::Unit::AssertionFailedError) do
@@ -29,15 +45,15 @@ class TC_Test_TestCase < Test::Unit::TestCase
 	end
 
 	Roby.logger.level = Logger::FATAL
-	Roby.control.run :detach => true
-	plan.insert(t = SimpleTask.new)
+        Robot.logger.level = Logger::FATAL
+	engine.run
+	plan.add_permanent(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)
+	plan.add_permanent(t = SimpleTask.new)
 	assert_raises(Test::Unit::AssertionFailedError) do
 	    assert_any_event(t.event(:success)) do
 		t.start!
@@ -47,8 +63,7 @@ class TC_Test_TestCase < Test::Unit::TestCase
 
 	## 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)
+	plan.add_permanent(t = SimpleTask.new)
 	assert_nothing_raised do
 	    assert_any_event(t.event(:failed)) do
 		t.start!
@@ -58,7 +73,7 @@ class TC_Test_TestCase < Test::Unit::TestCase
     end
 
     def test_assert_succeeds
-	Roby.control.run :detach => true
+	engine.run
     
 	task = Class.new(SimpleTask) do
 	    forward :start => :success
@@ -76,12 +91,13 @@ class TC_Test_TestCase < Test::Unit::TestCase
     end
 
     def test_sampling
-	Roby.control.run :cycle => 0.1, :detach => true
+	engine.run
 
 	i = 0
+        # Sampling of 1s, every 100ms (== 1 cycle)
 	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]
+	    [engine.cycle_start, i + rand / 10 - 0.05, rand / 10 + 0.95]
 	end
 	cur_size = samples.size
 
@@ -106,17 +122,17 @@ class TC_Test_TestCase < Test::Unit::TestCase
 	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(0.025, stats.index.stddev, 0.1)
 	assert_in_delta(1, stats.dummy.mean, 0.05)
-	assert_in_delta(0.025, stats.dummy.stddev, 0.026)
+	assert_in_delta(0.025, stats.dummy.stddev, 0.1)
 	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(0.25, stats.index.stddev, 0.5)
 	assert_in_delta(10, stats.dummy.mean,  1)
-	assert_in_delta(0.25, stats.dummy.stddev, 0.25)
+	assert_in_delta(0.25, stats.dummy.stddev, 0.5)
     end
 end
 

data/test/test_transactions.rb

@@ -1,20 +1,23 @@
-$LOAD_PATH.unshift File.expand_path('..', File.dirname(__FILE__))
+$LOAD_PATH.unshift File.expand_path('.', File.dirname(__FILE__))
+$LOAD_PATH.unshift File.expand_path(File.join('..', 'lib'), File.dirname(__FILE__))
 require 'roby/test/common'
 require 'roby/test/tasks/simple_task'
 require 'flexmock'
 
-require 'test/test_plan'
+require '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 :real_plan
     attr_reader :plan
+    def engine; (real_plan || plan).engine end
     def setup
-	@plan = Transaction.new(real_plan)
 	super
+        @real_plan = @plan
+	@plan = Transaction.new(real_plan)
     end
     def teardown
 	@plan.discard_transaction
@@ -33,10 +36,84 @@ module TC_TransactionBehaviour
 
     SimpleTask = Roby::Test::SimpleTask
 
+    def test_proxy_creation
+        plan.add(t = SimpleTask.new)
+        transaction_commit(plan) do |trsc|
+            assert !trsc[t, false]
+            assert trsc.known_tasks.empty?
+
+            assert(proxy = trsc[t, true])
+            assert(trsc.include?(proxy))
+            assert_same(proxy, trsc[t, false])
+        end
+    end
+
+    def test_remove_object
+        plan.add(t = SimpleTask.new)
+        transaction_commit(plan, t) do |trsc, p|
+            trsc.remove_object(p)
+            assert_same(nil, trsc[t, false])
+            assert(!trsc.include?(p))
+        end
+
+	t1, t2, t3 = prepare_plan :missions => 1, :add => 1, :tasks => 1
+	t1.depends_on t2
+	transaction_commit(plan, t1, t2) do |trsc, p1, p2|
+	    p1.depends_on(t3)
+	    trsc.remove_object(p1)
+	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.depends_on t3
+ 	    p1.remove_child p2
+	    trsc.remove_object(p1)
+ 	end
+ 	assert(plan.include?(t1))
+ 	assert_equal([t2], t1.children.to_a)
+    end
+
+    def test_add_tasks_from_plan
+        plan.add(t = SimpleTask.new)
+        transaction_commit(plan) do |trsc|
+            assert_raises(Roby::ModelViolation) { trsc.add(t) }
+        end
+    end
+
+    def test_object_transaction_stack
+        plan.add(t = SimpleTask.new)
+        transaction_commit(plan, t) do |trsc1, p1|
+            assert_equal([trsc1, plan], p1.transaction_stack)
+            transaction_commit(trsc1, p1) do |trsc2, p2|
+                assert_equal([trsc2, trsc1, plan], p2.transaction_stack)
+            end
+        end
+    end
+
+    def test_merged_relations
+        t1, t2, t3 = prepare_plan :add => 3
+        t1.depends_on t2
+        t2.depends_on t3
+
+        transaction_commit(plan, t2) do |trsc, p2|
+            assert_equal [t1], p2.merged_relations(:each_parent_task, true).map(&:__getobj__)
+            assert_equal [t3], p2.merged_relations(:each_child, true).map(&:__getobj__)
+        end
+
+        transaction_commit(plan, t2) do |trsc, p2|
+            assert_equal [[t2, t1]], p2.merged_relations(:each_parent_task, false).to_a
+            assert_equal [[t2, t3]], p2.merged_relations(:each_child, false).to_a
+            assert !trsc[t1, false]
+            assert !trsc[t3, false]
+        end
+    end
+
     def transaction_op(plan, op, *needed_proxies)
 	trsc = Roby::Transaction.new(plan)
 	proxies = needed_proxies.map do |o|
-	    plan.discover(o) unless o.plan
+	    plan.add(o) unless o.plan
 
 	    p = trsc[o]
 	    assert_not_equal(p, o)
@@ -80,28 +157,28 @@ module TC_TransactionBehaviour
     def test_commit_task
 	t = prepare_plan :tasks => 1
 	transaction_commit(plan, t) do |trsc, p|
-	    trsc.discover(p)
+	    trsc.add(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
+	t = prepare_plan :add => 1
 	transaction_commit(plan, t) do |trsc, p|
-	    trsc.insert(p)
+	    trsc.add_mission(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, t2), t = prepare_plan :add => 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)
+	    trsc.add(t)
 	    t.arguments[:task] = p2
 	end
 
@@ -129,7 +206,7 @@ module TC_TransactionBehaviour
 
 	transaction_commit(plan) do |trsc| 
 	    assert(!trsc.include?(t3))
-	    trsc.discover(t3)
+	    trsc.add(t3)
 	    assert(trsc.include?(t3))
 	    assert(!trsc.mission?(t3))
 	    assert(!plan.include?(t3))
@@ -140,7 +217,7 @@ module TC_TransactionBehaviour
 
 	transaction_commit(plan) do |trsc| 
 	    assert(!trsc.include?(t2))
-	    trsc.insert(t2) 
+	    trsc.add_mission(t2) 
 	    assert(trsc.include?(t2))
 	    assert(trsc.mission?(t2))
 	    assert(!plan.include?(t2))
@@ -151,7 +228,7 @@ module TC_TransactionBehaviour
 
 	transaction_commit(plan, t2) do |trsc, p2|
 	    assert(trsc.mission?(p2))
-	    trsc.discard(p2)
+	    trsc.unmark_mission(p2)
 	    assert(trsc.include?(p2))
 	    assert(!trsc.mission?(p2))
 	    assert(plan.include?(t2))
@@ -160,48 +237,79 @@ module TC_TransactionBehaviour
 	assert(plan.include?(t2))
 	assert(!plan.mission?(t2))
 
+        plan.add_mission(t3)
 	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))
+	assert(plan.include?(t3))
+	assert(plan.mission?(t3))
 
-	plan.permanent(t3 = Roby::Task.new)
+	plan.add_permanent(t3 = Roby::Task.new)
 	transaction_commit(plan, t3) do |trsc, p3|
 	    assert(trsc.permanent?(p3))
-	    trsc.auto(t3)
+	    trsc.unmark_permanent(t3)
 	    assert(!trsc.permanent?(p3))
 	    assert(plan.permanent?(t3))
 	end
 	assert(!plan.permanent?(t3))
 
 	transaction_commit(plan, t3) do |trsc, p3|
-	    trsc.permanent(p3)
+	    trsc.add_permanent(p3)
 	    assert(trsc.permanent?(p3))
 	    assert(!plan.permanent?(t3))
 	end
 	assert(plan.permanent?(t3))
     end
+    
+    # Tests insertion and removal of free events
+    def test_commit_plan_events
+        e1, e2 = (1..2).map { Roby::EventGenerator.new }
+        plan.add_permanent(e1)
+        plan.add(e2)
+
+	transaction_commit(plan, e1, e2) do |trsc, p1, p2|
+	    assert(trsc.include?(p1))
+	    assert(trsc.permanent?(p1))
+	    assert(trsc.include?(p2))
+	    assert(!trsc.permanent?(p2))
+
+            trsc.unmark_permanent(p1)
+	    assert(!trsc.permanent?(p1))
+	end
+        assert(!plan.permanent?(e1))
+
+        e3, e4 = (1..2).map { Roby::EventGenerator.new }
+	transaction_commit(plan) do |trsc|
+            trsc.add_permanent(e3)
+            trsc.add(e4)
+	    assert(trsc.permanent?(e3))
+	    assert(trsc.include?(e4))
+	    assert(!trsc.permanent?(e4))
+	end
+        assert(plan.include?(e3))
+        assert(plan.permanent?(e3))
+        assert(plan.include?(e4))
+        assert(!plan.permanent?(e4))
+    end
+
 
     def test_commit_task_relations
 	(t1, t2), (t3, t4) = prepare_plan(:missions => 2, :tasks => 2)
-	t1.realized_by t2
+	t1.depends_on t2
 
 	transaction_commit(plan) do |trsc|
-	    trsc.discover t3
-	    trsc.discover t4
+	    trsc.add t3
+	    trsc.add 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
+	    t.depends_on p1
 	    assert(Hierarchy.linked?(t, p1))
 	    assert(!Hierarchy.linked?(t, t1))
 	end
@@ -209,7 +317,7 @@ module TC_TransactionBehaviour
 
 	t = Roby::Task.new
 	transaction_commit(plan, t1, t2) do |trsc, p1, p2|
-	    p2.realized_by t
+	    p2.depends_on t
 	    assert(Hierarchy.linked?(p2, t))
 	    assert(!Hierarchy.linked?(t2, t))
 	end
@@ -223,37 +331,37 @@ module TC_TransactionBehaviour
 	assert(!Hierarchy.linked?(t1, t2))
 
 	transaction_commit(plan, t3, t4) do |trsc, p3, p4|
-	    trsc.remove_task(p3)
+	    trsc.remove_object(p3)
 	    assert(!trsc.include?(p3))
 	    assert(!PlannedBy.linked?(p3, p4))
 	    assert(PlannedBy.linked?(t3, t4))
 	end
-	assert(!PlannedBy.linked?(t3, t4))
+	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)
+	t1.signals(:start, t2, :success)
 
 	transaction_commit(plan, t1, t2) do |trsc, p1, p2|
-	    trsc.discover t3
-	    t3.event(:stop).on p2.event(:start)
+	    trsc.add t3
+            t3.signals(:stop, p2, :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)
+            p1.signals(:stop, p2, :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)
+	    trsc.add t4
+	    p1.signals(:stop, t4, :start)
 	    assert(Signal.linked?(p1.event(:stop), t4.event(:start)))
 	end
 	assert(Signal.linked?(t1.event(:stop), t4.event(:start)))
@@ -268,12 +376,12 @@ module TC_TransactionBehaviour
     
     def test_commit_replace
 	task, (planned, mission, child, r) = prepare_plan :missions => 1, :tasks => 4, :model => SimpleTask
-	mission.realized_by task
+	mission.depends_on task, :model => SimpleTask
 	planned.planned_by task
-	task.realized_by child
-	task.on(:stop, mission, :stop)
-	task.forward(:stop, planned, :success)
-	task.on(:start, child, :start)
+	task.depends_on child
+	task.signals(:stop, mission, :stop)
+	task.forward_to(:stop, planned, :success)
+	task.signals(:start, child, :start)
 
 	transaction_commit(plan, mission, planned, task, child) do |trsc, pm, pp, pt, pc|
 	    trsc.replace(pt, r)
@@ -310,47 +418,26 @@ module TC_TransactionBehaviour
     def test_relation_validation
 	t1, t2 = prepare_plan :tasks => 2
 	transaction_commit(plan, t1) do |trsc, p1|
-	    trsc.insert(t2)
+	    trsc.add_mission(t2)
 	    assert_equal(plan, t1.plan)
 	    assert_equal(trsc, p1.plan)
 	    assert_equal(trsc, t2.plan)
-	    assert_raises(RuntimeError) { t1.realized_by t2 }
+	    assert_raises(RuntimeError) { t1.depends_on 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) }
+	    assert_raises(RuntimeError) { t1.signals(:start, t2, :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
+	t1, t2, t3 = prepare_plan :missions => 1, :add => 1
+	t1.depends_on t2
 
 	t3 = SimpleTask.new
 	assert_raises(Roby::InvalidTransaction) do
 	    transaction_commit(plan, t1, t2) do |trsc, p1, p2|
-		p1.realized_by(t3)
+		p1.depends_on(t3)
 		assert(trsc.wrap(t1, false))
 		plan.remove_object(t1)
 		assert(trsc.invalid?)
@@ -360,138 +447,79 @@ module TC_TransactionBehaviour
     end
 
     def test_plan_add_remove_invalidate
-	t1 = prepare_plan :discover => 1
+	t1 = prepare_plan :add => 1
 	assert_raises(Roby::InvalidTransaction) do
 	    transaction_commit(plan, t1) do |trsc, p1|
-		trsc.conflict_solver = :invalidate
 		plan.remove_object(t1)
+                assert(!plan.include?(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
+        # Test for a special case: the task is removed from the transaction and
+        # then removed from the plan. We should not invalidate in that case
+	t1 = prepare_plan :add => 1
+        transaction_commit(plan, t1) do |trsc, p1|
+            trsc.remove_object(p1)
+            plan.remove_object(t1)
+            assert(!trsc.invalid?)
+        end
     end
 
     def test_plan_relation_update_invalidate
-	t1, t2 = prepare_plan :discover => 2
+	t1, t2 = prepare_plan :add => 2
 
-	t1.realized_by t2
+	t1.depends_on 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.depends_on t2
+        transaction_commit(plan, t1, t2) do |trsc, p1, p2|
+            p1.remove_child p2
+            t1.remove_child t2
+            assert(!trsc.invalid?)
+        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)
+		t1.depends_on(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
+        transaction_commit(plan, t1, t2) do |trsc, p1, p2|
+            p1.depends_on p2
+            t1.depends_on t2
+            assert(!trsc.invalid?)
+        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_real_plan
+        transaction_commit(plan) do |trsc|
+            assert_equal(plan, trsc.real_plan)
+        end
+    end
+
     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)
+	    trsc.add_mission(t2)
+	    trsc.add_mission(t3)
 	    and_generator = (p1.event(:start) & t2.event(:start))
 	    assert_equal(trsc, and_generator.plan)
-	    and_generator.on t3.event(:start)
+	    and_generator.signals t3.event(:start)
 	end
 
 	t1.start!
@@ -503,18 +531,18 @@ class TC_Transactions < Test::Unit::TestCase
     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)
+	    trsc.add_mission(t2)
+	    trsc.add_mission(t3)
+	    (p1.event(:start) | t2.event(:start)).signals t3.event(:start)
 	end
 
 	t1.start!
 	assert(t3.running?)
-	assert_nothing_raised { t2.start! }
+	t2.start!
     end
 
     def test_commit_event_handlers
-	plan.discover(e = Roby::EventGenerator.new(true))
+	plan.add(e = Roby::EventGenerator.new(true))
 	def e.called_by_handler(mock)
 	    mock.called_by_handler
 	end
@@ -537,10 +565,10 @@ class TC_Transactions < Test::Unit::TestCase
 	ev = nil
 	transaction_commit(plan, t1) do |trsc, p1|
 	    ev = EventGenerator.new do
-		p1.forward(:start, t2, :start)
-		p1.on(:start, t3, :start)
+		p1.forward_to(:start, t2, :start)
+		p1.signals(:start, t3, :start)
 	    end
-	    trsc.discover(ev)
+	    trsc.add(ev)
 	    ev
 	end
 	ev.call
@@ -554,16 +582,29 @@ class TC_RecursiveTransaction < Test::Unit::TestCase
     include TC_TransactionBehaviour
     include Roby::Test
 
-    alias :real_plan :plan
-    attr_reader :plan
+    attr_reader :real_plan
+    def engine; (real_plan || plan).engine end
     def setup
-	@plan = Roby::Transaction.new(real_plan)
 	super
+        @real_plan = @plan
+	@plan = Roby::Transaction.new(real_plan)
     end
     def teardown
-	plan.discard_transaction
-	real_plan.clear
+        plan.discard_transaction
+        real_plan.clear
 	super
     end
+
+    def test_real_plan
+        transaction_commit(plan) do |trsc|
+            assert_equal(real_plan, trsc.real_plan)
+        end
+    end
+
+    def test_transaction_stack
+        transaction_commit(plan) do |trsc|
+            assert_equal([trsc, plan, real_plan], trsc.transaction_stack)
+        end
+    end
 end