roby 0.7.3 → 0.8.0

data/test/test_state.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 'roby/state/pos'
 require 'flexmock'
@@ -283,7 +283,7 @@ class TC_State < Test::Unit::TestCase
     def test_pos_delta_event
 	State.pos = Pos::Euler3D.new
 
-	plan.discover(d = State.on_delta(:d => 10))
+	plan.add(d = State.on_delta(:d => 10))
 	assert_kind_of(PosDeltaEvent, d)
 	d.poll
 	assert_equal(State.pos, d.last_value)
@@ -308,7 +308,7 @@ class TC_State < Test::Unit::TestCase
     def test_yaw_delta_event
 	State.pos = Pos::Euler3D.new
 
-	plan.discover(y = State.on_delta(:yaw => 2))
+	plan.add(y = State.on_delta(:yaw => 2))
 	assert_kind_of(YawDeltaEvent, y)
 	y.poll
 	assert_equal(0, y.last_value)
@@ -327,87 +327,105 @@ class TC_State < Test::Unit::TestCase
     end
 
     def test_time_delta_event
-	plan.discover(t = State.on_delta(:t => 3600))
-	assert_kind_of(TimeDeltaEvent, t)
-
-	t.poll
-	assert(!t.happened?)
-	sleep(0.5)
-	t.poll
-	assert(!t.happened?)
-
-	t.instance_variable_set(:@last_value, Time.now - 3600)
-	t.poll
-	assert(1, t.history.size)
+	FlexMock.use(Time) do |time_proxy|
+	    current_time = Time.now + 5
+	    time_proxy.should_receive(:now).and_return { current_time }
+
+	    plan.add(t = State.on_delta(:t => 1))
+	    assert_kind_of(TimeDeltaEvent, t)
+
+	    t.poll
+	    assert(!t.happened?)
+	    current_time += 0.5
+	    t.poll
+	    assert(!t.happened?)
+
+	    current_time += 0.5
+	    t.poll
+	    assert(1, t.history.size)
+
+	    current_time += 0.5
+	    t.poll
+	    assert(1, t.history.size)
+
+	    current_time += 0.5
+	    t.poll
+	    assert(2, t.history.size)
+	end
     end
 
     def test_timepoint_event
-        plan.discover(ev = State.at(:t => Time.now + 0.5))
-        ev.poll
-        assert(!ev.happened?)
-        sleep(0.5)
-        ev.poll
-        assert(ev.happened?)
-        sleep(0.5)
-        ev.poll
-        assert_equal(1, ev.history.size)
+	FlexMock.use(Time) do |time_proxy|
+	    current_time = Time.now + 5
+	    time_proxy.should_receive(:now).and_return { current_time }
+
+	    plan.add(ev = State.at(:t => current_time + 1))
+	    ev.poll
+	    assert(!ev.happened?)
+	    current_time += 1
+	    ev.poll
+	    assert(ev.happened?)
+	    current_time += 1
+	    ev.poll
+	    assert_equal(1, ev.history.size)
+	end
     end
 
     def test_and_state_events
 	State.pos = Pos::Euler3D.new
-	plan.discover(ev = State.on_delta(:yaw => 2, :d => 10))
+	plan.add_permanent(ev = State.on_delta(:yaw => 2, :d => 10))
 	assert_kind_of(AndGenerator, ev)
 
-	Roby.poll_state_events
+	engine.process_events
 	assert_equal(0, ev.history.size)
 
 	State.pos.yaw = 1
 	State.pos.x = 15
-	Roby.poll_state_events
+	engine.process_events
 	assert_equal(0, ev.history.size)
 
 	State.pos.yaw = 2
-	Roby.poll_state_events
+	engine.process_events
 	assert_equal(1, ev.history.size)
 
 	State.pos.yaw = 3
 	State.pos.x = 25
-	Roby.poll_state_events
+	engine.process_events
 	assert_equal(1, ev.history.size)
 
 	State.pos.yaw = 4
-	Roby.poll_state_events
+	engine.process_events
 	assert_equal(2, ev.history.size, ev.waiting.to_a)
     end
 
     def test_or_state_events
 	State.pos = Pos::Euler3D.new
-	plan.discover(y = State.on_delta(:yaw => 2))
+	plan.add_permanent(y = State.on_delta(:yaw => 2))
 
 	ev = y.or(:d => 10)
-	Roby.poll_state_events
+	engine.process_events
 	assert_equal(0, ev.history.size)
 
 	State.pos.yaw = 1
 	State.pos.x = 15
-	Roby.poll_state_events
+	engine.process_events
 	assert_equal(1, ev.history.size)
 
 	State.pos.yaw = 2
-	Roby.poll_state_events
+	engine.process_events
 	assert_equal(1, ev.history.size)
 
 	State.pos.yaw = 3
-	Roby.poll_state_events
+	engine.process_events
 	assert_equal(2, ev.history.size)
 
 	ev = ev.or(:t => 3600)
-	Roby.poll_state_events
+	engine.process_events
 	assert_equal(0, ev.history.size)
 
 	time_event = plan.free_events.find { |t| t.kind_of?(TimeDeltaEvent) }
 	time_event.instance_variable_set(:@last_value, Time.now - 3600)
-	Roby.poll_state_events
+	engine.process_events
 	assert_equal(1, ev.history.size)
     end
 end

data/test/test_support.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/support'

data/test/test_task.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 'roby/test/tasks/simple_task'
 require 'roby/test/tasks/empty_task'
@@ -6,40 +6,100 @@ require 'flexmock'
 
 class TC_Task < Test::Unit::TestCase 
     include Roby::Test
