roby 0.8.0 → 3.0.0

data/test/test_gui.rb

@@ -1,20 +0,0 @@
-$LOAD_PATH.unshift File.expand_path(File.join('..', 'lib'), File.dirname(__FILE__))
-require 'roby/test/common'
-require 'roby/test/tasks/simple_task'
-require 'roby/test/tasks/empty_task'
-
-require 'roby/log/gui/relations'
-
-class TC_Task < Test::Unit::TestCase 
-    include Roby::Test
-
-    def test_index_handling
-        model = Ui::RelationConfigModel.new(nil)
-        [-1, 0, 222].each do |id|
-            idx = model.createIndex(0, 0, id)
-            assert_equal(id, Ui::RelationConfigModel.category_from_index(idx))
-        end
-    end
-end
-
-

data/test/test_interface.rb

@@ -1,43 +0,0 @@
-$LOAD_PATH.unshift File.expand_path(File.join('..', 'lib'), File.dirname(__FILE__))
-require 'roby/test/common'
-require 'roby/interface'
-require 'flexmock'
-
-class TC_Interface < Test::Unit::TestCase 
-    include Roby::Test
-
-    def setup
-        super
-        Roby.app.filter_backtraces = false
-    end
-
-
-    include Roby::Planning
-    def test_method_missing
-        iface   = Interface.new(engine)
-
-        task_model = Class.new(Task)
-
-        result_task = nil
-        planner = Class.new(Planner) do
-            method(:null_task) { result_task = task_model.new }
-        end
-        Roby.app.planners << planner
-
-	engine.run
-	returned_task = iface.null_task! do |_, planner|
-	    planner.start!
-	end
-
-	assert_kind_of(Roby::RemoteObjectProxy, returned_task)
-	marshalled = nil
-	assert_nothing_raised { marshalled = Marshal.dump(returned_task) }
-	unmarshalled = Marshal.load(marshalled)
-
-	assert_kind_of(Roby::Task, unmarshalled)
-	assert_equal(result_task, unmarshalled)
-	plan_task = plan.missions.find { true }
-	assert_equal(plan_task, unmarshalled)
-    end
-end
-

data/test/test_log.rb

