roby 0.7.3 → 0.8.0

data/test/distributed/test_query.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'
@@ -16,7 +16,7 @@ class TC_DistributedQuery < Test::Unit::TestCase
 	    t1 = Class.new(Task).new
 	    t2 = Class.new(Task).new
 	    t2.owners << fake_peer
-	    plan.discover [t1, t2]
+	    plan.add [t1, t2]
 
 	    assert_equal([t1].to_set, TaskMatcher.owned_by(Distributed).enum_for(:each, plan).to_set)
 	    assert_equal([t1].to_set, TaskMatcher.self_owned.enum_for(:each, plan).to_set)
@@ -26,7 +26,7 @@ class TC_DistributedQuery < Test::Unit::TestCase
     end
 
     def test_marshal_query
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    PeerServer.class_eval do
 		def query
 		    plan.find_tasks
@@ -40,14 +40,18 @@ class TC_DistributedQuery < Test::Unit::TestCase
 	assert_kind_of(Query, query)
     end
 
+    class QueryTaskModel < Roby::Task
+        argument :id
+    end
+
     # Check that we can query the remote plan database
     def test_query
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    local_model = Class.new(SimpleTask)
 
-	    mission, subtask = Task.new(:id => 1), local_model.new(:id => 2)
-	    mission.realized_by subtask
-	    remote.plan.insert(mission)
+	    mission, subtask = QueryTaskModel.new(:id => 1), local_model.new(:id => 2)
+	    mission.depends_on subtask
+	    remote.plan.add_mission(mission)
 	end
 
 	# Get the remote missions

data/test/distributed/test_remote_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'
 
@@ -66,10 +66,10 @@ class TC_DistributedRemotePlan < Test::Unit::TestCase
     end
 
     def test_remote_proxy_update
-	peer2peer(true) do |remote|
-	    remote.plan.insert(SimpleTask.new(:id => 'simple_task'))
-	    remote.plan.permanent(SimpleTask.new(:id => 'task'))
-	    remote.plan.permanent(SimpleTask.new(:id => 'other_task'))
+	peer2peer do |remote|
+	    remote.plan.add_mission(SimpleTask.new(:id => 'simple_task'))
+	    remote.plan.add_permanent(SimpleTask.new(:id => 'task'))
+	    remote.plan.add_permanent(SimpleTask.new(:id => 'other_task'))
 	end
 
 	r_simple_task = remote_task(:id => 'simple_task', :permanent => true)
@@ -81,28 +81,28 @@ class TC_DistributedRemotePlan < Test::Unit::TestCase
 	Distributed.update(r_simple_task) do
 	    assert(r_simple_task.read_write?)
 	    assert_nothing_raised do
-		r_simple_task.realized_by task
+		r_simple_task.depends_on task
 		r_simple_task.remove_child task
-		task.realized_by r_simple_task
+		task.depends_on r_simple_task
 		task.remove_child r_simple_task
 	    end
 	end
 	assert(!r_simple_task.read_write?)
 
-	assert_raises(OwnershipError) { r_simple_task.realized_by task }
-	assert_raises(OwnershipError) { task.realized_by r_simple_task }
-	Distributed.update(r_simple_task) { r_simple_task.realized_by task }
+	assert_raises(OwnershipError) { r_simple_task.depends_on task }
+	assert_raises(OwnershipError) { task.depends_on r_simple_task }
+	Distributed.update(r_simple_task) { r_simple_task.depends_on task }
 	assert_nothing_raised { r_simple_task.remove_child task }
-	Distributed.update(r_simple_task) { task.realized_by r_simple_task }
+	Distributed.update(r_simple_task) { task.depends_on r_simple_task }
 	assert_nothing_raised { task.remove_child r_simple_task }
 
-	assert_raises(OwnershipError) { r_simple_task.realized_by r_other_task }
-	assert_raises(OwnershipError) { r_other_task.realized_by r_simple_task }
-	Distributed.update_all([r_simple_task, r_other_task]) { r_simple_task.realized_by r_other_task }
+	assert_raises(OwnershipError) { r_simple_task.depends_on r_other_task }
+	assert_raises(OwnershipError) { r_other_task.depends_on r_simple_task }
+	Distributed.update_all([r_simple_task, r_other_task]) { r_simple_task.depends_on r_other_task }
 	assert_raises(OwnershipError) { r_simple_task.remove_child r_other_task }
 	Distributed.update_all([r_simple_task, r_other_task]) do
 	    r_simple_task.remove_child r_other_task