+    def setup
+        super
+        Roby.app.filter_backtraces = false
+    end
 
     def test_model_tag
-	my_tag = TaskModelTag.new do
-	    argument :model_tag
-	end
-	assert(my_tag.const_defined?(:ClassExtension))
-	assert(my_tag::ClassExtension.method_defined?(:argument))
+        tag1 = TaskModelTag.new { argument :model_tag_1 }
+	assert(tag1.const_defined?(:ClassExtension))
+	assert(tag1::ClassExtension.method_defined?(:argument))
+
+	tag2 = TaskModelTag.new do
+            include tag1
+            argument :model_tag_2
+        end
+	assert(tag2 < tag1)
+	assert(tag2.const_defined?(:ClassExtension))
+	assert(tag2::ClassExtension.method_defined?(:argument))
+
 	task = Class.new(Task) do
-	    include my_tag
+	    include tag2
 	    argument :task_tag
 	end
-	assert_equal([:task_tag, :model_tag].to_set, task.arguments.to_set)
+	assert_equal([:task_tag, :model_tag_2, :model_tag_1].to_set, task.arguments.to_set)
     end
 
-    def test_arguments
-	model = Class.new(Task) do
-	    arguments :from, :to
-	end
-	plan.discover(task = model.new(:from => 'B', :useless => 'bla'))
+    def test_arguments_declaration
+	model = Class.new(Task) { arguments :from, :to }
 	assert_equal([], Task.arguments.to_a)
-	assert_equal([:from, :to].to_value_set, task.model.arguments.to_value_set)
-	assert_equal({:from => 'B', :useless => 'bla'}, task.arguments)
-	assert_equal({:from => 'B'}, task.meaningful_arguments)
+	assert_equal([:from, :to].to_value_set, model.arguments.to_value_set)
+    end
 
-	assert(task.partially_instanciated?)
-	task.arguments[:to] = 'A'
-	assert_equal('A', task.arguments[:to])
-	assert(!task.partially_instanciated?)
-	assert_raises(ArgumentError) { task.arguments[:to] = 10 }
+    def test_arguments_initialization
+	model = Class.new(Task) { arguments :arg, :to }
+	plan.add(task = model.new(:arg => 'B'))
+	assert_equal({:arg => 'B'}, task.arguments)
+        assert_equal('B', task.arg)
+        assert_equal(nil, task.to)
+    end
+
+    def test_arguments_initialization_uses_assignation_operator
+	model = Class.new(Task) do
+            arguments :arg, :to
+
+            def arg=(value)
+                arguments[:assigned] = true
+                arguments[:arg] = value
+            end
+        end
+
+	plan.add(task = model.new(:arg => 'B'))
+	assert_equal({:arg => 'B', :assigned => true}, task.arguments)
+    end
+
+    def test_arguments_assignation
+	model = Class.new(Task) { arguments :arg }
+	plan.add(task = model.new)
+	task.arguments[:arg] = 'A'
+        assert_equal('A', task.arg)
+        assert_equal({ :arg => 'A' }, task.arguments)
+    end
+    
+    def test_arguments_assignation_operator
+	model = Class.new(Task) { arguments :arg }
+	plan.add(task = model.new)
+        task.arg = 'B'
+        assert_equal('B', task.arg)
+        assert_equal({ :arg => 'B' }, task.arguments)
+    end
 
+    def test_meaningful_arguments
+	model = Class.new(Task) { arguments :arg }
+	plan.add(task = model.new(:arg => 'B', :useless => 'bla'))
+	assert_equal({:arg => 'B', :useless => 'bla'}, task.arguments)
+	assert_equal({:arg => 'B'}, task.meaningful_arguments)
+    end
+
+    def test_arguments_cannot_override
+	model = Class.new(Task) { arguments :arg }
+	plan.add(task = model.new(:arg => 'B', :useless => 'bla'))
+	assert_raises(ArgumentError) { task.arg = 10 }
+
+        # But we can override non-meaningful arguments
 	task.arguments[:bar] = 42
 	assert_nothing_raised { task.arguments[:bar] = 43 }
     end
 
+    def test_arguments_partially_instanciated
+	model = Class.new(Task) { arguments :arg0, :arg1 }
+	plan.add(task = model.new(:arg0 => 'B', :useless => 'bla'))
+	assert(task.partially_instanciated?)
+        task.arg1 = 'C'
+	assert(!task.partially_instanciated?)
+    end
+
     def test_command_block
 	FlexMock.use do |mock|
 	    model = Class.new(SimpleTask) do 
@@ -48,7 +108,7 @@ class TC_Task < Test::Unit::TestCase
 		    emit :start
 		end
 	    end
-	    plan.insert(task = model.new)
+	    plan.add_mission(task = model.new)
 	    mock.should_receive(:start).once.with(task, [42])
 	    task.start!(42)
 	end
@@ -70,53 +130,97 @@ class TC_Task < Test::Unit::TestCase
                 end
             end
 
-            plan.insert(task = child_m.new)
+            plan.add_mission(task = child_m.new)
             mock.should_receive(:parent_started).once.with(task, 21)
             mock.should_receive(:child_started).once.with(task, 42)
             task.start!(42)
         end
     end
 
