roby 0.8.0 → 3.0.0

data/test/distributed/test_execution.rb

@@ -1,378 +0,0 @@
-$LOAD_PATH.unshift File.expand_path(File.join('..', '..', 'lib'), File.dirname(__FILE__))
-require 'roby/test/distributed'
-require 'roby/test/tasks/simple_task'
-require 'flexmock'
-
-class TC_DistributedExecution < Test::Unit::TestCase
-    include Roby::Distributed::Test
-    SimpleTask = Roby::Test::SimpleTask
-
-    def setup
-        super
-        Roby.app.filter_backtraces = false
-    end
-
-    def test_event_status
-	peer2peer do |remote|
-	    class << remote
-		attr_reader :controlable
-		attr_reader :contingent
-		def create
-		    # Put the task to avoir having GC clearing the events
-		    plan.add_mission(t = SimpleTask.new(:id => 'task'))
-		    plan.add(@controlable = Roby::EventGenerator.new(true))
-		    plan.add(@contingent = Roby::EventGenerator.new(false))
-		    t.signals(:start, controlable, :start)
-		    t.forward_to(:start, contingent, :start)
-		    nil
-		end
-		def fire
-		    engine.execute do
-			controlable.call(nil) 
-			contingent.emit(nil)
-		    end
-		    nil
-		end
-	    end
-	end
-
-	remote.create
-	task = subscribe_task(:id => 'task')
-	controlable = *task.event(:start).child_objects(EventStructure::Signal).to_a
-	contingent  = *task.event(:start).child_objects(EventStructure::Forwarding).to_a
-
-	FlexMock.use do |mock|
-	    controlable.on do
-		mock.fired_controlable(engine.gathering?)
-	    end
-	    contingent.on do
-		mock.fired_contingent(engine.gathering?)
-	    end
-
-	    mock.should_receive(:fired_controlable).with(true).once
-	    mock.should_receive(:fired_contingent).with(true).once
-	    remote.fire
-	    remote_peer.synchro_point
-	end
-
-	assert(controlable.happened?)
-	assert(contingent.happened?)
-    end
-
-    def test_signal_establishment
-	peer2peer do |remote|
-	    Roby::Distributed.on_transaction do |trsc|
-		trsc.edit do
-		    local_task = trsc.find_tasks.which_fullfills(Roby::Test::SimpleTask).to_a.first
-		    t = trsc[SimpleTask.new(:id => 'remote_task')]
-		    local_task.depends_on t
-		    local_task.signals :start, t, :start
-		    nil
-		end
-	    end
-	end
-
-	trsc = Roby::Distributed::Transaction.new(plan)
-	trsc.add_owner remote_peer
-	trsc.propose(remote_peer)
-
-	plan.add_mission(local_task = Roby::Test::SimpleTask.new)
-	trsc[local_task]
-	trsc.release
-	trsc.edit
-	trsc.commit_transaction
-
-	engine.execute { local_task.start! }
-	engine.wait_one_cycle
-	remote_peer.synchro_point
-	remote_task = subscribe_task(:id => 'remote_task')
-	assert(remote_task.running?)
-
-	engine.execute do
-	    plan.unmark_mission(local_task)
-	    local_task.stop!
-	end
-    end
-
-    # This test that the event/plan modification order is kept on a remote host
-    def test_keeps_causality
-	peer2peer do |remote|
-	    class << remote
-		attr_reader :event
-		attr_reader :task
-		def create
-		    # Put the task to avoir having GC clearing the events
-		    plan.add_mission(@task = SimpleTask.new(:id => 'task'))
-		    plan.add(@event = Roby::EventGenerator.new(true))
-		    event.signals task.event(:start)
-		    nil
-		end
-		def fire
-		    engine.execute do
-			event.on do
-			    plan.unmark_mission(task)
-			    task.event(:start).signals task.event(:success)
-			end
-		
-			event.call(nil) 
-		    end
-		    nil
-		end
-	    end
-	end
-
-	remote.create
-	task = subscribe_task(:id => 'task')
-	event = *task.event(:start).parent_objects(EventStructure::Signal).to_a
-
-	FlexMock.use do |mock|
-	    event.on do
-		mock.fired
-		assert(plan.free_events.include?(event))
-	    end
-
-	    mock.should_receive(:fired).once
-	    remote.fire
-	    remote_peer.synchro_point
-	end
-
-	assert(event.happened?)
-    end
-
-    def test_task_status
-	Roby.app.abort_on_exception = false
-	peer2peer do |remote|
-	    class << remote
-		include Test::Unit::Assertions
-		attr_reader :task
-		def create_task
-		    plan.clear
-		    plan.add_mission(@task = SimpleTask.new(:id => 1))
-		end
-		def start_task; engine.once { task.start! }; nil end
-		def stop_task
-		    assert(task.executable?)
-		    engine.once do
-			plan.unmark_mission(task)
-			task.stop!
-		    end
-		    nil
-		end
-	    end
-	end
-
-	remote.create_task
-	p_task = remote_task(:id => 1)
-	assert(!p_task.event(:start).happened?)
-	process_events
-	assert(!p_task.plan)
-
-	# Start the task *before* subscribing to test that #subscribe maps the
-	# task status
-	remote.start_task
-	process_events
-	p_task = subscribe_task(:id => 1)
-	assert(p_task.running?)
-	assert(p_task.event(:start).happened?)
-
-	# Stop the task to see if the fired event is propagated
-	remote.stop_task
-	process_events
-	assert(p_task.finished?)
-	assert(p_task.failed?)
-	assert(p_task.event(:stop).happened?)
-	assert(p_task.finished?)
-    end
-
-    def test_signalling
-	peer2peer do |remote|
-	    remote.plan.add_mission(task = SimpleTask.new(:id => 1))
-	    remote.class.class_eval do
-		include Test::Unit::Assertions
-		define_method(:start_task) do
-		    events = plan.free_events.to_a
-		    assert_equal(2, events.size)
-		    assert(sev = events.find { |ev| ev.controlable? })
-		    assert(fev = events.find { |ev| !ev.controlable? })
-		    assert(task.event(:start).child_object?(sev, Roby::EventStructure::Signal))
-		    assert(task.event(:start).child_object?(fev, Roby::EventStructure::Forwarding))
-		    engine.once { task.start! }
-		    nil
-		end
-	    end
-	end
-	p_task = subscribe_task(:id => 1)
-
-	FlexMock.use do |mock|
-	    signalled_ev = EventGenerator.new do |context|
-		mock.signal_command
-		signalled_ev.emit(nil)
-	    end
-	    signalled_ev.on { |ev| mock.signal_emitted }
-	    assert(signalled_ev.controlable?)
-
-	    forwarded_ev = EventGenerator.new	
-	    forwarded_ev.on { |ev| mock.forward_emitted }
-	    assert(!forwarded_ev.controlable?)
-
-	    p_task.event(:start).signals signalled_ev
-	    p_task.event(:start).forward_to forwarded_ev
-
-	    mock.should_receive(:signal_command).once.ordered('signal')
-	    mock.should_receive(:signal_emitted).once.ordered('signal')
-	    mock.should_receive(:forward_emitted).once
-	    process_events
-
-	    remote.start_task
-	    process_events
-	    assert(signalled_ev.happened?)
-	    assert(forwarded_ev.happened?)
-	end
-    end
-
-    def test_event_handlers
-	peer2peer do |remote|
-	    remote.plan.add_mission(task = SimpleTask.new(:id => 1))
-	    def remote.start(task)
-		task = local_peer.local_object(task)
-		engine.once { task.start! }
-		nil
-	    end
-	end
-	FlexMock.use do |mock|
-	    mock.should_receive(:started).once
-
-	    task = subscribe_task(:id => 1)
-	    task.on(:start) { mock.started }
-	    remote.start(Distributed.format(task))
-	    process_events
-
-	    assert(task.running?)
-	end
-    end
-
-    # Test that we can 'forget' running tasks that was known to us because they
-    # were related to subscribed tasks
-    def test_forgetting
-	peer2peer do |remote|
-	    parent, child =
-		SimpleTask.new(:id => 'parent'), 
-		SimpleTask.new(:id => 'child')
-	    parent.depends_on child
-
-	    remote.plan.add_mission(parent)
-	    child.start!
-	    remote.singleton_class.class_eval do
-		define_method(:remove_link) do
-		    parent.remove_child(child)
-		end
-	    end
-	end
-
-	parent   = subscribe_task(:id => 'parent')
-	child    = nil
-	assert(child = local.plan.known_tasks.find { |t| t.arguments[:id] == 'child' })
-	assert(!child.subscribed?)
-	assert(child.running?)
-	remote.remove_link
-	process_events
-	assert(!local.plan.known_tasks.find { |t| t.arguments[:id] == 'child' })
-    end
-
-    # Tests that running remote tasks are aborted and pending tasks GCed if the
-    # connection is killed
-    def test_disconnect_kills_tasks
-	peer2peer do |remote|
-	    remote.plan.add_mission(task = SimpleTask.new(:id => 'remote-1'))
-	    def remote.start(task)
-		task = local_peer.local_object(task)
-		engine.execute do
-		    task.start!
-		end
-		nil
-	    end
-	end
-
-	task = subscribe_task(:id => 'remote-1')
-	remote.start(Distributed.format(task))
-	process_events
-	assert(task.running?)
-	assert(task.child_object?(remote_peer.task, TaskStructure::ExecutionAgent))
-	assert(task.subscribed?)
-
-	engine.execute do
-	    remote_peer.disconnected!
-	end
-	assert(!task.subscribed?)
-	assert(remote_peer.task.finished?)
-	assert(remote_peer.task.event(:aborted).happened?)
-	assert(remote_peer.task.event(:stop).happened?)
-	assert(task.finished?)
-    end
-
-    # Checks that the code blocks are called only in owning controllers
-    class CodeBlocksOwnersMockup < Roby::Test::SimpleTask
-	attr_reader :command_called
-	event :start do
-	    @command_called = true
-	    emit :start
-	end
-
-	attr_reader :handler_called
-	on(:start) { @handler_called = true }
-
-	attr_reader :poller_called
-	poll { @poller_called = true }
-    end
-
-    def test_code_blocks_owners
-	peer2peer do |remote|
-	    remote.plan.add_mission(CodeBlocksOwnersMockup.new(:id => 'mockup'))
-
-	    def remote.call
-		task = plan.find_tasks(CodeBlocksOwnersMockup).to_a.first
-		engine.execute { task.start! }
-	    end
-
-	    def remote.blocks_called
-		task = plan.find_tasks(CodeBlocksOwnersMockup).to_a.first
-		task.command_called && task.poller_called && task.handler_called
-	    end
-	end
-
-	mockup = subscribe_task(:id => 'mockup')
-	remote.call
-	remote_peer.synchro_point
-
-	assert(remote.blocks_called)
-	assert(!mockup.command_called)
-	assert(!mockup.poller_called)
-	assert(!mockup.handler_called)
-    end
-
-    # Checks that we get the update fine if +fired+ and +signalled+ are
-    # received in the same cycle
-    def test_joint_fired_signalled
-	peer2peer do |remote|
-	    remote.plan.add_mission(task = SimpleTask.new(:id => 'remote-1'))
-	    engine.once { task.start! }
-	end
-	    
-	event_time = Time.now
-	remote = subscribe_task(:id => 'remote-1')
-	plan.add_mission(local = SimpleTask.new(:id => 'local'))
-	remote_peer.synchro_point
-
-	engine.execute do
-	    remote_peer.local_server.event_fired(remote.event(:success), 0, Time.now, [42])
-	    remote_peer.local_server.event_add_propagation(true, remote.event(:success), local.event(:start), 0, event_time, [42])
-	end
-	process_events
-
-	assert(remote.finished?)
-	assert(remote.success?)
-	assert(local.started?)
-	assert_equal(1, remote.history.size, remote.history)
-    end
-end
-

