roby 0.7.3 → 0.8.0

data/test/test_exceptions.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 'flexmock'
 require 'roby/test/tasks/simple_task'
@@ -10,7 +10,7 @@ class TC_Exceptions < Test::Unit::TestCase
     class SpecializedError < LocalizedError; end
 
     def test_execution_exception_initialize
-	plan.discover(task = Task.new)
+	plan.add(task = Task.new)
 	error = ExecutionException.new(LocalizedError.new(task))
 	assert_equal(task, error.task)
 	assert_equal([task], error.trace)
@@ -24,7 +24,7 @@ class TC_Exceptions < Test::Unit::TestCase
     end
 
     def test_execution_exception_fork
-	task, t1, t2, t3 = prepare_plan :discover => 5
+	task, t1, t2, t3 = prepare_plan :add => 5
 	e = ExecutionException.new(LocalizedError.new(task))
 	s = e.fork
 
@@ -51,7 +51,7 @@ class TC_Exceptions < Test::Unit::TestCase
 
 	e = ExecutionException.new(LocalizedError.new(task))
 	s = e.fork
-	t1, t2 = prepare_plan :discover => 2
+	t1, t2 = prepare_plan :add => 2
 	s.trace << t1 << t2
 	e.merge(s)
 	assert_equal([task, t2], e.task)
@@ -87,7 +87,7 @@ class TC_Exceptions < Test::Unit::TestCase
 		end
 	    end
 
-	    plan.discover(task  = klass.new)
+	    plan.add(task  = klass.new)
 	    error = ExecutionException.new(SpecializedError.new(task))
 	    mock.should_receive(:handler2).with(error, task, task).once.ordered
 	    mock.should_receive(:handler1).with(error, task, task).once.ordered
@@ -104,8 +104,8 @@ class TC_Exceptions < Test::Unit::TestCase
     def test_exception_in_handler
 	Roby.logger.level = Logger::FATAL
 
-	Roby.control.abort_on_exception = true
-	Roby.control.abort_on_application_exception = false
+	Roby.app.abort_on_exception = true
+	Roby.app.abort_on_application_exception = false
 	FlexMock.use do |mock|
 	    klass = Class.new(SimpleTask) do
 		define_method(:mock) { mock }
@@ -120,19 +120,19 @@ class TC_Exceptions < Test::Unit::TestCase
 		end
 	    end
 
-	    Roby.on_exception(RuntimeError) do |task, exception|
+	    plan.on_exception(RuntimeError) do |task, exception|
 		mock.global_handler_called
 		raise
 	    end
 
 	    t1, t2 = klass.new, klass.new
-	    t1.realized_by t2
-	    plan.insert(t1)
+	    t1.depends_on t2
+	    plan.add_mission(t1)
 
 	    mock.should_receive(:event_called).once.ordered
 	    mock.should_receive(:task_handler_called).once.ordered
 	    mock.should_receive(:global_handler_called).once.ordered
-	    Control.once { t2.start! }
+	    engine.once { t2.start! }
 	    assert_raises(SpecializedError) { process_events }
 	end
     end
@@ -145,28 +145,28 @@ class TC_Exceptions < Test::Unit::TestCase
 		    mock.handler(exception, exception.task, self)
 		end
 	    end.new
-	    plan.discover(t0)
-	    t0.realized_by t1
-	    t1.realized_by t2
+	    plan.add(t0)
+	    t0.depends_on t1
+	    t1.depends_on t2
 
 	    error = ExecutionException.new(SpecializedError.new(t2))
 	    mock.should_receive(:handler).with(error, t1, t0).once
-	    assert_equal([], Propagation.propagate_exceptions([error]))
+	    assert_equal([], engine.propagate_exceptions([error]))
 	    assert_equal([error], error.siblings)
 	    assert_equal([t2, t1], error.trace)
 
 	    error = ExecutionException.new(CodeError.new(nil, t2))
-	    assert_equal([error], Propagation.propagate_exceptions([error]))
+	    assert_equal([error], engine.propagate_exceptions([error]))
 	    assert_equal(t0, error.task)
 	    assert_equal([t2, t1, t0], error.trace)
 
 	    # Redo that but this time define a global exception handler
 	    error = ExecutionException.new(CodeError.new(nil, t2))
-	    Roby.on_exception(CodeError) do |mod, exception|
+	    plan.on_exception(CodeError) do |mod, exception|
 		mock.global_handler(exception, exception.task, mod)
 	    end
-	    mock.should_receive(:global_handler).with(error, t0, Roby).once
-	    assert_equal([], Propagation.propagate_exceptions([error]))
+	    mock.should_receive(:global_handler).with(error, t0, plan).once
+	    assert_equal([], engine.propagate_exceptions([error]))
 	end
     end
 
@@ -175,7 +175,7 @@ class TC_Exceptions < Test::Unit::TestCase
 	# 0 being able to handle the exception and 1, 3 not
 
 	FlexMock.use do |mock|
-	    t1, t2, t3 = prepare_plan :discover => 3
+	    t1, t2, t3 = prepare_plan :add => 3
 	    t0 = Class.new(Task) do 
 		attr_accessor :handled_exception
 		on_exception(CodeError) do |exception|
@@ -183,10 +183,10 @@ class TC_Exceptions < Test::Unit::TestCase
 		    mock.handler(exception, exception.task, self)
 		end
 	    end.new
-	    plan.discover(t0)
-	    t0.realized_by t1
-	    t1.realized_by t2
-	    t3.realized_by t2
+	    plan.add(t0)
+	    t0.depends_on t1
+	    t1.depends_on t2
+	    t3.depends_on t2
 
 	    error = ExecutionException.new(CodeError.new(nil, t2))
 	    mock.should_receive(:handler).with(ExecutionException, t1, t0).once
@@ -196,7 +196,7 @@ class TC_Exceptions < Test::Unit::TestCase
 	    #	   never tested on t3
 	    #	2/ propagation begins with t3, in which case +error+ is a sibling of
 	    #	   t0.handled_exception