-    Precedence = Roby::EventStructure::Precedence
-    def assert_direct_precedence(task, relations)
-	relations.each do |from, to|
-	    from = task.event(from)
-	    to   = to.map { |sym| task.event(sym) }
+    def assert_task_relation_set(task, relation, expected)
+        plan.add(task)
+        task.each_event do |from|
+            task.each_event do |to|
+                next if from == to
+                exp = expected[from.symbol]
+                if exp == to.symbol || (exp.respond_to?(:include?) && exp.include?(to.symbol))
+                    assert from.child_object?(to, relation), "expected relation #{from} => #{to} in #{relation} is missing"
+                else
+                    assert !from.child_object?(to, relation), "unexpected relation #{from} => #{to} found in #{relation}"
+                end
+            end
+        end
+    end
 
-	    assert_equal(to.to_value_set, from.child_objects(Precedence).to_value_set, from.symbol)
+    def do_test_instantiate_model_relations(method, relation, additional_links = Hash.new)
+	klass = Class.new(Roby::Test::SimpleTask) do
+            4.times { |i| event "e#{i + 1}", :command => true }
+            send(method, :e1 => [:e2, :e3], :e4 => :stop)
 	end
+
+        plan.add(task = klass.new)
+        expected_links = Hash[:e1 => [:e2, :e3], :e4 => :stop]
+        
+        assert_task_relation_set task, relation, expected_links.merge(additional_links)
+    end
+    def test_instantiate_model_signals
+        do_test_instantiate_model_relations(:signal, EventStructure::Signal)
+    end
+    def test_instantiate_deprecated_model_on
+        deprecated_feature do
+            do_test_instantiate_model_relations(:on, EventStructure::Signal)
+        end
+    end
+    def test_instantiate_model_forward
+        do_test_instantiate_model_relations(:forward, EventStructure::Forwarding,
+                           :success => :stop, :aborted => :failed, :failed => :stop)
+    end
+    def test_instantiate_model_causal_links
+        do_test_instantiate_model_relations(:causal_link, EventStructure::CausalLink,
+                           :success => :stop, :aborted => :failed, :failed => :stop)
     end
 
-    def test_instantiate_model_event_relations
-	# Create a task model with two intermediate events being
-	# linked by a causal link
-	task = Class.new(Roby::Test::SimpleTask) do
-	    event :first
-	    event :second
-	    event :third
-	    causal_link :first => :third
-	    causal_link :second => :third
-	end.new
-	plan.discover(task)
+    
+    def do_test_inherit_model_relations(method, relation, additional_links = Hash.new)
+	base = Class.new(Roby::Test::SimpleTask) do
+            4.times { |i| event "e#{i + 1}", :command => true }
+            send(method, :e1 => [:e2, :e3])
+	end
+        subclass = Class.new(base) do
+            send(method, :e4 => :stop)
+        end
 
-	assert_direct_precedence task, 
-	    :start => [:first, :second, :updated_data],
-	    :first => [:third],
-	    :second => [:third],
-	    :third => [:success, :aborted],
-	    :aborted => [:failed],
-	    :failed => [:stop],
-	    :success => [:stop]
+        task = base.new
+        assert_task_relation_set task, relation,
+            Hash[:e1 => [:e2, :e3]].merge(additional_links)
 
+        task = subclass.new
+        assert_task_relation_set task, relation,
+            Hash[:e1 => [:e2, :e3], :e4 => :stop].merge(additional_links)
+    end
+    def test_inherit_model_signals
+        do_test_inherit_model_relations(:signal, EventStructure::Signal)
+    end
+    def test_inherit_deprecated_model_on
+        deprecated_feature do
+            do_test_inherit_model_relations(:on, EventStructure::Signal)
+        end
+    end
+    def test_inherit_model_forward
+        do_test_inherit_model_relations(:forward, EventStructure::Forwarding,
+                           :success => :stop, :aborted => :failed, :failed => :stop)
+    end
+    def test_inherit_model_causal_links
+        do_test_inherit_model_relations(:causal_link, EventStructure::CausalLink,
+                           :success => :stop, :aborted => :failed, :failed => :stop)
     end
 
     # Test the behaviour of Task#on, and event propagation inside a task
-    def test_instance_on
-	plan.discover(t1 = SimpleTask.new)
+    def test_instance_event_handlers
+	plan.add(t1 = SimpleTask.new)
 	assert_raises(ArgumentError) { t1.on(:start) }
 	
-	# Test command handlers
-	plan.discover(task = SimpleTask.new)
+	plan.add(task = SimpleTask.new)
 	FlexMock.use do |mock|
 	    task.on(:start)   { |event| mock.started(event.context) }
 	    task.on(:start)   { |event| task.emit(:success, *event.context) }
@@ -130,38 +234,64 @@ class TC_Task < Test::Unit::TestCase
         assert(task.finished?)
 	event_history = task.history.map { |ev| ev.generator }
 	assert_equal([task.event(:start), task.event(:success), task.event(:stop)], event_history)
+    end
 
-	# Same test, but with signals
+    def test_instance_signals
 	FlexMock.use do |mock|
-	    t1, t2 = prepare_plan :discover => 2, :model => SimpleTask
-	    t1.on(:start, t2)
-	    t2.on(:start) { mock.start }
+	    t1, t2 = prepare_plan :add => 3, :model => SimpleTask
+            t1.signals(:start, t2, :start)
 
-	    mock.should_receive(:start).once
+            t2.on(:start) { mock.start }
+            mock.should_receive(:start).once
 	    t1.start!
 	end
+    end
 
+    def test_instance_signals_deprecated_default_event_name
 	FlexMock.use do |mock|
-	    t1, t2 = prepare_plan :discover => 2, :model => SimpleTask
-	    t2.start!
+	    t1, t2 = prepare_plan :add => 3, :model => SimpleTask
+            deprecated_feature do
+                t1.on(:start, t2)
+            end
 