data/test/distributed/test_mixed_plan.rb

@@ -1,341 +0,0 @@
-$LOAD_PATH.unshift File.expand_path(File.join('..', '..', 'lib'), File.dirname(__FILE__))
-require 'roby/test/distributed'
-require 'roby/test/tasks/simple_task'
-
-# This testcase tests buildings plans where local tasks are interacting with remote tasks
-#
-# Naming scheme:
-#   test_r<type of remote object>_realizes_l<type of local object>(_dynamic)
-#
-# For instance,  test_rproxy_realizes_lproxy means that we are building a
-# transaction where a remote transaction proxy is linked to a local transaction
-# proxy. If _dynamic is appended, #propose is called when the transaction is still
-# empty. Otherwise, #propose is called after all modifications have been put into
-# the transaction (propose then build or build then propose)
-#
-# The transaction is always built locally
-class TC_DistributedMixedPlan < Test::Unit::TestCase
-    include Roby::Distributed::Test
-
-    # 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.depends_on t2
-	t2.planned_by t3
-	plan.add_mission(t1)
-	plan.add(t2)
-	plan.add(t3)
-
-	[t1, t2, t3]
-    end
-
-    def check_local_center_structure(node, removed_planner)
-	if node.respond_to?(:__getobj__)
-	    assert_equal(["remote-2"], node.parents.map { |obj| obj.arguments[:id] })
-	else
-	    assert_equal(["local-1", "remote-2"].to_set, node.parents.map { |obj| obj.arguments[:id] }.to_set)
-	    unless removed_planner
-		assert_equal(["local-3"], node.enum_for(:each_planning_task).map { |obj| obj.arguments[:id] })
-	    end
-	end
-    end
-
-    def check_remote_center_structure(node, removed_planner)
-	assert_equal(["local-2"], node.children.map { |obj| obj.arguments[:id] })
-	unless node.respond_to?(:__getobj__)
-	    assert_equal(["remote-1"], node.parents.map { |obj| obj.arguments[:id] })
-	    unless removed_planner
-		assert_equal(["remote-3"], node.enum_for(:each_planning_task).map { |obj| obj.arguments[:id] })
-	    end
-	end
-    end
-
-    # Checks that +plan+ has all 6 tasks with remote-2 and local-2 linked as
-    # expected +plan+ may be either the transaction or the plan
-    #
-    # 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 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.
-    def check_resulting_plan(plan, removed_planner)
-	assert(remote_center_node = plan.known_tasks.find { |t| t.arguments[:id] == "remote-2" }, plan.known_tasks)
-	check_remote_center_structure(remote_center_node, removed_planner)
-	assert(local_center_node  = plan.known_tasks.find { |t| t.arguments[:id] == "local-2" }, plan.known_tasks)
-	check_local_center_structure(local_center_node, removed_planner)
-    end
-
-    def assert_cleared_relations(plan)
-	if remote_center_node = plan.known_tasks.find { |t| t.arguments[:id] == "remote-2" }
-	    assert_equal([], remote_center_node.enum_for(:each_planning_task).to_a)
-	end
-
-	if local_center_node = plan.known_tasks.find { |t| t.arguments[:id] == "local-2" }
-	    assert_equal([], local_center_node.enum_for(:each_planning_task).to_a)
-	end
-    end
-
-    # Common setup of the remote peer
-    def common_setup(propose_first)
-	peer2peer do |remote|
-	    testcase = self
-	    remote.singleton_class.class_eval do
-		define_method(:add_tasks) do |plan|
-		    plan = local_peer.proxy(plan)
-		    plan.edit do
-			testcase.add_tasks(plan, "remote") 
-		    end
-		end
-		define_method(:check_resulting_plan) do |plan, removed_planner|
-		    plan = local_peer.proxy(plan)
-		    plan.edit do
-			testcase.check_resulting_plan(local_peer.proxy(plan), removed_planner) 
-		    end
-		end
-		define_method(:assert_cleared_relations) do |plan|
-		    plan = local_peer.proxy(plan)
-		    plan.edit do
-			testcase.assert_cleared_relations(local_peer.proxy(plan))
-		    end
-		end
-		def remove_relations(t2)
-		    plan.edit do
-			t2 = local_peer.local_object(t2)
-			raise unless t3 = t2.planning_task
-			t2.remove_planning_task(t3)
-		    end
-		end
-		def subscribe(remote_task)
-		    local_peer.subscribe(remote_task)
-		end
-	    end
-	end
-
-	# Create the transaction, and do the necessary modifications
-	trsc = Distributed::Transaction.new(plan)
-
-	trsc.add_owner remote_peer
-	trsc.self_owned
-	trsc.propose(remote_peer) if propose_first
-
-	yield(trsc)
-
-	# Check the transaction is still valid, regardless of the
-	# changes we made to the plan
-	check_resulting_plan(trsc, true)
-	trsc.release(false)
-	remote.check_resulting_plan(Distributed.format(trsc), true)
-	trsc.edit
-
-	# Commit and check the result
-	trsc.commit_transaction
-
-	check_resulting_plan(plan, true)
-	remote.check_resulting_plan(Distributed.format(plan), true)
-    end
-
-    def test_rproxy_realizes_lproxy(propose_first = false)
-	common_setup(propose_first) do |trsc|
-	    # First, add relations between two nodes that are already existing
-	    remote.add_tasks(Distributed.format(plan))
-	    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 = Roby.synchronize { add_tasks(plan, "local") }
-
-	    assert(plan.useful_task?(r_t1))
-	    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
-		trsc.release(false)
-		remote.check_resulting_plan(Distributed.format(trsc), false)
-		trsc.edit
-	    end
-
-	    # Remove the relations in the real tasks (not the proxies)
-	    Roby.synchronize do
-		t2.remove_planning_task(t3)
-	    end
-	    remote.remove_relations(Distributed.format(r_t2))
-	    remote.subscribe(Distributed.format(t2))
-
-	    process_events
-	    assert(plan.useful_task?(r_t1))
-	    assert_cleared_relations(plan)
-
-	    unless propose_first
-		trsc.propose(remote_peer)
-	    end
-
-	    process_events
-	    remote.assert_cleared_relations(Distributed.format(plan))
-	end
-    end
-    def test_rproxy_realizes_lproxy_dynamic; test_rproxy_realizes_lproxy(true) end
-
-    def test_rproxy_realizes_ltask(propose_first = false)
-	common_setup(propose_first) do |trsc|
-	    remote.add_tasks(Distributed.format(plan))
-	    r_t2 = subscribe_task(:id => 'remote-2')
-	    t1, t2, t3 = Roby.synchronize { add_tasks(trsc, "local") }
-
-	    trsc[r_t2].depends_on t2
-	    trsc[r_t2].signals(:start, t2, :start)
-	    check_resulting_plan(trsc, false)
-	    process_events
-	    if propose_first
-		remote_peer.push_subscription(t2)
-		trsc.release(false)
-		remote.check_resulting_plan(Distributed.format(trsc), false)
-		trsc.edit
-	    end
-
-	    # remove the relations in the real tasks (not the proxies)
-	    remote.remove_relations(Distributed.format(r_t2))
-
-	    unless propose_first
-		trsc.propose(remote_peer)
-		remote_peer.push_subscription(t2)
-	    end
-	    process_events
-	    remote.assert_cleared_relations(Distributed.format(plan))
-	end
-    end
-    def test_rproxy_realizes_ltask_dynamic; test_rproxy_realizes_ltask(true) end
-
-    # no non-dynamic version for that since we need the transactio to be
-    # present on both sides if we want to have remote tasks in it
-    def test_rtask_realizes_lproxy
-	common_setup(true) do |trsc|
-	    trsc.release(false)
-	    r_t1, r_t2, r_t3 = remote.add_tasks(Distributed.format(trsc)).map { |t| remote_peer.proxy(t) }
-	    trsc.edit
-
-	    assert(r_t2.subscribed?)
-	    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)
-
-	    check_resulting_plan(trsc, false)
-	    trsc.release(false)
-	    remote.check_resulting_plan(Distributed.format(trsc), false)
-	    trsc.edit
-
-	    # remove the relations in the real tasks (not the proxies)
-	    t2.remove_planning_task(t3)
-	    process_events
-	    remote.assert_cleared_relations(Distributed.format(plan))
-	end
-    end
-
-    def test_garbage_collect
-	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.depends_on(r2 = SimpleTask.new(:id => 'remote-2'))
-		r2.depends_on(r3 = SimpleTask.new(:id => 'remote-3'))
-		trsc.release(false)
-	    end
-	end
-
-	r1 = subscribe_task(:id => 'remote-1')
-	assert(!plan.unneeded_tasks.include?(r1))
-
-	t1 = SimpleTask.new
-
-	# Add a local child to r1. This local child, and r1, must be kept event
-	# we are not subscribed to r1 anymore
-	trsc = Distributed::Transaction.new(plan)
-	trsc.add_owner(remote_peer)
-	trsc[r1].depends_on t1
-	Roby.synchronize do
-	    remote_peer.unsubscribe(r1)
-	    assert(!plan.unneeded_tasks.include?(r1))
-	end
-
-	trsc.propose(remote_peer)
-	trsc.commit_transaction
-	assert(!plan.unneeded_tasks.include?(r1))
-	assert(!plan.unneeded_tasks.include?(t1), plan.unneeded_tasks)
-
-	# 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.synchronize do
-	    t1.depends_on(t2 = SimpleTask.new)
-	    assert(!plan.unneeded_tasks.include?(t2))
-	    t2.depends_on(t3 = SimpleTask.new)
-	    assert(!plan.unneeded_tasks.include?(t3))
-	end
-
-	# Now, create a t3 => r2 => r3 chain
-	# * r2 should be kept since it is related to a task which is kept
-	# * r3 should not be kept
-	trsc = Distributed::Transaction.new(plan)
-	trsc.add_owner(remote_peer)
-	trsc.propose(remote_peer)
-	trsc.release
-	remote.insert_children(Distributed.format(trsc), Distributed.format(trsc[t3]))
-	trsc.edit
-	trsc.commit_transaction
-	process_events
-
-	r2 = remote_task(:id => 'remote-2')
-	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.synchronize do
-	    assert(!r3.plan || plan.unneeded_tasks.include?(r3))
-	end
-    end
-
-    # This tests that the race condition between transaction commit and plan GC
-    # is handled properly: if a task inside a transaction will be GCed just
-    # 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 do |remote|
-	    def remote.add_task(trsc)
-		trsc = local_peer.local_object(trsc)
-		trsc.edit
-		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 add a task, which 
-	# will be GCed as soon as the transaction is committed
-	trsc = Distributed::Transaction.new(plan)
-	trsc.add_owner(remote_peer)
-	trsc.propose(remote_peer)
-	trsc.release
-	remote.add_task(Distributed.format(trsc))
-	trsc.edit
-	
-	assert_nothing_raised do
-	    trsc.commit_transaction
-	    process_events
-	end
-	assert(remote_peer.connected?)
-    end
-end
-
-