-	    r_other_task.realized_by r_simple_task
+	    r_other_task.depends_on r_simple_task
 	end
 	assert_raises(OwnershipError) { r_other_task.remove_child r_simple_task }
 
@@ -117,16 +117,16 @@ class TC_DistributedRemotePlan < Test::Unit::TestCase
     # Test that the remote plan structure is properly mapped to the local
     # plan database
     def test_discover_neighborhood
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    mission, subtask, next_mission =
 		SimpleTask.new(:id => 'mission'), 
 		SimpleTask.new(:id => 'subtask'),
 		SimpleTask.new(:id => 'next_mission')
-	    mission.realized_by subtask
-	    mission.on(:stop, next_mission, :start)
+	    mission.depends_on subtask
+	    mission.signals(:stop, next_mission, :start)
 
-	    remote.plan.insert(mission)
-	    remote.plan.insert(next_mission)
+	    remote.plan.add_mission(mission)
+	    remote.plan.add_mission(next_mission)
 	end
 
 	r_mission	= remote_task(:id => 'mission', :permanent => true)
@@ -137,7 +137,7 @@ class TC_DistributedRemotePlan < Test::Unit::TestCase
 	assert_equal([], r_mission.children.to_a)
 	assert_equal([], r_mission.event(:stop).child_objects(EventStructure::Signal).to_a)
 
-	# Discover remote relations
+	# add remote relations
 	remote_peer.discover_neighborhood(r_mission, 1) do |r_mission|
 	    proxies = r_mission.children.to_a
 	    assert_equal(1, proxies.to_a.size)
@@ -146,16 +146,16 @@ class TC_DistributedRemotePlan < Test::Unit::TestCase
 	    assert_equal(r_next_mission.event(:start), proxies.first)
 	end
 
-	plan.auto(r_mission)
-	plan.auto(r_subtask)
-	plan.auto(r_next_mission)
-	Roby.control.wait_one_cycle
-	assert_equal([remote_peer.task], plan.keepalive.to_a)
+	plan.unmark_permanent(r_mission)
+	plan.unmark_permanent(r_subtask)
+	plan.unmark_permanent(r_next_mission)
+	engine.wait_one_cycle
+	assert_equal([remote_peer.task], plan.permanent_tasks.to_a)
     end
 
     def test_subscribing_old_objects
-	peer2peer(true) do |remote|
-	    plan.insert(@task = SimpleTask.new(:id => 1))
+	peer2peer do |remote|
+	    plan.add_mission(@task = SimpleTask.new(:id => 1))
 	end
 
 	r_task, r_task_id = nil
@@ -170,20 +170,20 @@ class TC_DistributedRemotePlan < Test::Unit::TestCase
     end
 
     def test_subscription
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    root, mission, subtask, next_mission =
 		SimpleTask.new(:id => 'root'), 
 		SimpleTask.new(:id => 'mission'), 
 		SimpleTask.new(:id => 'subtask'),
 		SimpleTask.new(:id => 'next_mission')
-	    root.realized_by mission
-	    mission.realized_by subtask
-	    mission.on(:stop, next_mission, :start)
+	    root.depends_on mission
+	    mission.depends_on subtask
+	    mission.signals(:stop, next_mission, :start)
 
-	    remote.plan.permanent(subtask)
-	    remote.plan.insert(root)
-	    remote.plan.insert(mission)
-	    remote.plan.insert(next_mission)
+	    remote.plan.add_permanent(subtask)
+	    remote.plan.add_mission(root)
+	    remote.plan.add_mission(mission)
+	    remote.plan.add_mission(next_mission)
 
 	    remote.singleton_class.class_eval do
 		include Test::Unit::Assertions
@@ -204,7 +204,7 @@ class TC_DistributedRemotePlan < Test::Unit::TestCase
 		    mission.remove_child subtask
 		end
 		define_method(:add_mission_subtask) do
-		    mission.realized_by subtask
+		    mission.depends_on subtask
 		end
 	    end
 	end