-	    t1.on(:start, t2, :stop)
-	    t2.on(:start) { mock.start }
-	    t2.on(:stop)  { mock.stop }
+            t2.on(:start) { mock.start }
+            mock.should_receive(:start).once
+	    t1.start!
+	end
+    end
 
-	    mock.should_receive(:start).never
-	    mock.should_receive(:stop).once
+    def test_instance_signals_deprecated_on_usage
+	FlexMock.use do |mock|
+	    t1, t2 = prepare_plan :add => 3, :model => SimpleTask
+            deprecated_feature do
+                t1.on(:start, t2, :start)
+            end
+
+            t2.on(:start) { mock.start }
+            mock.should_receive(:start).once
 	    t1.start!
 	end
+    end
 
+    def test_instance_signals_plain_events
 	t = prepare_plan :missions => 1, :model => SimpleTask
 	e = EventGenerator.new(true)
-	t.on(:start, e)
+	t.signals(:start, e)
 	t.start!
 	assert(e.happened?)
     end
 
-    def test_model_event_handling
+    def test_instance_signals_plain_events_deprecated_on_usage
+	t = prepare_plan :missions => 1, :model => SimpleTask
+	e = EventGenerator.new(true)
+        deprecated_feature do
+            t.on(:start, e)
+        end
+	t.start!
+	assert(e.happened?)
+    end
+
+    def test_model_forwardings
 	model = Class.new(SimpleTask) do
 	    forward :start => :failed
 	end
@@ -169,10 +299,20 @@ class TC_Task < Test::Unit::TestCase
 	assert_equal({}, SimpleTask.signal_sets)
 
 	assert_equal([:failed, :stop].to_value_set, model.forwardings(:start))
-	assert_equal([:stop].to_value_set, model.forwardings(:failed))
-	assert_equal(model.forwardings(:failed), model.enum_for(:each_forwarding, :failed).to_value_set)
+	assert_equal([:stop].to_value_set,          model.forwardings(:failed))
+	assert_equal([:stop].to_value_set,          model.enum_for(:each_forwarding, :failed).to_value_set)
+
+        plan.add(task = model.new)
+        task.start!
 
-        # Event handlers must accept exactly one argument
+	# Make sure the model-level relation is not applied to parent models
+	plan.add(task = SimpleTask.new)
+	task.start!
+	assert(!task.failed?)
+    end
+
+    def test_model_event_handlers
+	model = Class.new(SimpleTask)
         assert_raises(ArgumentError) { model.on(:start) { || } }
         assert_raises(ArgumentError) { model.on(:start) { |a, b| } }
 
@@ -180,42 +320,29 @@ class TC_Task < Test::Unit::TestCase
 	    model.on :start do
 		mock.start_called(self)
 	    end
-	    plan.discover(task = model.new)
+	    plan.add(task = model.new)
 	    mock.should_receive(:start_called).with(task).once
 	    task.start!
-	    assert(task.failed?)
-	end
 
-	# Make sure the model-level signal is not applied to parent models
-	plan.discover(task = SimpleTask.new)
-	task.start!
-	assert(!task.failed?)
+            # Make sure the model-level handler is not applied to parent models
+            plan.add(task = SimpleTask.new)
+            task.start!
+            assert(!task.failed?)
+	end
     end
 
-    def test_forward
+    def test_instance_forward_to
 	FlexMock.use do |mock|
 	    t1, t2 = prepare_plan :missions => 2, :model => SimpleTask
-	    t1.forward(:start, t2)
+	    t1.forward_to(:start, t2, :start)
 	    t2.on(:start) { mock.start }
 
 	    mock.should_receive(:start).once
 	    t1.start!
 	end
+    end
 
-	FlexMock.use do |mock|
-	    t1, t2 = prepare_plan :missions => 2, :model => SimpleTask
-	    t2.start!
-
-	    t1.forward(:start, t2, :stop)
-	    t2.on(:start) { mock.start }
-	    t2.on(:stop) { mock.stop }
-
-	    mock.should_receive(:start).never
-	    mock.should_receive(:stop).once
-	    t1.start!
-	end
-
-
+    def test_instance_forward_to_plain_events
 	FlexMock.use do |mock|
 	    t1 = prepare_plan :missions => 1, :model => SimpleTask
 	    ev = EventGenerator.new do 
@@ -223,7 +350,7 @@ class TC_Task < Test::Unit::TestCase
 		ev.emit
 	    end
 	    ev.on { mock.emitted }
-	    t1.forward(:start, ev)
+	    t1.forward_to(:start, ev)
 
 	    mock.should_receive(:called).never
 	    mock.should_receive(:emitted).once
@@ -231,68 +358,78 @@ class TC_Task < Test::Unit::TestCase
 	end
     end
 
-    def test_terminal
+    def test_terminal_option
 	klass = Class.new(Task) do