@@ -1,125 +0,0 @@
-$LOAD_PATH.unshift File.expand_path(File.join('..', 'lib'), File.dirname(__FILE__))
-require 'roby/test/common'
-require 'roby/test/distributed'
-require 'roby/test/tasks/simple_task'
-
-require 'roby'
-require 'roby/log'
-require 'flexmock'
-
-class TC_Log < Test::Unit::TestCase
-    include Roby::Test
-
-    def teardown
-	super
-	Log.clear_loggers
-    end
-
-    def test_start_stop_logger
-	FlexMock.use do |mock|
-	    mock.should_receive(:close).once
-	    Log.add_logger mock
-	    assert(Log.logging?)
-	    assert_nothing_raised { Log.start_logging }
-
-	    Log.remove_logger mock
-	    assert(!Log.logging?)
-	    assert_nothing_raised { Log.stop_logging }
-	end
-    end
-
-    def test_misc
-	FlexMock.use do |mock|
-            mock.should_receive(:logs_message?).with(:flush).and_return(false)
-            mock.should_receive(:logs_message?).with(:event).and_return(true)
-	    mock.should_receive(:splat?).and_return(true)
-	    mock.should_receive(:event).with(1, 2)
-	    mock.should_receive(:flush)
-	    mock.should_receive(:close).once
-	    Log.add_logger mock
-
-	    assert(!Log.has_logger?(:flush))
-	    assert(Log.has_logger?(:event))
-
-	    assert_equal([mock], Log.enum_for(:each_logger, :event).to_a)
-	    assert_equal([], Log.enum_for(:each_logger, :bla).to_a)
-            Log.remove_logger mock
-	end
-    end
-
-    def test_message_splat
-	FlexMock.use do |mock|
-            mock.should_receive(:logs_message?).and_return(true)
-	    mock.should_receive(:splat?).and_return(true).twice
-	    mock.should_receive(:splat_event).with(FlexMock.any, 1, 2).once
-	    mock.should_receive(:flush).once
-	    mock.should_receive(:close).once
-	    Log.add_logger mock
-
-	    Log.log(:splat_event) { [1, 2] }
-            Log.remove_logger mock
-	end
-    end
-
-    def test_message_nonsplat
-	FlexMock.use do |mock|
-            mock.should_receive(:logs_message?).and_return(true)
-	    mock.should_receive(:splat?).and_return(false).twice
-	    mock.should_receive(:nonsplat_event).with(FlexMock.any, [1, 2]).once
-	    mock.should_receive(:flush).once
-	    mock.should_receive(:close).once
-	    Log.add_logger mock
-
-	    Log.log(:nonsplat_event) { [1, 2] }
-            Log.remove_logger mock
-	end
-    end
-
-    def on_marshalled_task(task)
-	FlexMock.on do |obj| 
-	    obj.remote_siblings[Roby::Distributed.droby_dump(nil)] == task.remote_id
-	end
-    end
-    def test_known_objects_management
-	t1, t2 = SimpleTask.new, SimpleTask.new
-	FlexMock.use do |mock|
-            mock.should_receive(:logs_message?).and_return(true)
-	    mock.should_receive(:splat?).and_return(true)
-	    mock.should_receive(:added_task_child).
-		with(FlexMock.any, on_marshalled_task(t1), [TaskStructure::Hierarchy].droby_dump(nil), 
-		     on_marshalled_task(t2), FlexMock.any).once
-
-	    match_discovered_set = FlexMock.on do |task_set| 
-		task_set.map { |obj| obj.remote_siblings[Roby::Distributed.droby_dump(nil)] }.to_set == [t1.remote_id, t2.remote_id].to_set
-	    end
-
-	    mock.should_receive(:added_tasks).
-		with(FlexMock.any, FlexMock.any, match_discovered_set).
-		once
-	    mock.should_receive(:removed_task_child).
-		with(FlexMock.any, t1.remote_id, [TaskStructure::Hierarchy].droby_dump(nil), t2.remote_id).
-		once
-	    mock.should_receive(:finalized_task).
-		with(FlexMock.any, FlexMock.any, t1.remote_id).
-		once
-            mock.should_receive(:close).once
-
-	    Log.add_logger mock
-	    begin
-		t1.depends_on t2
-		assert(Log.known_objects.empty?)
-		plan.add(t1)
-		assert_equal([t1, t2].to_value_set, Log.known_objects)
-		t1.remove_child t2
-		assert_equal([t1, t2].to_value_set, Log.known_objects)
-		plan.remove_object(t1)
-		assert_equal([t2].to_value_set, Log.known_objects)
-
-		Log.flush
-	    ensure
-		Log.remove_logger mock
-	    end
-	end
-    end
-end
-

data/test/test_log_server.rb