-	    assert_equal([], Propagation.propagate_exceptions([error]))
+	    assert_equal([], engine.propagate_exceptions([error]))
 	    assert_equal([t2, t1], t0.handled_exception.trace)
 	    if t0.handled_exception != error
 		assert_equal([t2, t3], error.trace)
@@ -204,7 +204,7 @@ class TC_Exceptions < Test::Unit::TestCase
 	    end
 
 	    error = ExecutionException.new(LocalizedError.new(t2))
-	    assert(fatal = Propagation.propagate_exceptions([error]))
+	    assert(fatal = engine.propagate_exceptions([error]))
 	    assert_equal(1, fatal.size)
 	    e = *fatal
 	    assert_equal(t2, e.origin)
@@ -217,7 +217,7 @@ class TC_Exceptions < Test::Unit::TestCase
 	# 0 being able to handle the exception and 1, 3 not
 
 	FlexMock.use do |mock|
-	    t1, t2, t3 = prepare_plan :discover => 3
+	    t1, t2, t3 = prepare_plan :add => 3
 
 	    found_exception = nil
 	    t0 = Class.new(Task) do 
@@ -226,14 +226,14 @@ class TC_Exceptions < Test::Unit::TestCase
 		    mock.handler(exception, exception.task.to_set, self)
 		end
 	    end.new
-	    plan.discover(t0)
-	    t0.realized_by t1 ; t1.realized_by t2
-	    t0.realized_by t3 ; t3.realized_by t2
+	    plan.add(t0)
+	    t0.depends_on t1 ; t1.depends_on t2
+	    t0.depends_on t3 ; t3.depends_on t2
 	    
 
 	    error = ExecutionException.new(LocalizedError.new(t2))
 	    mock.should_receive(:handler).with(ExecutionException, [t1, t3].to_set, t0).once
-	    assert_equal([], Propagation.propagate_exceptions([error]))
+	    assert_equal([], engine.propagate_exceptions([error]))
 	    assert_equal(2, found_exception.trace.size, found_exception.trace)
 	    assert_equal(t2, found_exception.origin)
 	    assert_equal([t3, t1].to_set, found_exception.task.to_set)
@@ -245,7 +245,7 @@ class TC_Exceptions < Test::Unit::TestCase
 	    raise RuntimeError
 	    ev.emit(context)
 	end
-	plan.discover(ev)
+	plan.add(ev)
 	assert_original_error(RuntimeError, CommandFailed) { ev.call(nil) }
 	assert(!ev.happened?)
 
@@ -254,7 +254,7 @@ class TC_Exceptions < Test::Unit::TestCase
 	    ev.emit(context)
 	    raise RuntimeError
 	end
-	plan.discover(ev)
+	plan.add(ev)
 	assert_original_error(RuntimeError, CommandFailed) { ev.call(nil) }
 	assert(ev.happened?)
 
@@ -263,9 +263,9 @@ class TC_Exceptions < Test::Unit::TestCase
 	    ev.emit(context)
 	    raise RuntimeError
 	end
-	plan.discover(ev)
+	plan.add(ev)
 	ev2 = EventGenerator.new(true)
-	ev.on ev2
+	ev.signals ev2
 
 	assert_original_error(RuntimeError, CommandFailed) { ev.call(nil) }
 	assert(ev.happened?)
@@ -274,7 +274,7 @@ class TC_Exceptions < Test::Unit::TestCase
 	# Check event handlers
 	FlexMock.use do |mock|
 	    ev = EventGenerator.new(true)
-	    plan.discover(ev)
+	    plan.add(ev)
 	    ev.on { mock.handler ; raise RuntimeError }
 	    ev.on { mock.handler }
 	    mock.should_receive(:handler).twice
@@ -284,7 +284,7 @@ class TC_Exceptions < Test::Unit::TestCase
 
     # Tests exception handling mechanism during event propagation
     def test_task_propagation_with_exception
-	Roby.control.abort_on_exception = true
+	Roby.app.abort_on_exception = true
 	Roby.logger.level = Logger::FATAL
 
 	task = Class.new(SimpleTask) do
@@ -303,15 +303,15 @@ class TC_Exceptions < Test::Unit::TestCase
 	    end.new
 	    mock.should_receive(:exception).once
 
-	    parent.realized_by task
-	    plan.insert(parent)
+	    parent.depends_on task
+	    plan.add_mission(parent)
 
-	    Roby::Control.once { task.start! }
+	    engine.once { task.start! }
 
 	    mock.should_receive(:other_once_handler).once
 	    mock.should_receive(:other_event_processing).once
-	    Roby::Control.once { mock.other_once_handler }
-	    Roby::Control.event_processing << lambda { mock.other_event_processing }
+	    engine.once { mock.other_once_handler }
+	    engine.add_propagation_handler { |plan| mock.other_event_processing }
 
 	    begin
 		process_events
@@ -338,15 +338,15 @@ class TC_Exceptions < Test::Unit::TestCase
         end
 
         assert_raises(ArgumentError) do
-            Roby.on_exception(RuntimeError) do ||
+            plan.on_exception(RuntimeError) do ||
             end
         end
         assert_raises(ArgumentError) do |a, b|
-            Roby.on_exception(RuntimeError) do |_|
+            plan.on_exception(RuntimeError) do |_|
             end
         end
         assert_nothing_raised do
-            Roby.on_exception(RuntimeError) do |_, _|
+            plan.on_exception(RuntimeError) do |_, _|
             end
         end
     end
@@ -364,20 +364,20 @@ class TC_Exceptions < Test::Unit::TestCase
 		    mock.caught(exception.task)
 		end
 	    end.new(:id => 'root')
-	    plan.discover(root)
-	    root.realized_by(t11)
-	    root.realized_by(t12)
-	    root.realized_by(t13)
+	    plan.add(root)
+	    root.depends_on(t11)
+	    root.depends_on(t12)
+	    root.depends_on(t13)
 
-	    t11.realized_by(t21 = Task.new(:id => '21'))
-	    t12.realized_by(t21)
+	    t11.depends_on(t21 = Task.new(:id => '21'))
+	    t12.depends_on(t21)
 