-	    event(:terminal_model, :terminal => true)
-	    event(:terminal_model_signal)
-	    forward :terminal_model_signal => :terminal_model
-
-	    event(:success_model, :terminal => true)
-	    event(:success_model_signal)
-	    forward :success_model_signal => :success
-	    forward :success_model_signal => :success_model
-
-	    event(:failure_model, :terminal => true)
-	    event(:failure_model_signal)
-	    forward :failure_model_signal => :failed
-	    forward :failure_model_signal => :failure_model
-
-	    event(:ev)
-            event :controlable_terminal, :terminal => true, :command => true
+            event :terminal, :terminal => true
+        end
+        assert klass.event_model(:terminal).terminal?
+        plan.add(task = klass.new)
+        assert task.event(:terminal).terminal?
+        assert task.event(:terminal).child_object?(task.event(:stop), EventStructure::Forwarding)
+    end
+
+    def test_terminal_direct_forward_in_model
+	klass = Class.new(Task) do
+	    event :terminal
+	    forward :terminal => :stop
+	end
+        assert klass.event_model(:terminal).terminal?
+        plan.add(task = klass.new)
+        assert task.event(:terminal).terminal?
+    end
+
+    def test_terminal_indirect_forward_in_model
+	klass = Class.new(Task) do
+	    event :terminal
+            event :intermediate
+
+            forward :intermediate => :failed
+	    forward :terminal => :intermediate
 	end
-	assert(klass.event_model(:stop).terminal?)
-	assert(klass.event_model(:success).terminal?)
-	assert(klass.event_model(:failed).terminal?)
-	assert(klass.event_model(:terminal_model).terminal?)
-	assert(klass.event_model(:terminal_model_signal).terminal?)
-
-	plan.discover(task = klass.new)
-	assert(task.event(:stop).terminal?)
-	assert(!task.event(:stop).success?)
-	assert(!task.event(:stop).failure?)
-	assert(task.event(:success).terminal?)
-	assert(task.event(:success).success?)
-	assert(!task.event(:success).failure?)
-	assert(task.event(:failed).terminal?)
-	assert(!task.event(:failed).success?)
-	assert(task.event(:failed).failure?)
-
-	ev = task.event(:ev)
-	assert(!ev.terminal?)
-	assert(!ev.success?)
-	assert(!ev.failure?)
-	ev.forward task.event(:terminal_model_signal)
-	assert(ev.terminal?)
-	assert(!ev.success?)
-	assert(!ev.failure?)
-	ev.forward task.event(:success_model_signal)
-	assert(ev.terminal?)
-	assert(ev.success?)
-	assert(!ev.failure?)
-	ev.remove_forwarding task.event(:success_model_signal)
-	ev.forward task.event(:failure_model_signal)
-	assert(ev.terminal?)
-	assert(!ev.success?)
-	assert(ev.failure?)
-
-	ev.remove_forwarding task.event(:failure_model_signal)
-	ev.remove_forwarding task.event(:terminal_model_signal)
-	assert(!ev.terminal?)
-	ev.forward task.event(:failure_model_signal), :delay => 0.2
-	assert(!ev.terminal?)
-	ev.remove_forwarding task.event(:failure_model_signal)
-	ev.signal task.event(:controlable_terminal), :delay => 0.2
-	assert(!ev.terminal?)
+        assert klass.event_model(:terminal).terminal?
+        plan.add(task = klass.new)
+        assert task.event(:terminal).terminal?
+    end
+
+    def test_terminal_direct_signal_in_model
+	klass = Class.new(SimpleTask) do
+	    event :terminal
+	    signal :terminal => :stop
+	end
+        assert klass.event_model(:terminal).terminal?
+        plan.add(task = klass.new)
+        assert task.event(:terminal).terminal?
+    end
+
+    def test_terminal_indirect_signal_in_model
+	klass = Class.new(Task) do
+	    event :terminal
+            event :intermediate, :command => true
+
+	    signal :terminal => :intermediate
+            forward :intermediate => :failed
+	end
+        assert klass.event_model(:terminal).terminal?
+        plan.add(task = klass.new)
+        assert task.event(:terminal).terminal?
+    end
+
+    def test_should_not_establish_signal_from_terminal_to_non_terminal
+	klass = Class.new(Task) do
+	    event :terminal, :terminal => true
+            event :intermediate
+	end
+        assert_raises(ArgumentError) { klass.forward :terminal => :intermediate }
+        klass.new
+    end
+
+    def test_should_not_establish_signal_from_terminal_to_non_terminal
+	klass = Class.new(Task) do
+	    event :terminal, :terminal => true
+            event :intermediate, :command => true
+	end
+        assert_raises(ArgumentError) { klass.signal :terminal => :intermediate }
+        klass.new
     end
 
     # Tests Task::event
@@ -312,8 +449,9 @@ class TC_Task < Test::Unit::TestCase
 
 	klass.event :ev_terminal, :terminal => true, :command => true
 
-	plan.discover(task = klass.new)
+	plan.add(task = klass.new)
 	assert_respond_to(task, :start!)
+        assert_respond_to(task, :start?)
 
         # Test modifications to the class hierarchy
         my_event = nil
@@ -349,7 +487,7 @@ class TC_Task < Test::Unit::TestCase
         # Check validation of options[:command]
         assert_raise(ArgumentError) { klass.event :try_event, :command => "bla" }
 
-        plan.discover(task = EmptyTask.new)
+        plan.add(task = EmptyTask.new)
 	start_event = task.event(:start)
 
         assert_equal(start_event, task.event(:start))
@@ -371,7 +509,7 @@ class TC_Task < Test::Unit::TestCase
 		failed!
 	    end
 	end.new
-	plan.discover(task)
+	plan.add(task)
 
 	assert(task.pending?)
 	assert(!task.starting?)
@@ -437,7 +575,7 @@ class TC_Task < Test::Unit::TestCase
 
 		on(:stop)  { |event| mock.stopped(event.context) }
 	    end
-	    plan.insert(task = model.new)
+	    plan.add_mission(task = model.new)
 
 	    mock.should_receive(:starting).with([42]).once
 	    mock.should_receive(:started).with([42]).once