@@ -1,133 +0,0 @@
-$LOAD_PATH.unshift File.expand_path(File.join('..', 'lib'), File.dirname(__FILE__))
-require 'roby/test/distributed'
-require 'roby/log/server'
-
-class TC_LogServer < Test::Unit::TestCase
-    include Roby::Distributed::Test
-    include Roby::Log
-
-    def test_discovery(remote = nil)
-	recursive = !remote
-	remote ||= remote_server do
-	    def display_server
-		unless @display_server
-		    @display_server = Log::Server.new
-		    timings = DataStream.new 'robot', 'roby-timings'
-		    @display_server.added_stream(timings)
-		end
-		DRbObject.new(@display_server)
-	    end
-	end
-
-	remote_display = remote.display_server
-
-	Log::Server.enable_discovery 'localhost'
-	assert_raises(ArgumentError) { Log::Server.enable_discovery 'localhost' }
-	sleep(0.5)
-	assert_equal([remote_display], Log::Server.available_servers)
-
-	Log::Server.disable_discovery
-	if recursive
-	    test_discovery(remote)
-	end
-    end
-
-    def test_connection(remote = nil)
-	recursive = !remote
-	remote ||= remote_server do
-	    attr_reader :timings, :events
-	    def display_server
-		unless @display_server
-		    @display_server = Log::Server.new
-
-		    @timings = DataStream.new 'robot', 'roby-timings'
-		    @display_server.added_stream(timings)
-		end
-		DRbObject.new(@display_server)
-	    end
-	    def timings_id; timings.id end
-	    def events_id; events.id end
-	    def add_stream
-		@events = DataStream.new 'robot', 'roby-events'
-		@display_server.added_stream(events)
-		nil
-	    end
-	    def remove_stream
-		@display_server.removed_stream(events.id)
-		nil
-	    end
-	    def quit
-		@display_server.quit
-		nil
-	    end
-	end
-
-	display_server = remote.display_server
-	source = Log::Client.new(display_server)
-	assert_equal([[remote.timings_id, 'robot', 'roby-timings']], 
-		     source.streams.map { |s| [s.id, s.name, s.type] })
-	assert(source.connected?)
-
-	remote.add_stream
-	sleep(0.5)
-	assert_equal([[remote.timings_id, 'robot', 'roby-timings'], [remote.events_id, 'robot', 'roby-events']].to_set, 
-		     source.streams.map { |s| [s.id, s.name, s.type] }.to_set)
-
-	remote.remove_stream
-	sleep(0.5)
-	assert_equal([['robot', 'roby-timings']], source.streams.map { |s| [s.name, s.type] })
-
-	source.disconnect
-	remote.add_stream
-	sleep(0.5)
-	assert(!source.connected?)
-
-	# try reconnection ...
-	if recursive
-	    remote.remove_stream
-	    test_connection(remote)
-	else
-	    source.connect
-	    assert_equal([['robot', 'roby-timings'], ['robot', 'roby-events']].to_set, 
-			 source.streams.map { |s| [s.name, s.type] }.to_set)
-
-	    # ... or check what happens if the remote server quits
-	    remote.quit
-	    sleep(0.5)
-	    assert(!source.connected?)
-	end
-    end
-
-    def test_subscription
-	remote = remote_server do
-	    attr_reader :timings, :events
-	    def display_server
-		unless @display_server
-		    @display_server = Log::Server.new
-		    @timings = DataStream.new 'robot', 'roby-timings'
-		    @display_server.added_stream(timings)
-		end
-		DRbObject.new(@display_server)
-	    end
-	    def add_sample
-		@display_server.push(timings.id, Time.now, 42)
-	    end
-	end
-
-	display_server = remote.display_server
-	source = Log::Client.new(display_server)
-	source.subscribe(stream = source.streams.first)
-
-	remote.add_sample
-	sleep(0.5)
-	stream = source.streams.find { |s| s.id == stream.id }
-	assert(stream.has_sample?)
-	assert_equal(42, stream.read, source.streams)
-	assert(!stream.has_sample?)
-	
-	source.unsubscribe(stream)
-	remote.add_sample
-	sleep(0.5)
-    end
-end
-

data/test/test_plan.rb

