roby 0.7.3 → 0.8.0

data/test/distributed/test_mixed_plan.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/distributed'
 require 'roby/test/tasks/simple_task'
 
@@ -17,18 +17,18 @@ require 'roby/test/tasks/simple_task'
 class TC_DistributedMixedPlan < Test::Unit::TestCase
     include Roby::Distributed::Test
 
-    # Creates in +plan+ a task which is a child in a realized_by relation and a parent
+    # Creates in +plan+ a task which is a child in a depends_on relation and a parent
     # in a planned_by relation. All tasks have an ID of "#{name}-#{number}", with
     # 2 for the central task, 1 for its parent task and 3 for its planning task.
     #
     # Returns [-1, -2, -3]
     def add_tasks(plan, name)
 	t1, t2, t3 = (1..3).map { |i| SimpleTask.new(:id => "#{name}-#{i}") }
-	t1.realized_by t2
+	t1.depends_on t2
 	t2.planned_by t3
-	plan.insert(t1)
-	plan.discover(t2)
-	plan.discover(t3)
+	plan.add_mission(t1)
+	plan.add(t2)
+	plan.add(t3)
 
 	[t1, t2, t3]
     end
@@ -59,8 +59,8 @@ class TC_DistributedMixedPlan < Test::Unit::TestCase
     #
     # Tests are in two parts: first we build the transaction and check the
     # relations of the resulting proxies. Then, we remove all relations of
-    # tasks *in the plan*.  Since we have added a realized_by between the
-    # central tasks, the realized_by relations are kept inside the transaction.
+    # tasks *in the plan*.  Since we have added a depends_on between the
+    # central tasks, the depends_on relations are kept inside the transaction.
     # However, this is not the case for planning relations.  Thus, the planning
     # relation does not exist anymore in the transaction after they have been
     # removed from the plan.
@@ -83,7 +83,7 @@ class TC_DistributedMixedPlan < Test::Unit::TestCase
 
     # Common setup of the remote peer
     def common_setup(propose_first)
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    testcase = self
 	    remote.singleton_class.class_eval do
 		define_method(:add_tasks) do |plan|
@@ -118,7 +118,7 @@ class TC_DistributedMixedPlan < Test::Unit::TestCase
 	end
 
 	# Create the transaction, and do the necessary modifications
-	trsc = Distributed::Transaction.new(plan, :conflict_solver => SolverIgnoreUpdate.new)
+	trsc = Distributed::Transaction.new(plan)
 
 	trsc.add_owner remote_peer
 	trsc.self_owned
@@ -147,11 +147,11 @@ class TC_DistributedMixedPlan < Test::Unit::TestCase
 	    r_t2 = subscribe_task(:id => 'remote-2')
 	    assert(1, r_t2.parents.to_a.size)
 	    r_t1 = r_t2.parents.find { true }
-	    t1, t2, t3 = Control.synchronize { add_tasks(plan, "local") }
+	    t1, t2, t3 = Roby.synchronize { add_tasks(plan, "local") }
 
 	    assert(plan.useful_task?(r_t1))
-	    trsc[r_t2].realized_by trsc[t2]
-	    trsc[r_t2].on(:start, trsc[t2])
+	    trsc[r_t2].depends_on trsc[t2]
+	    trsc[r_t2].signals(:start, trsc[t2], :start)
 	    assert(plan.useful_task?(r_t1))
 	    check_resulting_plan(trsc, false)
 	    if propose_first
@@ -161,7 +161,7 @@ class TC_DistributedMixedPlan < Test::Unit::TestCase
 	    end
 
 	    # Remove the relations in the real tasks (not the proxies)
-	    Control.synchronize do
+	    Roby.synchronize do
 		t2.remove_planning_task(t3)
 	    end
 	    remote.remove_relations(Distributed.format(r_t2))
@@ -185,10 +185,10 @@ class TC_DistributedMixedPlan < Test::Unit::TestCase
 	common_setup(propose_first) do |trsc|
 	    remote.add_tasks(Distributed.format(plan))
 	    r_t2 = subscribe_task(:id => 'remote-2')
-	    t1, t2, t3 = Control.synchronize { add_tasks(trsc, "local") }
+	    t1, t2, t3 = Roby.synchronize { add_tasks(trsc, "local") }
 