@@ -488,7 +626,7 @@ class TC_Task < Test::Unit::TestCase
 	ev_models = Hash[*model.enum_for(:each_event).to_a.flatten]
 	assert_equal([:start, :success, :aborted, :updated_data, :stop, :failed, :inter].to_set, ev_models.keys.to_set)
 
-	plan.discover(task = model.new)
+	plan.add(task = model.new)
 	ev_models = Hash[*task.model.enum_for(:each_event).to_a.flatten]
 	assert_equal([:start, :success, :aborted, :updated_data, :stop, :failed, :inter].to_set, ev_models.keys.to_set)
 	assert( ev_models[:start].symbol )
@@ -499,7 +637,7 @@ class TC_Task < Test::Unit::TestCase
 	model = Class.new(SimpleTask) do
 	    event(:inter, :command => true)
 	end
-	plan.discover(task = model.new)
+	plan.add(task = model.new)
 
 	assert_raises(CommandFailed) { task.inter! }
 	assert_raises(EmissionFailed) { task.emit(:inter) }
@@ -523,7 +661,7 @@ class TC_Task < Test::Unit::TestCase
 		emit :inter
             end
 	end
-	plan.discover(task = model.new)
+	plan.add(task = model.new)
 	assert_nothing_raised { task.start! }
     end
 
@@ -535,7 +673,7 @@ class TC_Task < Test::Unit::TestCase
 	    event :stop, :command => true
 	end
 
-	plan.discover(task = model.new)
+	plan.add(task = model.new)
 	task.start!
 	task.emit(:stop)
 	assert(!task.success?)
@@ -543,7 +681,7 @@ class TC_Task < Test::Unit::TestCase
 	assert(task.finished?)
 	assert_equal(task.event(:stop).last, task.terminal_event)
 
-	plan.discover(task = model.new)
+	plan.add(task = model.new)
 	task.start!
 	task.emit(:success)
 	assert(task.success?)
@@ -551,7 +689,7 @@ class TC_Task < Test::Unit::TestCase
 	assert(task.finished?)
 	assert_equal(task.event(:success).last, task.terminal_event)
 
-	plan.discover(task = model.new)
+	plan.add(task = model.new)
 	task.start!
 	task.emit(:failed)
 	assert(!task.success?)
@@ -565,7 +703,7 @@ class TC_Task < Test::Unit::TestCase
         flunk 'no exception raised'
     rescue klass => e
         unless msg === e.message
-            flunk "exception message '#{e.message}' does not match the expected pattern"
+            flunk "exception message '#{e.message}' does not match the expected pattern #{msg}"
         end
     rescue Exception => e
         flunk "expected an exception of class #{klass} but got #{e.full_message}"
@@ -581,9 +719,7 @@ class TC_Task < Test::Unit::TestCase
 	assert_raises(EventNotExecutable) { task.start! }
 	assert_raises(EventNotExecutable) { task.event(:start).call }
 
-
-
-	plan.discover(task)
+	plan.add(task)
 	assert(task.executable?)
 	assert_nothing_raised { task.event(:start).call(nil) }
 
@@ -591,7 +727,7 @@ class TC_Task < Test::Unit::TestCase
 	assert_raises(ModelViolation) { task.executable = false }
 
 	task = SimpleTask.new
-	plan.insert(task)
+	plan.add_mission(task)
 	assert(task.executable?)
 	task.executable = false
 	assert(!task.executable?)
@@ -599,7 +735,7 @@ class TC_Task < Test::Unit::TestCase
 	assert(task.executable?)
 
 	task = SimpleTask.new
-	plan.permanent(task)
+	plan.add_permanent(task)
 	assert(task.executable?)
 	task.executable = false
 	assert(!task.executable?)
@@ -639,11 +775,11 @@ class TC_Task < Test::Unit::TestCase
 	if check_signaling then
 	    error = yield
 	    assert_exception_message(EventNotExecutable, substring) do
-	       exception_propagator(error, :on)
+	       exception_propagator(error, :signals)
 	    end
 	    error = yield
 	    assert_exception_message(EventNotExecutable, substring) do
-	       exception_propagator(error, :forward)
+	       exception_propagator(error, :forward_to)
 	    end
 	end
     end
@@ -651,7 +787,7 @@ class TC_Task < Test::Unit::TestCase
     def test_exception_refinement
 	# test for partially instanciation
 	check_direct_start(/partially instanciated/,true) do
-	   plan.discover(task = ParameterizedTask.new)
+	   plan.add(task = ParameterizedTask.new)
 	   task
 	end
 
@@ -662,21 +798,21 @@ class TC_Task < Test::Unit::TestCase
         
         #test for an abstract task
         check_direct_start(/abstract/,true) do
-            plan.discover(task = AbstractTask.new)
+            plan.add(task = AbstractTask.new)
             task
 	end
 	
 	#test for a not executable plan
 	erroneous_plan = NotExecutablePlan.new	
 	check_direct_start(/plan is not executable/,false) do
-	   erroneous_plan.discover(task = SimpleTask.new)
+	   erroneous_plan.add(task = SimpleTask.new)
 	   task
 	end
-        erroneous_plan.garbage_collect	
+        erroneous_plan.clear
         
         #test for a not executable task
         check_direct_start(/is not executable/,true) do
-            plan.discover(task = SimpleTask.new)
+            plan.add(task = SimpleTask.new)
             task.executable = false
             task
 	end
@@ -686,7 +822,7 @@ class TC_Task < Test::Unit::TestCase
 
     def test_task_success_failure
 	FlexMock.use do |mock|