@@ -1,418 +0,0 @@
-$LOAD_PATH.unshift File.expand_path(File.join('..', 'lib'), File.dirname(__FILE__))
-require 'roby/test/common'
-require 'roby/test/tasks/simple_task'
-
-require 'flexmock'
-
-
-module TC_PlanStatic
-    include Roby
-    include Roby::Test
-
-    def assert_task_state(task, state)
-        assert_planobject_state(task, state)
-        if state == :removed
-            assert(!plan.mission?(task))
-            assert(!task.mission?)
-        else
-            if state == :mission
-                assert(plan.mission?(task))
-                assert(task.mission?)
-            elsif state == :permanent
-                assert(!plan.mission?(task))
-                assert(!task.mission?)
-            elsif state == :normal
-                assert(!plan.mission?(task))
-                assert(!task.mission?)
-            end
-        end
-    end
-    def assert_planobject_state(obj, state)
-        if state == :removed
-            assert(!plan.include?(obj))
-            assert(!plan.permanent?(obj))
-            assert_equal(nil, obj.plan)
-        else
-            assert_equal(plan, obj.plan)
-            assert(plan.include?(obj))
-            if state == :permanent
-                assert(plan.permanent?(obj))
-            else
-                assert(!plan.permanent?(obj))
-            end
-        end
-    end
-
-    def test_add_task
-	plan.add(t = Task.new)
-        assert_task_state(t, :normal)
-
-        other_plan = Plan.new
-        assert_raises(ModelViolation) { other_plan.add(t) }
-    end
-    def test_add_task_deprecated_discover
-        t = Task.new
-	deprecated_feature { plan.discover(t) }
-        assert_task_state(t, :normal)
-    end
-    def test_remove_task
-	plan.remove_object(t)
-        assert_task_state(t, :removed)
-    end
-
-    def test_add_mission
-	plan.add_mission(t = Task.new)
-        assert_task_state(t, :mission)
-    end
-    def test_add_mission_deprecated_insert
-	plan.insert(t = Task.new)
-        assert_task_state(t, :mission)
-    end
-    def test_unmark_mission
-	plan.add_mission(t = Task.new)
-	plan.unmark_mission(t)
-        assert_task_state(t, :normal)
-    end
-    def test_removed_mission
-	plan.add_mission(t = Task.new)
-	plan.remove_object(t)
-        assert_task_state(t, :removed)
-    end
-
-    def test_add_mission_deprecated_insert
-        t = Task.new
-        deprecated_feature { plan.insert(t) }
-        assert_task_state(t, :mission)
-    end
-    def test_unmark_mission_deprecated_discard
-	plan.add_mission(t = Task.new)
-	deprecated_feature { plan.discard(t) }
-        assert_task_state(t, :normal)
-    end
-    def test_unmark_mission_deprecated_remove_mission
-	plan.add_mission(t = Task.new)
-	deprecated_feature { plan.remove_mission(t) }
-        assert_task_state(t, :normal)
-    end
-
-    def test_add_permanent
-	plan.add_permanent(t = Task.new)
-        assert_task_state(t, :permanent)
-    end
-    def test_unmark_permanent
-	plan.add_permanent(t = Task.new)
-	plan.unmark_permanent(t)
-        assert_task_state(t, :normal)
-    end
-    def test_remove_permanent
-	plan.add_permanent(t = Task.new)
-	plan.remove_object(t)
-        assert_task_state(t, :removed)
-    end
-
-    def test_add_permanent_deprecated_permanent
-        t = Task.new
-	deprecated_feature { plan.permanent(t) }
-        assert_task_state(t, :permanent)
-    end
-    def test_unmark_permanent_deprecated_auto
-	plan.add_permanent(t = Task.new)
-	deprecated_feature { plan.auto(t) }
-        assert_task_state(t, :normal)
-    end
-
-    def test_add_event
-	plan.add(ev = EventGenerator.new)
-        assert_planobject_state(ev, :normal)
-    end
-    def test_remove_event
-	plan.add(ev = EventGenerator.new)
-	plan.remove_object(ev)
-        assert_planobject_state(ev, :removed)
-    end
-    def test_add_permanent_event
-	plan.add_permanent(ev = EventGenerator.new)
-        assert_planobject_state(ev, :permanent)
-    end
-    def test_unmark_permanent_event
-	plan.add_permanent(ev = EventGenerator.new)
-	plan.unmark_permanent(ev)
-        assert_planobject_state(ev, :normal)
-    end
-    def test_permanent_event_deprecated_permanent
-        ev = EventGenerator.new
-	deprecated_feature { plan.permanent(ev) }
-        assert_planobject_state(ev, :permanent)
-    end
-    def test_unmark_permanent_event_deprecated_auto
-	plan.add_permanent(ev = EventGenerator.new)
-	deprecated_feature { plan.unmark_permanent(ev) }
-        assert_planobject_state(ev, :normal)
-    end
-
-    # TODO: test that #remove_object removes the object from its relations
-    # TODO: test that #add adds related objects
-
-    #def test_discover
-    #    t1, t2, t3, t4 = prepare_plan :tasks => 4, :model => Roby::Test::SimpleTask
-    #    t1.depends_on t2
-    #    or_ev = OrGenerator.new
-    #    t2.event(:start).signals or_ev
-    #    or_ev.signals t3.event(:stop)
-    #    t2.planned_by t4
-
-    #    result = plan.discover(t1)
-    #    assert_equal(plan, result)
-    #    assert( plan.include?(t1) )
-    #    assert( plan.include?(t2) )
-    #    assert( plan.free_events.include?(or_ev))
-    #    assert( !plan.include?(t3) ) # t3 not related because of task structure
-    #    assert( plan.include?(t4) )
-
-    #    # Discover t3 to help plan cleanup
-    #    plan.discover(t3)
-
-    #    # Discover an AndGenerator and not its sources. The sources
-    #    # must be discovered automatically
-    #    a, b = (1..2).map { EventGenerator.new(true) }
-    #    and_event = a & b
-    #    plan.discover(and_event)
-    #    assert_equal(plan, a.plan)
-    #end
-
-    def test_useful_task_components
-	t1, t2, t3, t4 = prepare_plan :tasks => 4, :model => Roby::Test::SimpleTask
-	t1.depends_on t2
-	t2.signals(:start, t3, :stop)
-	t2.planned_by t4
-
-	plan.add_mission(t1)
-
-	assert_equal([t1, t2, t4].to_value_set, plan.locally_useful_tasks)
-	plan.add_mission(t3)
-	assert_equal([t1, t2, t3, t4].to_value_set, plan.locally_useful_tasks)
-	plan.unmark_mission(t1)
-	assert_equal([t3].to_value_set, plan.locally_useful_tasks)
-	assert_equal([t1, t2, t4].to_value_set, plan.unneeded_tasks)
-    end
-
-    def test_replace_task
-	(p, c1), (c11, c12, c2, c3) = prepare_plan :missions => 2, :tasks => 4, :model => Roby::Test::SimpleTask
-	p.depends_on c1, :model => [Roby::Test::SimpleTask, {}]
-	c1.depends_on c11
-	c1.depends_on c12
-	p.depends_on c2
-	c1.signals(:stop, c2, :start)
-	c1.forward_to :start, c1, :stop
-	c11.forward_to :success, c1, :success
-
-	# Replace c1 by c3 and check that the hooks are properly called
-	FlexMock.use do |mock|
-	    p.singleton_class.class_eval do
-		define_method('removed_child_object') do |child, relations|
-		    mock.removed_hook(self, child, relations)
-		end
-	    end
-	    c1.singleton_class.class_eval do
-		define_method('removed_parent_object') do |parent, relations|
-		    mock.removed_hook(self, parent, relations)
-		end
-	    end
-
-	    mock.should_receive(:removed_hook).with(p, c1, [TaskStructure::Hierarchy]).once
-	    mock.should_receive(:removed_hook).with(c1, p, [TaskStructure::Hierarchy]).once
-	    mock.should_receive(:removed_hook).with(p, c2, [TaskStructure::Hierarchy])
-	    mock.should_receive(:removed_hook).with(c2, p, [TaskStructure::Hierarchy])
-	    mock.should_receive(:removed_hook).with(p, c3, [TaskStructure::Hierarchy])
-	    mock.should_receive(:removed_hook).with(c3, p, [TaskStructure::Hierarchy])
-	    plan.replace_task(c1, c3)
-	end
-
-	# Check that the external task and event structures have been
-	# transferred. 
-	assert( !p.child_object?(c1, TaskStructure::Hierarchy) )
-	assert( p.child_object?(c3, TaskStructure::Hierarchy) )
-	assert( c3.child_object?(c11, TaskStructure::Hierarchy) )
-	assert( !c1.child_object?(c11, TaskStructure::Hierarchy) )
-
-	assert( !c1.event(:stop).child_object?(c2.event(:start), EventStructure::Signal) )
-	assert( c3.event(:stop).child_object?(c2.event(:start), EventStructure::Signal) )
-	assert( c3.event(:success).parent_object?(c11.event(:success), EventStructure::Forwarding) )
-	assert( !c1.event(:success).parent_object?(c11.event(:success), EventStructure::Forwarding) )
-	# Also check that the internal event structure has *not* been transferred
-	assert( !c3.event(:start).child_object?(c3.event(:stop), EventStructure::Forwarding) )
-	assert( c1.event(:start).child_object?(c1.event(:stop), EventStructure::Forwarding) )
-
-	# Check that +c1+ is no more marked as mission, and that c3 is marked. c1 should
-	# still be in the plan
-	assert(! plan.mission?(c1) )
-	assert( plan.mission?(c3) )
-	assert( plan.include?(c1) )
-
-	# Check that #replace_task keeps the permanent flag too
-	(root, p), t = prepare_plan :permanent => 2, :tasks => 1, :model => Roby::Test::SimpleTask
-        root.depends_on p, :model => Roby::Test::SimpleTask
-
-	plan.add_permanent(p)
-	plan.replace_task(p, t)
-	assert(!plan.permanent?(p))
-	assert(plan.permanent?(t))
-    end
-
-    def test_replace
-	(p, c1), (c11, c12, c2, c3) = prepare_plan :missions => 2, :tasks => 4, :model => Roby::Test::SimpleTask
-	p.depends_on c1, :model => Roby::Test::SimpleTask
-	c1.depends_on c11
-	c1.depends_on c12
-	p.depends_on c2
-	c1.signals(:stop, c2, :start)
-	c1.forward_to :start, c1, :stop
-	c11.forward_to :success, c1, :success
-
-	# Replace c1 by c3 and check that the hooks are properly called
-	FlexMock.use do |mock|
-	    p.singleton_class.class_eval do
-		define_method('removed_child_object') do |child, relations|
-		    mock.removed_hook(self, child, relations)
-		end
-	    end
-	    c1.singleton_class.class_eval do
-		define_method('removed_parent_object') do |parent, relations|
-		    mock.removed_hook(self, parent, relations)
-		end
-	    end
-
-	    mock.should_receive(:removed_hook).with(p, c1, [TaskStructure::Hierarchy]).once
-	    mock.should_receive(:removed_hook).with(c1, p, [TaskStructure::Hierarchy]).once
-	    mock.should_receive(:removed_hook).with(p, c2, [TaskStructure::Hierarchy])
-	    mock.should_receive(:removed_hook).with(c2, p, [TaskStructure::Hierarchy])
-	    mock.should_receive(:removed_hook).with(p, c3, [TaskStructure::Hierarchy])
-	    mock.should_receive(:removed_hook).with(c3, p, [TaskStructure::Hierarchy])
-	    plan.replace(c1, c3)
-	end
-
-	# Check that the external task and event structures have been
-	# transferred. 
-	assert( !p.child_object?(c1, TaskStructure::Hierarchy) )
-	assert( p.child_object?(c3, TaskStructure::Hierarchy) )
-	assert( c1.child_object?(c11, TaskStructure::Hierarchy) )
-	assert( !c3.child_object?(c11, TaskStructure::Hierarchy) )
-
-	assert( !c1.event(:stop).child_object?(c2.event(:start), EventStructure::Signal) )
-	assert( c3.event(:stop).child_object?(c2.event(:start), EventStructure::Signal) )
-	assert( c1.event(:success).parent_object?(c11.event(:success), EventStructure::Forwarding) )
-	assert( !c3.event(:success).parent_object?(c11.event(:success), EventStructure::Forwarding) )
-	# Also check that the internal event structure has *not* been transferred
-	assert( !c3.event(:start).child_object?(c3.event(:stop), EventStructure::Forwarding) )
-	assert( c1.event(:start).child_object?(c1.event(:stop), EventStructure::Forwarding) )
-
-	# Check that +c1+ is no more marked as mission, and that c3 is marked. c1 should
-	# still be in the plan
-	assert(! plan.mission?(c1) )
-	assert( plan.mission?(c3) )
-	assert( plan.include?(c1) )
-    end
-
-    def test_remove_task
-	t1, t2, t3 = (1..3).map { Roby::Task.new }
-	t1.depends_on t2
-	t1.signals(:stop, t3, :start)
-
-	plan.add_mission(t1)
-	plan.add_mission(t3)
-
-	assert(!t1.leaf?)
-	plan.remove_object(t2)
-	assert(t1.leaf?)
-	assert(!plan.include?(t2))
-
-	assert(!t1.event(:stop).leaf?(EventStructure::Signal))
-	plan.remove_object(t3)
-	assert(t1.event(:stop).leaf?(EventStructure::Signal))
-	assert(!plan.include?(t3))
-    end
-
-    def test_free_events
-	t1, t2, t3 = (1..3).map { Roby::Task.new }
-	plan.add_mission(t1)
-	t1.depends_on t2
-	assert_equal(plan, t2.plan)
-	assert_equal(plan, t1.event(:start).plan)
-
-	or_generator  = (t1.event(:stop) | t2.event(:stop))
-	assert_equal(plan, or_generator.plan)
-	assert(plan.free_events.include?(or_generator))
-	or_generator.signals t3.event(:start)
-	assert_equal(plan, t3.plan)
-
-	and_generator = (t1.event(:stop) & t2.event(:stop))
-	assert_equal(plan, and_generator.plan)
-	assert(plan.free_events.include?(and_generator))
-    end
-
-    def test_plan_synchronization
-	t1, t2 = prepare_plan :tasks => 2
-	plan.add_mission(t1)
-	assert_equal(plan, t1.plan)
-	assert_equal(nil, t2.plan)
-	t1.depends_on t2
-	assert_equal(plan, t1.plan)
-	assert_equal(plan, t2.plan)
-	assert(plan.include?(t2))
-
-	e = EventGenerator.new(true)
-	assert_equal(nil, e.plan)
-	t1.signals(:start, e, :start)
-	assert_equal(plan, e.plan)
-	assert(plan.free_events.include?(e))
-
-	# Now, make sure a PlanObject don't get included in the plan if add_child_object
-	# raises
-	adding_child_failure = Module.new do
-	    def adding_child_object(child, relation, info)
-		raise RuntimeError
-	    end
-	end
-	model = Class.new(Task) do
-	    include adding_child_failure
-	end
-	t1, t2 = model.new, model.new
-	plan.add_mission(t1)
-	assert_equal(plan, t1.plan)
-	assert_equal(nil, t2.plan)
-	assert_raises(RuntimeError) { t1.depends_on t2 }
-	assert_equal(plan, t1.plan)
-	assert_equal(plan, t2.plan)
-	assert(plan.include?(t2))
-    end
-
-    # Checks that a garbage collected object (event or task) cannot be added back into the plan
-    def test_garbage_collection_final
-	t = SimpleTask.new
-	e = EventGenerator.new(true)
-	plan.real_plan.add [t, e]
-	engine.garbage_collect
-	assert_raises(ArgumentError) { plan.add(t) }
-	assert_raises(ArgumentError) { plan.add(e) }
-    end
-
-    def test_proxy_operator
-        t = SimpleTask.new
-        assert_same t, plan[t, false]
-
-        assert plan.include?(t)
-        assert_same t, plan[t, true]
-
-        plan.remove_object(t)
-        assert_raises(ArgumentError) { plan[t] }
-    end
-end
-
-class TC_Plan < Test::Unit::TestCase
-    include TC_PlanStatic
-
-    def test_transaction_stack
-        assert_equal [plan], plan.transaction_stack
-    end
-end
-