-	    t13.realized_by(t22 = Task.new(:id => '22'))
-	    t22.realized_by(t31 = Task.new(:id => '31'))
-	    t31.realized_by(t21)
+	    t13.depends_on(t22 = Task.new(:id => '22'))
+	    t22.depends_on(t31 = Task.new(:id => '31'))
+	    t31.depends_on(t21)
 
 	    mock.should_receive(:caught).once
-	    Propagation.propagate_exceptions([ExecutionException.new(LocalizedError.new(t21))])
+	    engine.propagate_exceptions([ExecutionException.new(LocalizedError.new(t21))])
 	end
     end
 
@@ -388,7 +388,7 @@ class TC_Exceptions < Test::Unit::TestCase
 	end
 
 	# First, check methods located in Plan
-	plan.discover(task = model.new)
+	plan.add(task = model.new)
 	r1, r2 = SimpleTask.new, SimpleTask.new
 
 	task.start!
@@ -416,21 +416,21 @@ class TC_Exceptions < Test::Unit::TestCase
 
     def test_exception_inhibition
 	parent, child = prepare_plan :tasks => 2, :model => SimpleTask
-	plan.insert(parent)
-	parent.realized_by child
-	parent.on :start, child, :start
+	plan.add_mission(parent)
+	parent.depends_on child
+	parent.signals :start, child, :start
 	parent.start!
 	child.failed!
 
-	exceptions = Roby.control.structure_checking
+	exceptions = plan.check_structure
 
-	plan.discover(repairing_task = SimpleTask.new)
+	plan.add(repairing_task = SimpleTask.new)
 	repairing_task.start!
-	assert_equal(exceptions.to_a, Propagation.remove_inhibited_exceptions(exceptions))
-	assert_equal(exceptions.keys, Propagation.propagate_exceptions(exceptions))
+	assert_equal(exceptions.to_a, engine.remove_inhibited_exceptions(exceptions))
+	assert_equal(exceptions.keys, engine.propagate_exceptions(exceptions))
 	plan.add_repair(child.terminal_event, repairing_task)
-	assert_equal([], Propagation.remove_inhibited_exceptions(exceptions))
-	assert_equal([], Propagation.propagate_exceptions(exceptions))
+	assert_equal([], engine.remove_inhibited_exceptions(exceptions))
+	assert_equal([], engine.propagate_exceptions(exceptions))
 
     ensure
 	# Remove the child so that the test's plan cleanup does not complain
@@ -444,8 +444,8 @@ class TC_Exceptions < Test::Unit::TestCase
 	end
 
 	parent, child = prepare_plan :tasks => 2, :model => task_model
-	plan.insert(parent)
-	parent.realized_by child
+	plan.add_mission(parent)
+	parent.depends_on child
 	repairing_task = SimpleTask.new
 	child.event(:failed).handle_with repairing_task
 
@@ -453,20 +453,20 @@ class TC_Exceptions < Test::Unit::TestCase
 	child.start!
 	child.emit error_event
 
-	exceptions = Roby.control.structure_checking
+	exceptions = plan.check_structure
 
-	assert_equal([], Propagation.propagate_exceptions(exceptions))
+	assert_equal([], engine.propagate_exceptions(exceptions))
 	assert_equal({ child.terminal_event => repairing_task },
 		     plan.repairs_for(child.terminal_event), [plan.repairs, child.terminal_event])
 
-	Roby.control.abort_on_exception = false
+	Roby.app.abort_on_exception = false
 	process_events
 	assert(repairing_task.running?)
 
 	# Make the "repair task" finish, but do not repair the plan.
 	# propagate_exceptions must not add a new repair
 	repairing_task.success!
-	assert_equal(exceptions.keys, Propagation.propagate_exceptions(exceptions))
+	assert_equal(exceptions.keys, engine.propagate_exceptions(exceptions))
 
     ensure
 	parent.remove_child child if child
@@ -476,7 +476,7 @@ class TC_Exceptions < Test::Unit::TestCase
 	test_error_handling_relation(:blocked)
     end
 
-    def test_handling_missions_exceptions
+    def test_mission_exceptions
 	mission = prepare_plan :missions => 1, :model => SimpleTask
 	repairing_task = SimpleTask.new
 	mission.event(:failed).handle_with repairing_task
@@ -484,15 +484,15 @@ class TC_Exceptions < Test::Unit::TestCase
 	mission.start!
 	mission.emit :failed
 
-	exceptions = Roby.control.structure_checking
+	exceptions = plan.check_structure
 	assert_equal(1, exceptions.size)
 	assert_kind_of(Roby::MissionFailedError, exceptions.to_a[0][0].exception, exceptions)
 
-	assert_equal([], Propagation.propagate_exceptions(exceptions))
+	assert_equal([], engine.propagate_exceptions(exceptions))
 	assert_equal({ mission.terminal_event => repairing_task },
 		     plan.repairs_for(mission.terminal_event), [plan.repairs, mission.terminal_event])
 
-	Roby.control.abort_on_exception = false
+	Roby.app.abort_on_exception = false
 	process_events
 	assert(plan.mission?(mission))
 	assert(repairing_task.running?)
@@ -500,13 +500,14 @@ class TC_Exceptions < Test::Unit::TestCase
 	# Make the "repair task" finish, but do not repair the plan.
 	# propagate_exceptions must not add a new repair
 	repairing_task.success!
-	assert_equal(exceptions.keys, Propagation.propagate_exceptions(exceptions))
+	assert_equal(exceptions.keys, engine.propagate_exceptions(exceptions))
 
 	# Discard the mission so that the test teardown does not complain
-	plan.discard(mission)
+	plan.unmark_mission(mission)
     end
 
     def test_filter_command_errors
+        Roby.app.filter_backtraces = true
         model = Class.new(SimpleTask) do
             event :start do
                 raise ArgumentError
@@ -565,8 +566,6 @@ class TC_Exceptions < Test::Unit::TestCase
     end
 
     def test_filter_polling_errors
-        #Roby.control.fatal_exceptions = false
-
         model = Class.new(SimpleTask) do
             poll do
                 raise ArgumentError, "bla"