-	    plan.insert(t = EmptyTask.new)
+	    plan.add_mission(t = EmptyTask.new)
 	    [:start, :success, :stop].each do |name|
 		t.on(name) { mock.send(name) }
 		mock.should_receive(name).once.ordered
@@ -696,7 +832,7 @@ class TC_Task < Test::Unit::TestCase
     end
 
     def aggregator_test(a, *tasks)
-	plan.insert(a)
+	plan.add_mission(a)
 	FlexMock.use do |mock|
 	    [:start, :success, :stop].each do |name|
 		a.on(name) { mock.send(name) }
@@ -709,10 +845,10 @@ class TC_Task < Test::Unit::TestCase
 
     def test_task_parallel_aggregator
         t1, t2 = EmptyTask.new, EmptyTask.new
-	plan.discover([t1, t2])
+	plan.add([t1, t2])
 	aggregator_test((t1 | t2), t1, t2)
         t1, t2 = EmptyTask.new, EmptyTask.new
-	plan.discover([t1, t2])
+	plan.add([t1, t2])
 	aggregator_test( (t1 | t2).to_task, t1, t2 )
     end
 
@@ -755,7 +891,7 @@ class TC_Task < Test::Unit::TestCase
 
 	task = seq.to_task(model)
 
-	plan.insert(task)
+	plan.add_mission(task)
 
 	assert(!seq.child_object?(t1, TaskStructure::Hierarchy))
 	assert(!seq.child_object?(t2, TaskStructure::Hierarchy))
@@ -769,13 +905,13 @@ class TC_Task < Test::Unit::TestCase
     end
 
     def test_compatible_state
-	t1, t2 = prepare_plan :discover => 2, :model => SimpleTask
+	t1, t2 = prepare_plan :add => 2, :model => SimpleTask
 
 	assert(t1.compatible_state?(t2))
 	t1.start!; assert(! t1.compatible_state?(t2) && !t2.compatible_state?(t1))
 	t1.stop!; assert(t1.compatible_state?(t2) && t2.compatible_state?(t1))
 
-	plan.discover(t1 = SimpleTask.new)
+	plan.add(t1 = SimpleTask.new)
 	t1.start!
 	t2.start!; assert(t1.compatible_state?(t2) && t2.compatible_state?(t1))
 	t1.stop!; assert(t1.compatible_state?(t2) && !t2.compatible_state?(t1))
@@ -791,31 +927,33 @@ class TC_Task < Test::Unit::TestCase
 	end
 
 	t1, t2 = task_model.new, task_model.new
-	plan.discover([t1, t2])
+	plan.add([t1, t2])
 	assert(t1.fullfills?(t1.model))
 	assert(t1.fullfills?(t2))
 	assert(t1.fullfills?(abstract_task_model))
 	
-	plan.discover(t2 = task_model.new(:index => 2))
+	plan.add(t2 = task_model.new(:index => 2))
 	assert(!t1.fullfills?(t2))
 
-	plan.discover(t3 = task_model.new(:universe => 42))
+	plan.add(t3 = task_model.new(:universe => 42))
 	assert(t3.fullfills?(t1))
 	assert(!t1.fullfills?(t3))
+	plan.add(t3 = task_model.new(:universe => 42, :index => 21))
+	assert(t3.fullfills?(task_model, :universe => 42))
 
-	plan.discover(t3 = Class.new(Task).new)
+	plan.add(t3 = Class.new(Task).new)
 	assert(!t1.fullfills?(t3))
 
-	plan.discover(t3 = Class.new(task_model).new)
+	plan.add(t3 = Class.new(task_model).new)
 	assert(!t1.fullfills?(t3))
 	assert(t3.fullfills?(t1))
     end
 
     def test_related_tasks
 	t1, t2, t3 = (1..3).map { SimpleTask.new }.
-	    each { |t| plan.discover(t) }
-	t1.realized_by t2
-	t1.event(:start).on t3.event(:start)
+	    each { |t| plan.add(t) }
+	t1.depends_on t2
+	t1.event(:start).signals t3.event(:start)
 	assert_equal([t3].to_value_set, t1.event(:start).related_tasks)
 	assert_equal([t2].to_value_set, t1.related_objects)
 	assert_equal([t2, t3].to_value_set, t1.related_tasks)
@@ -823,9 +961,9 @@ class TC_Task < Test::Unit::TestCase
 
     def test_related_events
 	t1, t2, t3 = (1..3).map { SimpleTask.new }.
-	    each { |t| plan.discover(t) }
-	t1.realized_by t2
-	t1.event(:start).on t3.event(:start)
+	    each { |t| plan.add(t) }
+	t1.depends_on t2
+	t1.event(:start).signals t3.event(:start)
 	assert_equal([t3.event(:start)].to_value_set, t1.related_events)
     end
 
@@ -836,7 +974,7 @@ class TC_Task < Test::Unit::TestCase
 
 	# Test that the stop event will make the handler called on a running task
 	FlexMock.use do |mock|
-	    plan.discover(task = model.new)
+	    plan.add(task = model.new)
 	    ev = task.event(:success)
 	    ev.if_unreachable(false) { mock.success_called }
 	    ev.if_unreachable(true)  { mock.success_cancel_called }
@@ -851,11 +989,11 @@ class TC_Task < Test::Unit::TestCase
 	    task.start!
 	    task.success!
 	end
-	plan.garbage_collect
+	engine.garbage_collect
 
 	# Test that it works on pending tasks too
 	FlexMock.use do |mock|