@@ -233,11 +233,11 @@ class TC_DistributedRemotePlan < Test::Unit::TestCase
 	assert(plan.useful_task?(r_mission))
 	r_next_mission = remote_task(:id => 'next_mission')
 	r_subtask = remote_task(:id => 'subtask')
-	Roby::Control.synchronize do
+	Roby.synchronize do
 	    assert(!r_next_mission.plan || !plan.useful_task?(r_next_mission))
 	    assert(!r_subtask.plan || !plan.useful_task?(r_subtask))
 	end
-	Roby.control.wait_one_cycle
+	engine.wait_one_cycle
 	
 	# Check that the task index has been updated
 	assert(!plan.task_index.by_owner[remote_peer].include?(r_subtask))
@@ -248,7 +248,7 @@ class TC_DistributedRemotePlan < Test::Unit::TestCase
 	r_subtask = remote_task(:id => 'subtask')
 	assert(!plan.unneeded_tasks.include?(r_subtask))
 	r_next_mission = remote_task(:id => 'next_mission')
-	Roby::Control.synchronize do
+	Roby.synchronize do
 	    assert(!r_next_mission.plan || plan.unneeded_tasks.include?(r_next_mission))
 	end
 
@@ -256,13 +256,13 @@ class TC_DistributedRemotePlan < Test::Unit::TestCase
 
 	## Check plan GC after we have unsubscribed from mission
 	remote_peer.unsubscribe(r_mission)
-	Roby::Control.synchronize do
+	Roby.synchronize do
 	    assert(r_mission.plan)
 	    assert(!plan.unneeded_tasks.include?(r_mission))
 	    assert(!remote_peer.subscribed?(r_mission))
 	    assert(plan.unneeded_tasks.include?(r_subtask))
 	end
-	Roby.control.wait_one_cycle
+	engine.wait_one_cycle
 
 	# Check that subtask and next_mission are removed from the plan
 	assert(!r_subtask.plan)
@@ -301,23 +301,23 @@ class TC_DistributedRemotePlan < Test::Unit::TestCase
 	r_mission = remote_peer.subscribe(r_mission)
 	r_subtask = remote_task(:id => 'subtask')
 	r_next_mission = remote_task(:id => 'next_mission')
-	Roby.control.wait_one_cycle
+	engine.wait_one_cycle
 
 	proxies = r_mission.children.to_a
 	assert(! proxies.empty?)
     end
 
     def test_remove_not_needed
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    left, right, middle =
 		SimpleTask.new(:id => 'left'), 
 		SimpleTask.new(:id => 'right'), 
 		SimpleTask.new(:id => 'middle')
-	    remote.plan.insert(left)
-	    remote.plan.insert(right)
+	    remote.plan.add_mission(left)
+	    remote.plan.add_mission(right)
 
-	    left.realized_by middle
-	    right.realized_by middle
+	    left.depends_on middle
+	    right.depends_on middle
 
 	    remote.singleton_class.class_eval do
 		include Test::Unit::Assertions
@@ -338,7 +338,7 @@ class TC_DistributedRemotePlan < Test::Unit::TestCase
 	assert(!plan.unneeded_tasks.include?(right))
 	assert(!plan.unneeded_tasks.include?(middle))
 
-	Roby::Control.synchronize do
+	Roby.synchronize do
 	    remote_peer.unsubscribe(right)
 	    assert(!right.remotely_useful?)
 	    assert(!right.subscribed?)
@@ -357,10 +357,10 @@ class TC_DistributedRemotePlan < Test::Unit::TestCase
     end
 
     def test_data_update
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    task = SimpleTask.new(:id => 'task')
 	    task.data = [4, 2]
-	    remote.plan.insert(task)
+	    remote.plan.add_mission(task)
 
 	    remote.singleton_class.class_eval do 
 		define_method(:change_data) { task.data = 42 }
@@ -375,20 +375,20 @@ class TC_DistributedRemotePlan < Test::Unit::TestCase
     end
 
     def test_mission_notifications
-	peer2peer(true) do |remote|
-	    plan.insert(mission = SimpleTask.new(:id => 'mission'))
+	peer2peer do |remote|
+	    plan.add_mission(mission = SimpleTask.new(:id => 'mission'))
 
 	    remote.class.class_eval do
 		define_method(:discard_mission) do