-	    trsc[r_t2].realized_by t2
-	    trsc[r_t2].on(:start, t2)
+	    trsc[r_t2].depends_on t2
+	    trsc[r_t2].signals(:start, t2, :start)
 	    check_resulting_plan(trsc, false)
 	    process_events
 	    if propose_first
@@ -220,9 +220,9 @@ class TC_DistributedMixedPlan < Test::Unit::TestCase
 	    trsc.edit
 
 	    assert(r_t2.subscribed?)
-	    t1, t2, t3 = Control.synchronize { add_tasks(plan, "local") }
-	    r_t2.realized_by trsc[t2]
-	    r_t2.on(:start, trsc[t2])
+	    t1, t2, t3 = Roby.synchronize { add_tasks(plan, "local") }
+	    r_t2.depends_on trsc[t2]
+	    r_t2.signals(:start, trsc[t2], :start)
 	    remote_peer.subscribe(r_t2)
 	    remote_peer.push_subscription(t2)
 
@@ -239,15 +239,15 @@ class TC_DistributedMixedPlan < Test::Unit::TestCase
     end
 
     def test_garbage_collect
-	peer2peer(true) do |remote|
-	    remote.plan.insert(SimpleTask.new(:id => 'remote-1'))
+	peer2peer do |remote|
+	    remote.plan.add_mission(SimpleTask.new(:id => 'remote-1'))
 	    def remote.insert_children(trsc, root_task)
 		trsc = local_peer.local_object(trsc)
 		root_task = local_peer.local_object(root_task)
 		trsc.edit
 
-		root_task.realized_by(r2 = SimpleTask.new(:id => 'remote-2'))
-		r2.realized_by(r3 = SimpleTask.new(:id => 'remote-3'))
+		root_task.depends_on(r2 = SimpleTask.new(:id => 'remote-2'))
+		r2.depends_on(r3 = SimpleTask.new(:id => 'remote-3'))
 		trsc.release(false)
 	    end
 	end
@@ -261,8 +261,8 @@ class TC_DistributedMixedPlan < Test::Unit::TestCase
 	# we are not subscribed to r1 anymore
 	trsc = Distributed::Transaction.new(plan)
 	trsc.add_owner(remote_peer)
-	trsc[r1].realized_by t1
-	Roby::Control.synchronize do
+	trsc[r1].depends_on t1
+	Roby.synchronize do
 	    remote_peer.unsubscribe(r1)
 	    assert(!plan.unneeded_tasks.include?(r1))
 	end
@@ -275,10 +275,10 @@ class TC_DistributedMixedPlan < Test::Unit::TestCase
 	# Ok, we now create a r1 => t1 => t2 => t3 chain
 	#   * t2 and t3 are kept because they are useful for r1
 	t2, t3 = nil
-	Roby::Control.synchronize do
-	    t1.realized_by(t2 = SimpleTask.new)
+	Roby.synchronize do
+	    t1.depends_on(t2 = SimpleTask.new)
 	    assert(!plan.unneeded_tasks.include?(t2))
-	    t2.realized_by(t3 = SimpleTask.new)
+	    t2.depends_on(t3 = SimpleTask.new)
 	    assert(!plan.unneeded_tasks.include?(t3))
 	end
 
@@ -295,13 +295,13 @@ class TC_DistributedMixedPlan < Test::Unit::TestCase
 	process_events
 
 	r2 = remote_task(:id => 'remote-2')
-	Roby::Control.synchronize do
+	Roby.synchronize do
 	    assert(r2.plan && !plan.unneeded_tasks.include?(r2))
 	    assert(t3.child_object?(r2, TaskStructure::Hierarchy))
 	end
 
 	r3 = remote_task(:id => 'remote-3')
-	Roby::Control.synchronize do
+	Roby.synchronize do
 	    assert(!r3.plan || plan.unneeded_tasks.include?(r3))
 	end
     end
@@ -311,17 +311,17 @@ class TC_DistributedMixedPlan < Test::Unit::TestCase
     # after the commit, there is a race condition possibility if the other
     # peers do not have committed the transaction yet
     def test_commit_race_condition
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    def remote.add_task(trsc)
 		trsc = local_peer.local_object(trsc)
 		trsc.edit