@@ -575,7 +574,7 @@ class TC_Exceptions < Test::Unit::TestCase
 
         parent = prepare_plan :permanent => 1, :model => SimpleTask
         child = prepare_plan :permanent => 1, :model => model
-        parent.realized_by child
+        parent.depends_on child
         parent.start!
         child.start!
         child.failed!

data/test/test_execution_engine.rb

@@ -0,0 +1,987 @@
+$LOAD_PATH.unshift File.expand_path(File.join('..', 'lib'), File.dirname(__FILE__))
+require 'roby/test/common'
+require 'flexmock'
+require 'roby/test/tasks/simple_task'
+require 'roby/test/tasks/empty_task'
+require 'mockups/tasks'
+require 'flexmock'
+require 'utilrb/hash/slice'
+require 'roby/log'
+
+class TC_ExecutionEngine < Test::Unit::TestCase
+    include Roby::Test
+
+    def setup
+	super
+	Roby::Log.add_logger(@finalized_tasks_recorder = FinalizedTaskRecorder.new)
+    end
+    def teardown
+	Roby::Log.remove_logger @finalized_tasks_recorder
+	super
+    end
+
+    def test_gather_propagation
+	e1, e2, e3 = EventGenerator.new(true), EventGenerator.new(true), EventGenerator.new(true)
+	plan.add [e1, e2, e3]
+
+	set = engine.gather_propagation do
+	    e1.call(1)
+	    e1.call(4)
+	    e2.emit(2)
+	    e2.emit(3)
+	    e3.call(5)
+	    e3.emit(6)
+	end
+	assert_equal({ e1 => [nil, [nil, [1], nil, nil, [4], nil]], e2 => [[nil, [2], nil, nil, [3], nil], nil], e3 => [[nil, [6], nil], [nil, [5], nil]] }, set)
+    end
+
+    def test_emission_is_forbidden_outside_propagation_phase
+        # Temporarily disable logging as we are going to generate a fatal error
+        # ..
+        Roby.logger.level = Logger::FATAL
+
+        plan.add_permanent(task = SimpleTask.new)
+
+        error = nil
+        failure = lambda do
+            begin
+                task.emit(:start)
+            rescue Exception => e
+                error = e
+                raise
+            end
+            nil
+        end
+        plan.structure_checks << failure
+
+        engine.run
+        engine.join
+        assert_kind_of(PhaseMismatch, error)
+
+    ensure
+        plan.structure_checks.delete_if { |v| v == failure }
+    end
+
+    def test_propagation_handlers
+        test_obj = Object.new
+        def test_obj.mock_handler(plan)
+            @mockup.called(plan)
+        end
+
+        FlexMock.use do |mock|
+            test_obj.instance_variable_set :@mockup, mock
+            id = engine.add_propagation_handler test_obj.method(:mock_handler)
+
+            mock.should_receive(:called).with(plan).twice
+            process_events
+            process_events
+            engine.remove_propagation_handler id
+            process_events
+        end
+
+        FlexMock.use do |mock|
+            test_obj.instance_variable_set :@mockup, mock
+            id = engine.add_propagation_handler { |plan| mock.called(plan) }
+
+            mock.should_receive(:called).with(plan).twice
+            process_events
+            process_events
+            engine.remove_propagation_handler id
+            process_events
+        end
+
+        assert_raises(ArgumentError) do
+            engine.add_propagation_handler { |plan, failure| mock.called(plan) }
+        end
+
+        assert_nothing_raised { process_events }
+    end
+
+    def test_prepare_propagation
+	g1, g2 = EventGenerator.new(true), EventGenerator.new(true)
+	ev = Event.new(g2, 0, nil)
+
+	step = [nil, [1], nil, nil, [4], nil]
+	source_events, source_generators, context = engine.prepare_propagation(nil, false, step)
+	assert_equal(ValueSet.new, source_events)
+	assert_equal(ValueSet.new, source_generators)
+	assert_equal([1, 4], context)
+
+	step = [nil, [], nil, nil, [4], nil]
+	source_events, source_generators, context = engine.prepare_propagation(nil, false, step)
+	assert_equal(ValueSet.new, source_events)
+	assert_equal(ValueSet.new, source_generators)
+	assert_equal([4], context)
+
+	step = [g1, [], nil, ev, [], nil]
+	source_events, source_generators, context = engine.prepare_propagation(nil, false, step)
+	assert_equal([g1, g2].to_value_set, source_generators)
+	assert_equal([ev].to_value_set, source_events)
+	assert_equal(nil, context)
+
+	step = [g2, [], nil, ev, [], nil]
+	source_events, source_generators, context = engine.prepare_propagation(nil, false, step)
+	assert_equal([g2].to_value_set, source_generators)
+	assert_equal([ev].to_value_set, source_events)
+	assert_equal(nil, context)
+    end
+
+    def test_precedence_graph
+	e1, e2 = EventGenerator.new(true), EventGenerator.new(true)
+	engine.event_ordering << :bla
+	plan.add e1
+	assert(engine.event_ordering.empty?)
+	plan.add e2
+	
+	engine.event_ordering << :bla
+	task = Roby::Task.new
+	plan.add(task)
+	assert(engine.event_ordering.empty?)
+	assert(EventStructure::Precedence.linked?(task.event(:start), task.event(:updated_data)))
+
+	engine.event_ordering << :bla
+	e1.signals e2
+	assert(EventStructure::Precedence.linked?(e1, e2))
+	assert(engine.event_ordering.empty?)
+
+	engine.event_ordering << :bla
+	e1.remove_signal e2
+	assert(engine.event_ordering.empty?)
+	assert(!EventStructure::Precedence.linked?(e1, e2))
+    end
+
+    def test_next_step
+	# For the test to be valid, we need +pending+ to have a deterministic ordering
+	# Fix that here
+	e1, e2 = EventGenerator.new(true), EventGenerator.new(true)
+	plan.add [e1, e2]
+	pending = [ [e1, [true, nil, nil, nil]], [e2, [false, nil, nil, nil]] ]
+	def pending.each_key; each { |(k, v)| yield(k) } end
+	def pending.delete(ev); delete_if { |(k, v)| k == ev } end
+
+	e1.add_precedence e2
+	assert_equal(e1, engine.next_event(pending).first)
+
+	e1.remove_precedence e2
+	e2.add_precedence e1
+	assert_equal(e2, engine.next_event(pending).first)
+    end
+
+    def test_delay
+	FlexMock.use(Time) do |time_proxy|
+	    current_time = Time.now + 5
+	    time_proxy.should_receive(:now).and_return { current_time }
+
+	    plan.add_mission(t = SimpleTask.new)
+	    e = EventGenerator.new(true)
+	    t.event(:start).signals e, :delay => 0.1
+	    engine.once { t.start! }
+	    process_events
+	    assert(!e.happened?)
+	    current_time += 0.1
+	    process_events
+	    assert(e.happened?)
+	end
+    end
+
+    def test_duplicate_signals
+	plan.add_mission(t = SimpleTask.new)
+	
+	FlexMock.use do |mock|
+	    t.on(:start)   { |event| t.emit(:success, *event.context) }
+	    t.on(:start)   { |event| t.emit(:success, *event.context) }
+
+	    t.on(:success) { |event| mock.success(event.context) }
+	    t.on(:stop)    { |event| mock.stop(event.context) }
+	    mock.should_receive(:success).with([42, 42]).once.ordered
+	    mock.should_receive(:stop).with([42, 42]).once.ordered
+	    t.start!(42)
+	end
+    end
+    def test_diamond_structure
+	a = Class.new(SimpleTask) do
+	    event :child_success
+	    event :child_stop
+	    forward :child_success => :child_stop
+	end.new(:id => 'a')
+
+	plan.add_mission(a)
+	a.depends_on(b = SimpleTask.new(:id => 'b'))
+
+	b.forward_to(:success, a, :child_success)
+	b.forward_to(:stop, a, :child_stop)
+
+	FlexMock.use do |mock|
+	    a.on(:child_stop) { mock.stopped }
+	    mock.should_receive(:stopped).once.ordered
+	    a.start!
+	    b.start!
+	    b.success!
+	end
+    end
+
+    def test_signal_forward
+	forward = EventGenerator.new(true)
+	signal  = EventGenerator.new(true)
+	plan.add [forward, signal]
+
+	FlexMock.use do |mock|
+	    sink = EventGenerator.new do |context|
+		mock.command_called(context)
+		sink.emit(42)
+	    end
+	    sink.on { |event| mock.handler_called(event.context) }
+
+	    forward.forward_to sink
+	    signal.signals   sink
+
+	    seed = lambda do
+		forward.call(24)
+		signal.call(42)
+	    end
+	    mock.should_receive(:command_called).with([42]).once.ordered
+	    mock.should_receive(:handler_called).with([42, 24]).once.ordered
+	    engine.propagate_events([seed])
+	end
+    end
+
+    module LogEventGathering
+	class << self
+	    attr_accessor :mockup
+	    def handle(name, obj)
+		mockup.send(name, obj, obj.engine.propagation_sources) if mockup
+	    end
+	end
+
+	def signalling(event, to)
+	    super if defined? super
+	    LogEventGathering.handle(:signalling, self)
+	end
+	def forwarding(event, to)
+	    super if defined? super
+	    LogEventGathering.handle(:forwarding, self)
+	end
+	def emitting(context)
+	    super if defined? super
+	    LogEventGathering.handle(:emitting, self)
+	end
+	def calling(context)
+	    super if defined? super
+	    LogEventGathering.handle(:calling, self)
+	end
+    end
+    EventGenerator.include LogEventGathering
+
+    def test_log_events
+	FlexMock.use do |mock|
+	    LogEventGathering.mockup = mock
+	    dst = EventGenerator.new { }
+	    src = EventGenerator.new { dst.call }
+	    plan.add [src, dst]
+
+	    mock.should_receive(:signalling).never
+	    mock.should_receive(:forwarding).never
+	    mock.should_receive(:calling).with(src, [].to_value_set).once
+	    mock.should_receive(:calling).with(dst, [src].to_value_set).once
+	    src.call
+	end
+
+    ensure 
+	LogEventGathering.mockup = nil
+    end
+
+    def test_add_framework_errors
+	# Shut up the logger in this test
+	Roby.logger.level = Logger::FATAL
+	exception = begin; raise RuntimeError
+		    rescue; $!
+		    end
+
+	Roby.app.abort_on_application_exception = false
+	assert_nothing_raised { engine.add_framework_error(exception, :exceptions) }
+
+	Roby.app.abort_on_application_exception = true
+	assert_raises(RuntimeError) { engine.add_framework_error(exception, :exceptions) }
+    end
+
+    def test_event_loop
+        plan.add_mission(start_node = EmptyTask.new)
+        next_event = [ start_node, :start ]
+        plan.add_mission(if_node    = ChoiceTask.new)
+        start_node.on(:stop) { next_event = [if_node, :start] }
+	if_node.on(:stop) {  }
+            
+        engine.propagation_handlers << lambda do |plan|
+            next unless next_event
+            task, event = *next_event
+            next_event = nil
+            task.event(event).call(nil)
+        end
+        process_events
+        assert(start_node.finished?)
+	
+        process_events
+	assert(if_node.finished?)
+    end
+
+    def test_every
+	# Check that every(cycle_length) works fine
+	engine.run
+
+	samples = []
+	id = engine.every(0.1) do
+	    samples << engine.cycle_start
+	end
+	sleep(1)
+	engine.remove_periodic_handler(id)
+	size = samples.size
+	assert(size > 2, samples.map { |t| t.to_hms })
+
+	samples.each_cons(2) do |a, b|
+	    assert_in_delta(0.1, b - a, 0.001)
+	end
+
+	# Check that no samples have been added after the 'remove_periodic_handler'
+	assert_equal(size, samples.size)
+    end
+
+    def test_once
+	FlexMock.use do |mock|
+	    engine.once { mock.called }
+	    mock.should_receive(:called).once
+	    process_events
+	end
+	FlexMock.use do |mock|
+	    engine.once { mock.called }
+	    mock.should_receive(:called).once
+	    process_events
+	    process_events
+	end
+    end
+
+    def test_failing_once
+	Roby.logger.level = Logger::FATAL
+	Roby.app.abort_on_exception = true
+	engine.run
+
+	FlexMock.use do |mock|
+	    engine.once { mock.called; raise }
+	    mock.should_receive(:called).once
+
+	    assert_raises(ExecutionQuitError) do
+		engine.wait_one_cycle
+		engine.join
+	    end
+	end
+    end
+
+    class SpecificException < RuntimeError; end
+    def test_unhandled_event_exceptions
+	Roby.app.abort_on_exception = true
+
+	# Test that the event is not pending if the command raises
+	model = Class.new(SimpleTask) do
+	    event :start do |context|
+		raise SpecificException, "bla"
+            end
+	end
+	plan.add_permanent(t = model.new)
+
+	assert_original_error(SpecificException, CommandFailed) { t.start! }
+	assert(!t.event(:start).pending?)
+
+	# Check that the propagation is pruned if the command raises
+	t = nil
+	FlexMock.use do |mock|
+	    t = Class.new(SimpleTask) do
+		event :start do |context|
+		    mock.command_called
+		    raise SpecificException, "bla"
+		    emit :start
+                end
+		on(:start) { |ev| mock.handler_called }
+	    end.new
+	    plan.add_permanent(t)
+
+	    mock.should_receive(:command_called).once
+	    mock.should_receive(:handler_called).never
+
+	    engine.once { t.start!(nil) }
+	    assert_original_error(SpecificException, CommandFailed) { process_events }
+	    assert(!t.event(:start).pending)
+	end
+
+	# Check that the task has been garbage collected in the process
+	assert(! plan.include?(t))
+    end
+
+    def apply_check_structure(&block)
+	Plan.structure_checks.clear
+	Plan.structure_checks << lambda(&block)
+	process_events
+    ensure
+	Plan.structure_checks.clear
+    end
+
+    def test_check_structure
+	Roby.logger.level = Logger::FATAL
+	Roby.app.abort_on_exception = false
+
+	# Check on a single task
+	plan.add_mission(t = SimpleTask.new)
+	apply_check_structure { LocalizedError.new(t) }
+	assert(! plan.include?(t))
+
+	# Make sure that a task which has been repaired will not be killed
+	plan.add_mission(t = SimpleTask.new)
+	did_once = false
+	apply_check_structure do
+	    unless did_once
+		did_once = true
+		LocalizedError.new(t)
+	    end
+	end
+	assert(plan.include?(t))
+
+	# Check that whole task trees are killed
+	t0, t1, t2, t3 = prepare_plan :discover => 4
+	t0.depends_on t2
+	t1.depends_on t2
+	t2.depends_on t3
+
+	plan.add_mission(t0)
+	plan.add_mission(t1)
+	FlexMock.use do |mock|
+	    mock.should_receive(:checking).twice
+	    apply_check_structure do
+		mock.checking
+		LocalizedError.new(t2)
+	    end
+	end
+	assert(!plan.include?(t0))
+	assert(!plan.include?(t1))
+	assert(!plan.include?(t2))
+	process_events
+	assert(!plan.include?(t3))
+
+	# Check that we can kill selectively by returning a hash
+	t0, t1, t2 = prepare_plan :discover => 3
+	t0.depends_on t2
+	t1.depends_on t2
+	plan.add_mission(t0)
+	plan.add_mission(t1)
+	apply_check_structure { { LocalizedError.new(t2) => t0 } }
+	assert(!plan.include?(t0))
+	assert(plan.include?(t1))
+	assert(plan.include?(t2))
+    end
+
+    def test_at_cycle_end
+	# Shut up the logger in this test
+	Roby.logger.level = Logger::FATAL
+        Roby.app.abort_on_application_exception = false
+
+        FlexMock.use do |mock|
+            mock.should_receive(:before_error).at_least.once
+            mock.should_receive(:after_error).never
+            mock.should_receive(:called).at_least.once
+
+            engine.at_cycle_end do
+		mock.before_error
+		raise
+		mock.after_error
+            end
+
+            engine.at_cycle_end do
+		mock.called
+		unless engine.quitting?
+		    engine.quit
+		end
+            end
+            engine.run
+            engine.join
+        end
+    end
+
+    def test_inside_outside_control
+	# First, no control thread
+	assert(engine.inside_control?)
+	assert(engine.outside_control?)
+
+	# Add a fake control thread
+	begin
+	    engine.thread = Thread.main
+	    assert(engine.inside_control?)
+	    assert(!engine.outside_control?)
+
+	    t = Thread.new do
+		assert(!engine.inside_control?)
+		assert(engine.outside_control?)
+	    end
+	    t.value
+	ensure
+	    engine.thread = nil
+	end
+
+	# .. and test with the real one
+	engine.run
+	engine.execute do
+	    assert(engine.inside_control?)
+	    assert(!engine.outside_control?)
+	end
+	assert(!engine.inside_control?)
+	assert(engine.outside_control?)
+    end
+
+    def test_execute
+	# Set a fake control thread
+	engine.thread = Thread.main
+
+	FlexMock.use do |mock|
+	    mock.should_receive(:thread_before).once.ordered
+	    mock.should_receive(:main_before).once.ordered
+	    mock.should_receive(:execute).once.ordered.with(Thread.current).and_return(42)
+	    mock.should_receive(:main_after).once.ordered(:finish)
+	    mock.should_receive(:thread_after).once.ordered(:finish)
+
+	    returned_value = nil
+	    t = Thread.new do
+		mock.thread_before
+		returned_value = engine.execute do
+		    mock.execute(Thread.current)
+		end
+		mock.thread_after
+	    end
+
+	    # Wait for the thread to block
+	    while !t.stop?; sleep(0.1) end
+	    mock.main_before
+	    assert(t.alive?)
+	    process_events
+	    mock.main_after
+	    t.join
+
+	    assert_equal(42, returned_value)
+	end
+
+    ensure
+	engine.thread = nil
+    end
+
+    def test_execute_error
+	assert(!engine.thread)
+	# Set a fake control thread
+	engine.thread = Thread.main
+	assert(!engine.quitting?)
+
+	returned_value = nil
+	t = Thread.new do
+	    returned_value = begin
+				 engine.execute do
+				     raise ArgumentError
+				 end
+			     rescue ArgumentError => e
+				 e
+			     end
+	end
+
+	# Wait for the thread to block
+	while !t.stop?; sleep(0.1) end
+	process_events
+	t.join
+
+	assert_kind_of(ArgumentError, returned_value)
+	assert(!engine.quitting?)
+
+    ensure
+	engine.thread = nil
+    end
+    
+    def test_wait_until
+	# Set a fake control thread
+	engine.thread = Thread.main
+
+	plan.add_permanent(task = SimpleTask.new)
+	t = Thread.new do
+	    engine.wait_until(task.event(:start)) do
+		task.start!
+	    end
+	end
+
+	while !t.stop?; sleep(0.1) end
+	process_events
+	assert_nothing_raised { t.value }
+
+    ensure
+	engine.thread = nil
+    end
+ 
+    def test_wait_until_unreachable
+	# Set a fake control thread
+	engine.thread = Thread.main
+
+	plan.add_permanent(task = SimpleTask.new)
+	t = Thread.new do
+	    begin
+		engine.wait_until(task.event(:success)) do
+		    task.start!
+		    task.stop!
+		end
+	    rescue Exception => e
+		e
+	    end
+	end
+
+	while !t.stop?; sleep(0.1) end
+	process_events
+
+	result = t.value
+	assert_kind_of(UnreachableEvent, result)
+	assert_equal(task.event(:success), result.failed_generator)
+
+    ensure
+	engine.thread = nil
+    end
+
+    class CaptureLastStats
+	attr_reader :last_stats
+	def splat?; true end
+        def logs_message?(m); m == :cycle_end end
+        def close; end
+	def cycle_end(time, stats)
+	    @last_stats = stats
+	end
+    end
+    
+    def test_stats
+        require 'roby/log'
+	engine.run
+
+	capture = CaptureLastStats.new
+	Roby::Log.add_logger capture
+
+	time_events = [:real_start, :events, :structure_check, :exception_propagation, :exception_fatal, :garbage_collect, :application_errors, :ruby_gc, :sleep, :end]
+	10.times do
+	    engine.wait_one_cycle
+	    next unless capture.last_stats
+
+	    Roby.synchronize do
+		timepoints = capture.last_stats.slice(*time_events)
+		assert(timepoints.all? { |name, d| d > 0 })
+
+		sorted_by_time = timepoints.sort_by { |name, d| d }
+		sorted_by_name = timepoints.sort_by { |name, d| time_events.index(name) }
+		sorted_by_time.each_with_index do |(name, d), i|
+		    assert(sorted_by_name[i][1] == d)
+		end
+	    end
+	end
+
+    ensure
+	Roby::Log.remove_logger capture if capture
+    end
+
+    def clear_finalized
+        Roby::Log.flush
+        @finalized_tasks_recorder.clear
+    end
+    # Returns the RemoteID for tasks that have been finalized since the last
+    # call to #clear_finalized.
+    def finalized_tasks; @finalized_tasks_recorder.tasks end
+    # Returns the RemoteID for events that have been finalized since the last
+    # call to #clear_finalized.
+    def finalized_events; @finalized_tasks_recorder.events end
+    class FinalizedTaskRecorder
+	attribute(:tasks) { Array.new }
+	attribute(:events) { Array.new }
+        def logs_message?(m); m == :finalized_task || m == :finalized_event end
+	def finalized_task(time, plan, task)
+	    tasks << task
+	end
+	def finalized_event(time, plan, event)
+	    events << event unless event.respond_to?(:task)
+	end
+	def clear
+	    tasks.clear
+	    events.clear
+	end
+        def close; end
+	def splat?; true end
+    end
+
+    def assert_finalizes(plan, unneeded, finalized = nil)
+	finalized ||= unneeded
+	finalized = finalized.map { |obj| obj.remote_id }
+	clear_finalized
+
+	yield if block_given?
+
+	assert_equal(unneeded.to_set, plan.unneeded_tasks.to_set)
+	engine.garbage_collect
+        process_events
+	engine.garbage_collect
+
+        # !!! We are actually relying on the logging queue for this to work.
+        # make sure it is empty before testing anything
+        Roby::Log.flush
+
+	assert_equal(finalized.to_set, (finalized_tasks.to_set | finalized_events.to_set) )
+	assert(! finalized.any? { |t| plan.include?(t) })
+    end
+
+    def test_garbage_collect_tasks
+	klass = Class.new(Task) do
+	    attr_accessor :delays
+
+	    event(:start, :command => true)
+	    event(:stop) do |context|
+		if delays
+		    return
+		else
+		    emit(:stop)
+		end
+            end
+	end
+
+	t1, t2, t3, t4, t5, t6, t7, t8, p1 = (1..9).map { |i| klass.new(:id => i) }
+	t1.depends_on t3
+	t2.depends_on t3
+	t3.depends_on t4
+	t5.depends_on t4
+	t5.planned_by p1
+	p1.depends_on t6
+
+	t7.depends_on t8
+
+	[t1, t2, t5].each { |t| plan.add_mission(t) }
+	plan.add_permanent(t7)
+
+	assert_finalizes(plan, [])
+	assert_finalizes(plan, [t1]) { plan.unmark_mission(t1) }
+	assert_finalizes(plan, [t2, t3]) do
+	    t2.start!(nil)
+	    plan.unmark_mission(t2)
+	end
+	assert_finalizes(plan, [t5, t4, p1, t6], []) do
+	    t5.delays = true
+	    t5.start!(nil)
+	    plan.unmark_mission(t5)
+	end
+	assert(t5.event(:stop).pending?)
+	assert_finalizes(plan, [t5, t4, p1, t6]) do
+	    t5.event(:stop).emit(nil)
+	end
+    end
+    
+    def test_force_garbage_collect_tasks
+	t1 = Class.new(Task) do
+	    event(:stop) { |context| }
+	end.new
+	t2 = Task.new
+	t1.depends_on t2
+
+	plan.add_mission(t1)
+	t1.start!
+	assert_finalizes(plan, []) do
+	    engine.garbage_collect([t1])
+	end
+	assert(t1.event(:stop).pending?)
+
+	assert_finalizes(plan, [t1, t2], [t1, t2]) do
+	    # This stops the mission, which will be automatically discarded
+	    t1.event(:stop).emit(nil)
+	end
+    end
+
+    def test_gc_ignores_incoming_events
+	Roby::Plan.logger.level = Logger::WARN
+	a, b = prepare_plan :discover => 2, :model => SimpleTask
+	a.signals(:stop, b, :start)
+	a.start!
+
+	process_events
+	process_events
+	assert(!a.plan)
+	assert(!b.plan)
+	assert(!b.event(:start).happened?)
+    end
+
+    # Test a setup where there is both pending tasks and running tasks. This
+    # checks that #stop! is called on all the involved tasks. This tracks
+    # problems related to bindings in the implementation of #garbage_collect:
+    # the killed task bound to the Roby.once block must remain the same.
+    def test_gc_stopping
+	Roby::Plan.logger.level = Logger::WARN
+	running_task = nil
+	FlexMock.use do |mock|
+	    task_model = Class.new(Task) do
+		event :start, :command => true
+		event :stop do
+		    mock.stop(self)
+		end
+	    end
+
+	    running_tasks = (1..5).map do
+		task_model.new
+	    end
+
+	    plan.add(running_tasks)
+	    t1, t2 = Roby::Task.new, Roby::Task.new
+	    t1.depends_on t2
+	    plan.add(t1)
+
+	    running_tasks.each do |t|
+		t.start!
+		mock.should_receive(:stop).with(t).once
+	    end
+		
+	    engine.garbage_collect
+	    process_events
+
+	    assert(!plan.include?(t1))
+	    assert(!plan.include?(t2))
+	    running_tasks.each do |t|
+		assert(t.finishing?)
+		t.emit(:stop)
+	    end
+
+	    engine.garbage_collect
+	    running_tasks.each do |t|
+		assert(!plan.include?(t))
+	    end
+	end
+
+    ensure
+	running_task.emit(:stop) if running_task && !running_task.finished?
+    end
+
+    def test_garbage_collect_events
+	t  = SimpleTask.new
+	e1 = EventGenerator.new(true)
+
+	plan.add_mission(t)
+	plan.add(e1)
+	assert_equal([e1], plan.unneeded_events.to_a)
+	t.event(:start).signals e1
+	assert_equal([], plan.unneeded_events.to_a)
+
+	e2 = EventGenerator.new(true)
+	plan.add(e2)
+	assert_equal([e2], plan.unneeded_events.to_a)
+	e1.forward_to e2
+	assert_equal([], plan.unneeded_events.to_a)
+
+	plan.remove_object(t)
+	assert_equal([e1, e2].to_value_set, plan.unneeded_events)
+
+        plan.add_permanent(e1)
+	assert_equal([], plan.unneeded_events.to_a)
+        plan.unmark_permanent(e1)
+	assert_equal([e1, e2].to_value_set, plan.unneeded_events)
+        plan.add_permanent(e2)
+	assert_equal([], plan.unneeded_events.to_a)
+        plan.unmark_permanent(e2)
+	assert_equal([e1, e2].to_value_set, plan.unneeded_events)
+    end
+
+    def test_garbage_collect_weak_relations
+	engine.run
+
+	engine.execute do
+	    planning, planned, influencing = prepare_plan :discover => 3, :model => SimpleTask
+
+	    planned.planned_by planning
+	    influencing.depends_on planned
+	    planning.influenced_by influencing
+
+	    planned.start!
+	    planning.start!
+	    influencing.start!
+	end
+
+	engine.wait_one_cycle
+	engine.wait_one_cycle
+	engine.wait_one_cycle
+
+	assert(plan.known_tasks.empty?)
+    end
+
+    def test_mission_failed
+	model = Class.new(SimpleTask) do
+	    event :specialized_failure, :command => true
+	    forward :specialized_failure => :failed
+	end
+
+	task = prepare_plan :missions => 1, :model => model
+	task.start!
+	task.specialized_failure!
+	
+	error = Roby::Plan.check_failed_missions(plan).first.exception
+	assert_kind_of(Roby::MissionFailedError, error)
+	assert_equal(task.event(:specialized_failure).last, error.failure_point)
+        assert_nothing_raised do
+            Roby.format_exception error
+        end
+
+	# Makes teardown happy
+	plan.remove_object(task)
+    end
+
+    def test_check_relations_structure
+        r_t = TaskStructure.relation :TestRT
+        r_e = EventStructure.relation :TestRE
+
+        FlexMock.use do |mock|
+            r_t.singleton_class.class_eval do
+                define_method :check_structure do |plan|
+                    mock.checked_task_relation(plan)
+                    []
+                end
+            end
+            r_e.singleton_class.class_eval do
+                define_method :check_structure do |plan|
+                    mock.checked_event_relation(plan)
+                    []
+                end
+            end
+
+            plan = Plan.new
+            assert plan.relations.include?(r_t)
+            assert plan.relations.include?(r_e)
+
+            mock.should_receive(:checked_task_relation).with(plan).once
+            mock.should_receive(:checked_event_relation).with(plan).once
+            assert_equal(Hash.new, plan.check_structure)
+        end
+    ensure
+        TaskStructure.remove_relation r_t if r_t
+        EventStructure.remove_relation r_e if r_e
+    end
+
+    def test_forward_signal_ordering
+        100.times do
+            stop_called = false
+            source = SimpleTask.new(:id => 'source')
+            target = Class.new(SimpleTask) do
+                event :start do
+                    if !stop_called
+                        raise ArgumentError, "ordering failed"
+                    end
+                    emit :start
+                end
+            end.new(:id => 'target')
+            plan.add_permanent(source)
+            plan.add_permanent(target)
+
+            source.signals :success, target, :start
+            source.on :stop do
+                stop_called = true
+            end
+            source.start!
+            source.emit :success
+            assert(target.running?)
+            target.stop!
+        end
+    end
+end
+