-		    Roby::Control.synchronize do
-			remote.plan.discard(mission)
-			remote.plan.permanent(mission)
+		    Roby.synchronize do
+			remote.plan.unmark_mission(mission)
+			remote.plan.add_permanent(mission)
 		    end
 		end
 		define_method(:insert_mission) do
-		    Roby::Control.synchronize do
-			remote.plan.auto(mission)
-			remote.plan.insert(mission)
+		    Roby.synchronize do
+			remote.plan.unmark_permanent(mission)
+			remote.plan.add_mission(mission)
 		    end
 		end
 	    end
@@ -409,25 +409,25 @@ class TC_DistributedRemotePlan < Test::Unit::TestCase
     end
 
     def test_relation_updates
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    mission, subtask, next_mission =
 		SimpleTask.new(:id => 'mission'), 
 		SimpleTask.new(:id => 'subtask'),
 		SimpleTask.new(:id => 'next_mission')
 
-	    remote.plan.insert(mission)
-	    remote.plan.insert(next_mission)
-	    remote.plan.permanent(subtask)
+	    remote.plan.add_mission(mission)
+	    remote.plan.add_mission(next_mission)
+	    remote.plan.add_permanent(subtask)
 
 	    remote.singleton_class.class_eval do
 		define_method(:add_mission_subtask) do
-		    mission.realized_by subtask
+		    mission.depends_on subtask
 		end
 		define_method(:remove_mission_subtask) do
 		    mission.remove_child subtask
 		end
 		define_method(:add_mission_stop_next_start) do
-		    mission.on(:stop, next_mission, :start)
+		    mission.signals(:stop, next_mission, :start)
 		end
 		define_method(:remove_mission_stop_next_start) do
 		    mission.event(:stop).remove_signal(next_mission.event(:start))
@@ -458,16 +458,16 @@ class TC_DistributedRemotePlan < Test::Unit::TestCase
 
     # Check that remote events that are unknown locally are properly ignored
     def test_ignored_events
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    model = Class.new(SimpleTask) do
 		event :unknown, :command => true
 	    end
-	    remote.plan.insert(t1 = SimpleTask.new(:id => 1))
-	    remote.plan.insert(t2 = SimpleTask.new(:id => 2))
-	    remote.plan.insert(u = model.new(:id => 0))
+	    remote.plan.add_mission(t1 = SimpleTask.new(:id => 1))
+	    remote.plan.add_mission(t2 = SimpleTask.new(:id => 2))
+	    remote.plan.add_mission(u = model.new(:id => 0))
 
-	    t1.event(:start).on u.event(:unknown)
-	    t2.event(:start).emit_on u.event(:unknown)
+	    t1.signals(:start, u, :unknown)
+            u.forward_to(:unknown, t2, :start)
 
 	    remote.singleton_class.class_eval do
 		define_method(:remove_relations) do

data/test/distributed/test_transaction.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'
 
@@ -6,7 +6,7 @@ class TC_DistributedTransaction < Test::Unit::TestCase
     include Roby::Distributed::Test
 
     def test_marshal_transactions
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    PeerServer.class_eval do
 		attr_reader :plan
 		def transaction
@@ -30,7 +30,7 @@ class TC_DistributedTransaction < Test::Unit::TestCase
     end
 
     def test_transaction_create
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    PeerServer.class_eval do
 		include Test::Unit::Assertions
 		def check_transaction(marshalled_trsc, trsc_drbobject)
@@ -39,7 +39,6 @@ class TC_DistributedTransaction < Test::Unit::TestCase
 		    assert_equal([peer, Roby::Distributed], trsc.owners)
 		    assert(!trsc.first_editor?)
 		    assert(!trsc.editor?)
-		    assert(trsc.conflict_solver.kind_of?(Roby::SolverIgnoreUpdate))
 
 		    assert(trsc.subscribed?)
 		    assert(trsc.update_on?(peer))
@@ -48,7 +47,7 @@ class TC_DistributedTransaction < Test::Unit::TestCase
 		end
 	    end
 	end
-	trsc = Distributed::Transaction.new(plan, :conflict_solver => SolverIgnoreUpdate.new)
+	trsc = Distributed::Transaction.new(plan)
 	assert(trsc.self_owned?)
 	assert(trsc.first_editor?)
 	assert(trsc.editor?)