-		trsc.discover(SimpleTask.new(:id => 'remote'))
+		trsc.add(SimpleTask.new(:id => 'remote'))
 		trsc.release(false)
 	    end
 	end
 	
 	# Create an empty transaction and send it to our peer
-	# The peer will then discover a task, which 
+	# The peer will then add a task, which 
 	# will be GCed as soon as the transaction is committed
 	trsc = Distributed::Transaction.new(plan)
 	trsc.add_owner(remote_peer)

data/test/distributed/test_plan_notifications.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/distributed'
 require 'roby/test/tasks/simple_task'
 require 'flexmock'
@@ -7,12 +7,12 @@ class TC_DistributedPlanNotifications < Test::Unit::TestCase
     include Roby::Distributed::Test
 
     def test_triggers
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    def remote.new_task(kind, args)
-		Roby.execute do
+		engine.execute do
 		    new_task = kind.proxy(local_peer).new(args)
 		    yield(new_task.remote_id) if block_given?
-		    plan.insert(new_task)
+		    plan.add_mission(new_task)
 		end
 		nil
 	    end
@@ -52,9 +52,9 @@ class TC_DistributedPlanNotifications < Test::Unit::TestCase
     end
 
     def test_trigger_subscribe
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    def remote.new_task
-		plan.insert(SimpleTask.new(:id => 1))
+		plan.add_mission(SimpleTask.new(:id => 1))
 		nil
 	    end
 	end
@@ -78,12 +78,12 @@ class TC_DistributedPlanNotifications < Test::Unit::TestCase
     end
 
     def test_subscribe_plan
-	peer2peer(true) do |remote|
-	    plan.insert(mission = Task.new(:id => 'mission'))
-	    subtask = Task.new :id => 'subtask'
-	    plan.insert(next_mission = Task.new(:id => 'next_mission'))
-	    mission.realized_by subtask
-	    mission.on(:start, next_mission, :start)
+	peer2peer do |remote|
+	    plan.add_mission(mission = SimpleTask.new(:id => 'mission'))
+	    subtask = SimpleTask.new :id => 'subtask'
+	    plan.add_mission(next_mission = SimpleTask.new(:id => 'next_mission'))
+	    mission.depends_on subtask
+	    mission.signals(:start, next_mission, :start)
 	end
 
 	# Subscribe to the remote plan
@@ -103,27 +103,27 @@ class TC_DistributedPlanNotifications < Test::Unit::TestCase
     end
 
     def test_plan_updates
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    class << remote
 		attr_reader :mission, :subtask, :next_mission, :free_event
 		def create_mission
 		    @mission = Roby::Task.new :id => 'mission'
-		    plan.insert(mission)
+		    plan.add_mission(mission)
 		end
 		def create_subtask
-		    plan.permanent(@subtask = Roby::Task.new(:id => 'subtask'))
-		    mission.realized_by subtask
+		    plan.add_permanent(@subtask = Roby::Task.new(:id => 'subtask'))
+		    mission.depends_on subtask
 		end
 		def create_next_mission
 		    @next_mission = Roby::Task.new :id => 'next_mission'
-		    mission.on(:start, next_mission, :start)
-		    plan.insert(next_mission)
+		    mission.signals(:start, next_mission, :start)
+		    plan.add_mission(next_mission)
 		end
 		def create_free_event
 		    @free_event = Roby::EventGenerator.new(true)
 		    # Link the event to a task to protect it from GC
-		    @next_mission.on(:start, @free_event)
-		    plan.discover(free_event)
+		    @next_mission.signals(:start, @free_event, :start)
+		    plan.add(free_event)
 		end
 		def remove_free_event
 		    plan.remove_object(free_event)
@@ -133,8 +133,8 @@ class TC_DistributedPlanNotifications < Test::Unit::TestCase
 		def unlink_subtask; mission.remove_child(subtask) end
 		def remove_subtask; plan.remove_object(subtask) end
 		def discard_mission 
-		    plan.permanent(mission)
-		    plan.discard(mission) 
+		    plan.add_permanent(mission)
+		    plan.unmark_mission(mission) 
 		end
 		def remove_mission; plan.remove_object(mission) end
 	    end