-	    plan.discover(task = model.new)
+	    plan.add(task = model.new)
 	    ev = task.event(:success)
 	    ev.if_unreachable(false) { mock.success_called }
 	    ev.if_unreachable(true)  { mock.success_cancel_called }
@@ -868,7 +1006,7 @@ class TC_Task < Test::Unit::TestCase
 	    mock.should_receive(:ready_called).once
 	    mock.should_receive(:ready_cancel_called).once
 
-	    plan.garbage_collect
+	    engine.garbage_collect
 	end
 
     end
@@ -881,11 +1019,11 @@ class TC_Task < Test::Unit::TestCase
 		event(:start).achieve_with slave
 	    end
 	end.new
-	plan.discover([master, slave])
+	plan.add([master, slave])
 
 	master.start!
 	assert(master.starting?)
-	assert(master.realized_by?(slave))
+	assert(master.depends_on?(slave))
 	slave.start!
 	slave.success!
 	assert(master.started?)
@@ -896,7 +1034,7 @@ class TC_Task < Test::Unit::TestCase
 		event(:start).achieve_with slave.event(:start)
 	    end
 	end.new
-	plan.discover([master, slave])
+	plan.add([master, slave])
 
 	master.start!
 	assert(master.starting?)
@@ -905,7 +1043,7 @@ class TC_Task < Test::Unit::TestCase
 
     def test_task_group
 	t1, t2 = SimpleTask.new, SimpleTask.new
-	plan.discover(g = Group.new(t1, t2))
+	plan.add(g = Group.new(t1, t2))
 
 	g.start!
 	assert(t1.running?)
@@ -918,7 +1056,7 @@ class TC_Task < Test::Unit::TestCase
     end
 
     def test_task_poll
-	Roby.control.run :cycle => 0.1, :detach => true
+	engine.run
 
 	FlexMock.use do |mock|
 	    t = Class.new(SimpleTask) do
@@ -928,12 +1066,12 @@ class TC_Task < Test::Unit::TestCase
 	    end.new
 	    mock.should_receive(:polled).at_least.once.with(t)
 
-	    Roby.execute do
-		plan.permanent(t)
+	    engine.execute do
+		plan.add_permanent(t)
 		t.start!
 	    end
-	    sleep(1)
-	    Roby.execute do
+	    engine.wait_one_cycle
+	    engine.execute do
 		assert(t.running?, t.terminal_event.to_s)
 		t.stop!
 	    end
@@ -948,11 +1086,11 @@ class TC_Task < Test::Unit::TestCase
 		end
 	    end.new
 
-	    Roby.execute do
-		plan.permanent(t)
+	    engine.execute do
+		plan.add_permanent(t)
 		t.start!
 	    end
-	    sleep(1)
+	    engine.wait_one_cycle
 	    assert(t.failed?)
 	end
     end
@@ -962,15 +1100,15 @@ class TC_Task < Test::Unit::TestCase
 	    event :specialized_failure, :command => true
 	    forward :specialized_failure => :failed
 	end.new
-	plan.discover(task)
+	plan.add(task)
 
 	task.start!
 	assert_equal([task.event(:start).last], task.event(:start).last.task_sources.to_a)
 
 	ev = EventGenerator.new(true)
-	ev.forward task.event(:specialized_failure)
+	ev.forward_to task.event(:specialized_failure)
 	ev.call
-	assert_equal([task.event(:specialized_failure).last], task.event(:failed).last.task_sources.to_a)
+	assert_equal([task.event(:specialized_failure).last], task.event(:stop).last.task_sources.to_a)
     end
 
     def test_virtual_task
@@ -978,7 +1116,7 @@ class TC_Task < Test::Unit::TestCase
 	assert_raises(ArgumentError) { VirtualTask.create(success, start) }
 
 	assert_kind_of(VirtualTask, task = VirtualTask.create(start, success))
-	plan.discover(task)
+	plan.add(task)
 	assert_equal(start, task.start_event)
 	assert_equal(success, task.success_event)
 	FlexMock.use do |mock|
@@ -993,19 +1131,19 @@ class TC_Task < Test::Unit::TestCase
 	end
 
 	start, success = EventGenerator.new(true), EventGenerator.new
-	plan.discover(task = VirtualTask.create(start, success))
+	plan.add(task = VirtualTask.create(start, success))
 	task.start!
 	plan.remove_object(success)
 	assert(task.failed?)
 
 	start, success = EventGenerator.new(true), EventGenerator.new
-	plan.discover(success)
-	plan.discover(task = VirtualTask.create(start, success))
+	plan.add(success)
+	plan.add(task = VirtualTask.create(start, success))
 	assert_nothing_raised { success.emit }
     end
 
     def test_dup
-	plan.discover(task = Roby::Test::SimpleTask.new)
+	plan.add(task = Roby::Test::SimpleTask.new)
 	task.start!
 
 	new = task.dup
@@ -1024,5 +1162,20 @@ class TC_Task < Test::Unit::TestCase
 	new.event(:stop).call
 	assert(new.finished?, new.history)
     end
+
+    def test_failed_to_start
+	plan.add(task = Roby::Test::SimpleTask.new)
+        begin
+            task.event(:start).emit_failed
+        rescue Exception
+        end
+        assert task.failed_to_start?
+        assert task.failed?
+        assert !task.pending?
+        assert !task.running?
+        assert [], plan.find_tasks.pending.to_a
+        assert [], plan.find_tasks.running.to_a
+        assert [task], plan.find_tasks.failed.to_a
+    end
 end