@@ -65,7 +64,7 @@ class TC_DistributedTransaction < Test::Unit::TestCase
     end
 
     def test_transaction_proxies
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    PeerServer.class_eval do
 		include Test::Unit::Assertions
 		def marshalled_transaction_proxy(trsc, task)
@@ -84,7 +83,7 @@ class TC_DistributedTransaction < Test::Unit::TestCase
 
 	# Check that marshalling the remote view of a local transaction proxy
 	# returns the local proxy itself
-	plan.insert(task = Task.new)
+	plan.add_mission(task = Task.new)
 	assert(!plan.update_on?(remote_peer))
 	assert(trsc.update_on?(remote_peer))
 	assert(!task.update_on?(remote_peer))
@@ -99,20 +98,20 @@ class TC_DistributedTransaction < Test::Unit::TestCase
 	assert_equal(proxy, remote_peer.local_object(marshalled_remote))
     end
 
-    # Checks that if we discover a set of tasks, then their relations are updated as well
+    # Checks that if we add a set of tasks, then their relations are updated as well
     def test_discover
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    def remote.add_tasks(trsc)
 		trsc = local_peer.local_object(trsc)
 
 		trsc.edit do
 		    t1 = SimpleTask.new :id => 'root'
-		    t1.realized_by(t2 = SimpleTask.new(:id => 'child'))
-		    t1.on(:start, t2, :start)
-		    t2.realized_by(t3 = SimpleTask.new(:id => 'grandchild'))
-		    t3.on(:failed, t2, :failed)
+		    t1.depends_on(t2 = SimpleTask.new(:id => 'child'))
+		    t1.signals(:start, t2, :start)
+		    t2.depends_on(t3 = SimpleTask.new(:id => 'grandchild'))
+		    t3.signals(:failed, t2, :failed)
 
-		    trsc.insert(t1)
+		    trsc.add_mission(t1)
 		end
 	    end
 	end
@@ -133,7 +132,7 @@ class TC_DistributedTransaction < Test::Unit::TestCase
     end
 
     def test_edition
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    class << remote
 		include Test::Unit::Assertions
 		def edit_transaction(trsc)
@@ -175,8 +174,8 @@ class TC_DistributedTransaction < Test::Unit::TestCase
     end
 
     def test_ownership
-	peer2peer(true) do |remote|
-	    remote.plan.insert(Task.new(:id => 1))
+	peer2peer do |remote|
+	    remote.plan.add_mission(Task.new(:id => 1))
 	    def remote.add_owner_local(trsc)
 		trsc = local_peer.local_object(trsc)
 		trsc.add_owner local_peer
@@ -207,34 +206,34 @@ class TC_DistributedTransaction < Test::Unit::TestCase
 	trsc.self_owned = false
 
 	task = Task.new
-	assert_raises(OwnershipError) { t_task.realized_by task }
-	assert_raises(OwnershipError) { task.realized_by t_task }
-	assert_raises(OwnershipError) { task.event(:start).on t_task.event(:start) }
+	assert_raises(OwnershipError) { t_task.depends_on task }
+	assert_raises(OwnershipError) { task.depends_on t_task }
+	assert_raises(OwnershipError) { task.event(:start).signals t_task.event(:start) }
 	assert_raises(OwnershipError) { trsc.discard_transaction }
 	assert_raises(OwnershipError) { trsc.commit_transaction }
 	assert(! task.plan)
-	assert_nothing_raised { t_task.event(:start).on task.event(:start) }
+	t_task.signals(:start, task, :start)
 
 	remote.add_owner_local(Distributed.format(trsc))
 
-	assert_nothing_raised { t_task.realized_by task }
-	assert_nothing_raised { t_task.remove_child task }
-	assert_nothing_raised { t_task.event(:start).remove_signal task.event(:start) }
-	assert_nothing_raised { task.realized_by t_task }
-	assert_nothing_raised { task.event(:start).on t_task.event(:start) }
+	t_task.depends_on task
+	t_task.remove_child task
+	t_task.event(:start).remove_signal task.event(:start)
+	task.depends_on t_task
+	task.signals(:start, t_task, :start)
 	assert_raises(OwnershipError) { trsc.remove_owner remote_peer }
 	assert_raises(OwnershipError) { trsc.self_owned = false }