@@ -206,12 +206,12 @@ class TC_DistributedPlanNotifications < Test::Unit::TestCase
     end
 
     def test_unsubscribe_plan
-	peer2peer(true) do |remote|
-	    remote.plan.insert(Task.new(:id => 'remote-1'))
-	    remote.plan.insert(Task.new(:id => 'remote-2'))
+	peer2peer do |remote|
+	    remote.plan.add_mission(SimpleTask.new(:id => 'remote-1'))
+	    remote.plan.add_mission(SimpleTask.new(:id => 'remote-2'))
 
 	    def remote.new_task
-		plan.insert(Task.new(:id => 'remote-3'))
+		plan.add_mission(SimpleTask.new(:id => 'remote-3'))
 	    end
 	end
 

data/test/distributed/test_protocol.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/distributed'
 require 'roby/test/tasks/simple_task'
 require 'flexmock'
@@ -30,13 +30,13 @@ class TC_DistributedRobyProtocol < Test::Unit::TestCase
 
     TEST_ARRAY_SIZE = 7
     def dumpable_array
-	task = Roby::Task.new(:id => 1)
+	task = SimpleTask.new(:id => 1)
 	[1, task, 
 	    Roby::EventGenerator.new {}, 
 	    SimpleTask.new(:id => 2), 
 	    task.event(:start), 
 	    Roby::TaskStructure::Hierarchy, 
-	    Class.new(Task).new(:id => 3) ]
+	    Class.new(SimpleTask).new(:id => 3) ]
     end
     def dumpable_hash
 	Hash[*(0...TEST_ARRAY_SIZE).zip(dumpable_array).flatten]
@@ -47,7 +47,7 @@ class TC_DistributedRobyProtocol < Test::Unit::TestCase
 
 	assert_kind_of(Task::DRoby, array[1])
 	assert_equal({:id => 1}, array[1].arguments)
-	assert_equal(Task, array[1].model.proxy(remote_peer))
+	assert_equal(SimpleTask, array[1].model.proxy(remote_peer))
 
 	assert_kind_of(EventGenerator::DRoby, array[2])
 	assert(array[2].controlable)
@@ -117,7 +117,7 @@ class TC_DistributedRobyProtocol < Test::Unit::TestCase
 
     def test_enumerables
 	test_case = self
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    PeerServer.class_eval do
 		define_method(:array)     { test_case.dumpable_array }
 		define_method(:value_set) { test_case.dumpable_array.to_value_set }
@@ -148,7 +148,7 @@ class TC_DistributedRobyProtocol < Test::Unit::TestCase
     end
 
     def test_marshal_peer
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    def remote.remote_peer_id; Distributed.state.remote_id end
 	end
 
@@ -159,7 +159,7 @@ class TC_DistributedRobyProtocol < Test::Unit::TestCase
     end
 
     def test_marshal_model
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    PeerServer.class_eval do
 		def model; SimpleTask end
 		def anonymous_model; @anonymous ||= Class.new(model) end
@@ -178,10 +178,10 @@ class TC_DistributedRobyProtocol < Test::Unit::TestCase
     end
 
     def test_marshal_task
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    PeerServer.class_eval do
 		def task
-		    plan.insert(@task = Class.new(SimpleTask).new(:id => 1))
+		    plan.add_mission(@task = Class.new(SimpleTask).new(:id => 1))
 		    @task.data = [42, @task.class]
 		    [@task, @task.remote_id]
 		end
@@ -201,7 +201,7 @@ class TC_DistributedRobyProtocol < Test::Unit::TestCase
 	assert_equal(remote_task_id, remote_task.remote_siblings[remote_peer.droby_dump(nil)], remote_task.remote_siblings)
 	assert(!remote_task.remote_siblings[Roby::Distributed.droby_dump(nil)])
 
-	plan.permanent(local_proxy = remote_peer.local_object(remote_task))
+	plan.add_permanent(local_proxy = remote_peer.local_object(remote_task))
 	assert_kind_of(SimpleTask,  local_proxy)
 	assert_not_same(SimpleTask, local_proxy.class)
 	assert_equal([42, local_proxy.class], local_proxy.data)
@@ -214,7 +214,9 @@ class TC_DistributedRobyProtocol < Test::Unit::TestCase
 	remote_peer.synchro_point
 	assert(remote_peer.call(:check_sibling, local_proxy.remote_id))
 	assert(local_proxy.executable?)
-	assert_raises(OwnershipError) { local_proxy.start! }
+        Roby.execute do
+            assert_raises(OwnershipError) { local_proxy.start! }
+        end
     end
 
     class ErrorWithArguments < Exception
@@ -230,7 +232,7 @@ class TC_DistributedRobyProtocol < Test::Unit::TestCase
 	assert_kind_of(Exception::DRoby, formatted)
 	assert_nothing_raised { Marshal.dump(formatted) }
 
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    def remote.exception
 		model = Class.new(Exception)
 		e = model.exception("test")
@@ -264,17 +266,17 @@ class TC_DistributedRobyProtocol < Test::Unit::TestCase
     # See #test_local_task_back_forth_through_drb_race_condition
     # This test checks the case where we received the added_sibling message
     def test_local_task_back_forth_through_drb
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    PeerServer.class_eval do
 		def proxy(object)
 		    Marshal.dump(object)
-		    plan.permanent(task = peer.local_object(object))
+		    plan.add_permanent(task = peer.local_object(object))
 		    task
 		end
 	    end
 	end
 
-	plan.permanent(local_task = SimpleTask.new(:id => 'local'))
+	plan.add_permanent(local_task = SimpleTask.new(:id => 'local'))
 	remote_proxy = remote_peer.call(:proxy, local_task)
 	remote_peer.synchro_point
 	assert(remote_peer.proxies[remote_proxy], [remote_peer.proxies, remote_proxy])
@@ -291,17 +293,17 @@ class TC_DistributedRobyProtocol < Test::Unit::TestCase
     # #local_object while the local host does not know yet that the remote host
     # has a sibling for the object
     def test_local_task_back_forth_through_drb_race_condition
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    def remote.proxy(object)
 		Marshal.dump(object)
-		plan.permanent(task = local_peer.local_object(object))
+		plan.add_permanent(task = local_peer.local_object(object))
 		task
 	    end
 	end
 
 	begin
 	    remote.disable_communication
-	    plan.permanent(local_task = SimpleTask.new(:id => 'local'))
+	    plan.add_permanent(local_task = SimpleTask.new(:id => 'local'))
 	    remote_proxy = remote.proxy(Distributed.format(local_task))
 	    assert_equal(remote_proxy, remote.proxy(Distributed.format(local_task)))
 	    assert(!remote_peer.proxies[remote_proxy])
@@ -314,13 +316,17 @@ class TC_DistributedRobyProtocol < Test::Unit::TestCase
 	assert_nothing_raised { remote_peer.synchro_point }
     end
 
+    class FinalizedRemoteTaskRaceTask < SimpleTask
+        argument :newarg
+    end
+
     # test a particular situations of GC/communication interaction
     # - A finalizes a task T which is owned by B
     # - A receives a message involving T which has been emitted while B was not knowing about the
     #   deletion (it has not yet received the removed_sibling message)
     def test_finalized_remote_task_race_condition
-	peer2peer(true) do |remote|
-	    remote.plan.insert(task = SimpleTask.new(:id => 'remote'))
+	peer2peer do |remote|
+	    remote.plan.add_mission(task = FinalizedRemoteTaskRaceTask.new(:id => 'remote'))
 	    
 	    remote.singleton_class.class_eval do
 		define_method(:send_task_update) do
@@ -335,7 +341,7 @@ class TC_DistributedRobyProtocol < Test::Unit::TestCase
 	    task
 	end
 
-	Roby.control.wait_one_cycle
+	engine.wait_one_cycle
 	assert(!task.plan)
 
 	new_task = remote_peer.local_object(remote.send_task_update)
@@ -347,14 +353,16 @@ class TC_DistributedRobyProtocol < Test::Unit::TestCase
     end
 
     def test_marshal_task_arguments
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    PeerServer.class_eval do
 		def task
-		    plan.insert(@task = model.new(:id => 1, :model => model))
+		    plan.add_mission(@task = model.new(:id => 1, :model => model))
 		    @task
 		end
 		def model