-	assert_nothing_raised { trsc.discard_transaction }
+	trsc.discard_transaction
     end
 
     def test_executed_by
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    task = Task.new(:id => 1) 
 	    exec = Class.new(Task) do
 		event :ready, :command => true
 	    end.new(:id => 'exec')
 	    task.executed_by exec
-	    remote.plan.insert(task)
+	    remote.plan.add_mission(task)
 
 	    remote.singleton_class.class_eval do
 		include Test::Unit::Assertions
@@ -269,8 +268,8 @@ class TC_DistributedTransaction < Test::Unit::TestCase
     end
 
     def test_argument_updates
-	peer2peer(true) do |remote|
-	    remote.plan.insert(ArgumentUpdateTest.new(:id => 2))
+	peer2peer do |remote|
+	    remote.plan.add_mission(ArgumentUpdateTest.new(:id => 2))
 	    def remote.set_argument(task)
 		task = local_peer.local_object(task)
 		task.plan.edit
@@ -303,7 +302,7 @@ class TC_DistributedTransaction < Test::Unit::TestCase
 
 	# Now, add a task of our own and link the remote and the local
 	task = SimpleTask.new :id => 'local'
-	trsc.discover(task)
+	trsc.add(task)
 
 	parent = subscribe_task(:id => 'remote-1')
 	child  = subscribe_task(:id => 'remote-2')
@@ -318,10 +317,10 @@ class TC_DistributedTransaction < Test::Unit::TestCase
 	assert(task.event(:stop).read_write?)
 
 	# Add relations
-	trsc[parent].realized_by task
-	task.realized_by trsc[child]
-	trsc[parent].event(:start).on task.event(:start)
-	task.event(:stop).on trsc[child].event(:stop)
+	trsc[parent].depends_on task
+	task.depends_on trsc[child]
+	trsc[parent].event(:start).signals task.event(:start)
+	task.event(:stop).signals trsc[child].event(:stop)
 
 	[task, parent]
     end
@@ -350,10 +349,10 @@ class TC_DistributedTransaction < Test::Unit::TestCase
     end
 
     def test_propose_commit
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    testcase = self
-	    remote.plan.insert(root = SimpleTask.new(:id => 'remote-1'))
-	    root.realized_by(child = SimpleTask.new(:id => 'remote-2'))
+	    remote.plan.add_mission(root = SimpleTask.new(:id => 'remote-1'))
+	    root.depends_on(child = SimpleTask.new(:id => 'remote-2'))
 
 	    PeerServer.class_eval do
 		include Test::Unit::Assertions
@@ -382,10 +381,10 @@ class TC_DistributedTransaction < Test::Unit::TestCase
     end
 
     def test_synchronization
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    testcase = self
-	    remote.plan.insert(root = SimpleTask.new(:id => 'remote-1'))
-	    root.realized_by SimpleTask.new(:id => 'remote-2')
+	    remote.plan.add_mission(root = SimpleTask.new(:id => 'remote-1'))
+	    root.depends_on SimpleTask.new(:id => 'remote-2')
 
 	    PeerServer.class_eval do
 		define_method(:check_transaction) do |trsc|
@@ -411,8 +410,12 @@ class TC_DistributedTransaction < Test::Unit::TestCase
 	check_transaction_commit(trsc)
     end
 
+    class RemoteTaskModel < SimpleTask
+        argument :arg
+    end
+
     def test_create_remote_tasks
-	peer2peer(true) do |remote|
+	peer2peer do |remote|
 	    def remote.arguments_of(t)
 		t = local_peer.local_object(t)
 		t.arguments
@@ -434,12 +437,12 @@ class TC_DistributedTransaction < Test::Unit::TestCase
 	trsc.propose(remote_peer)
 
 	local_task = SimpleTask.new(:id => 'local')
-	trsc.insert(local_task)
+	trsc.add_mission(local_task)
 
-	t = SimpleTask.new(:arg => 10, :id => 0)
+	t = RemoteTaskModel.new(:arg => 10, :id => 0)
 	t.extend DistributedObject
-	local_task.realized_by t
-	trsc.insert(t)
+	local_task.depends_on t
+	trsc.add_mission(t)
 	t.owner = remote_peer
 
 	assert(trsc.task_index.by_owner[remote_peer].include?(t))