-		    @model ||= Class.new(SimpleTask)
+		    @model ||= Class.new(SimpleTask) do
+                        argument :model
+                    end
 		end
 	    end
 	end
@@ -370,7 +378,7 @@ class TC_DistributedRobyProtocol < Test::Unit::TestCase
     end
 
     def test_marshal_task_event
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    PeerServer.class_eval do
 		attr_reader :task
 		def task_event
@@ -390,7 +398,7 @@ class TC_DistributedRobyProtocol < Test::Unit::TestCase
 
     CommonTaskModelTag = TaskModelTag.new
     def test_marshal_task_model_tag
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    PeerServer.class_eval do
 		def tag; CommonTaskModelTag end
 		def anonymous_tag
@@ -428,37 +436,38 @@ class TC_DistributedRobyProtocol < Test::Unit::TestCase
     end
 
     def test_marshal_event
-	peer2peer(true) do |remote|
-	    remote.plan.insert(t = Task.new)
-	    t.on(:start, (ev = EventGenerator.new(true)))
-	    t.event(:start).forward(ev = EventGenerator.new(false))
-	    t.on(:start, (ev = EventGenerator.new { }))
+	peer2peer do |remote|
+	    remote.plan.add_mission(t = Task.new)
+	    t.signals(:start, (ev = EventGenerator.new(true)))
+	    t.event(:start).forward_to(ev = EventGenerator.new(false))
+	    t.signals(:start, (ev = EventGenerator.new { }))
 	    PeerServer.class_eval do
 		include Test::Unit::Assertions
 		define_method(:events) { plan.free_events }
 	    end
 	end
 	
-	marshalled = remote_peer.call(:events)
-	marshalled.each { |ev| assert_kind_of(EventGenerator::DRoby, ev) }
-
-	all_events = marshalled.map { |ev| remote_peer.local_object(ev) }
-	assert_equal(1, all_events.find_all { |ev| !ev.controlable? }.size)
-	assert_equal(2, all_events.find_all { |ev| ev.controlable? }.size)
-	all_events.each do |ev|
-	    if ev.controlable?
-		assert_raises(OwnershipError) { ev.call }
-	    end
-	    assert_raises(OwnershipError) { ev.emit }
-	end
+        marshalled = remote_peer.call(:events)
+        marshalled.each { |ev| assert_kind_of(EventGenerator::DRoby, ev) }
+        Roby.execute do
+            all_events = marshalled.map { |ev| remote_peer.local_object(ev) }
+            assert_equal(1, all_events.find_all { |ev| !ev.controlable? }.size)
+            assert_equal(2, all_events.find_all { |ev| ev.controlable? }.size)
+            all_events.each do |ev|
+                if ev.controlable?
+                    assert_raises(OwnershipError) { ev.call }
+                end
+                assert_raises(OwnershipError) { ev.emit }
+            end
+        end
     end
 
     def test_siblings
-	peer2peer(true) do |remote|
-	    plan.insert(Roby::Task.new(:id => 'remote'))
+	peer2peer do |remote|
+	    plan.add_mission(Roby::Task.new(:id => 'remote'))
 	end
 
-	plan.insert(remote_task = remote_task(:id => 'remote'))
+	plan.add_mission(remote_task = remote_task(:id => 'remote'))
 	assert(remote_task.has_sibling_on?(remote_peer))
 	remote_object, _ = remote_peer.proxies.find { |_, task| task == remote_task }
 	assert(remote_object)
@@ -497,7 +506,7 @@ class TC_DistributedRobyProtocol < Test::Unit::TestCase
 
     def test_dump_sequence
 	DRb.start_service
-	t1, t2 = prepare_plan :discover => 2
+	t1, t2 = prepare_plan :add => 2
 	p = t1+t2
 
 	formatted = Distributed.format(p)
@@ -506,7 +515,7 @@ class TC_DistributedRobyProtocol < Test::Unit::TestCase
 
     def test_dump_parallel
 	DRb.start_service
-	t1, t2 = prepare_plan :discover => 2
+	t1, t2 = prepare_plan :add => 2
 	p = t1|t2
 
 	formatted = Distributed.format(p)