roby 0.7.3 → 0.8.0

data/test/relations/test_planned_by.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'
 
@@ -8,7 +8,7 @@ class TC_PlannedBy < Test::Unit::TestCase
     PlannedBy = Roby::TaskStructure::PlannedBy
     SimpleTask = Roby::Test::SimpleTask
     def test_replace
-	task, p1, p2 = prepare_plan :discover => 3
+	task, p1, p2 = prepare_plan :add => 3
 	task.planned_by p1
 
 	assert_raises(ArgumentError) { task.planned_by p2 }
@@ -24,24 +24,26 @@ class TC_PlannedBy < Test::Unit::TestCase
 	task = Roby::Task.new
 	planner = Roby::Test::SimpleTask.new
 	task.planned_by planner
-	plan.permanent(task)
+	plan.add_permanent(task)
 
-	assert_equal([], PlannedBy.check_planning(plan))
+	assert_equal([], plan.check_structure.to_a)
 	planner.start!
-	assert_equal([], PlannedBy.check_planning(plan))
+	assert_equal([], plan.check_structure.to_a)
 	planner.success!
-	assert_equal([], PlannedBy.check_planning(plan))
+	assert_equal([], plan.check_structure.to_a)
 
 	task.remove_planning_task planner
 	planner = Roby::Test::SimpleTask.new
 	task.planned_by planner
 
-	assert_equal([], PlannedBy.check_planning(plan))
+	assert_equal([], plan.check_structure.to_a)
 	planner.start!
-	assert_equal([], PlannedBy.check_planning(plan))
+	assert_equal([], plan.check_structure.to_a)
 	planner.failed!
 
-	error = *PlannedBy.check_planning(plan)
+	errors = plan.check_structure.to_a
+        assert_equal 1, errors.size
+        error = errors.first.first.exception
 	assert_kind_of(Roby::PlanningFailedError, error)
 	assert_equal(planner, error.failed_task)
 	assert_equal(task, error.planned_task)

data/test/suite_core.rb

@@ -1,3 +1,4 @@
+$LOAD_PATH.unshift File.expand_path(File.join('..', 'lib'), File.dirname(__FILE__))
 require 'test_support'
 
 require 'test_bgl'
@@ -6,19 +7,21 @@ require 'test_event'
 require 'test_task'
 require 'test_state'
 
-require 'test_propagation'
+require 'test_execution_engine'
 require 'test_exceptions'
 
 require 'test_plan'
 require 'test_query'
 require 'test_transactions'
 require 'test_transactions_proxy'
-require 'test_thread_task'
+
+require 'tasks/test_thread_task'
+
+require 'test_testcase'
 
 require 'suite_planning'
 require 'suite_relations'
 
-require 'test_control'
 require 'test_interface'
 require 'test_log'
 

data/test/suite_distributed.rb

@@ -1,3 +1,4 @@
+$LOAD_PATH.unshift File.expand_path(File.join('..', 'lib'), File.dirname(__FILE__))
 require 'distributed/test_communication'
 require 'distributed/test_connection'
 require 'distributed/test_execution'

data/test/suite_planning.rb

@@ -1,3 +1,4 @@
+$LOAD_PATH.unshift File.expand_path(File.join('..', 'lib'), File.dirname(__FILE__))
 require 'planning/test_model'
 require 'planning/test_task'
 require 'planning/test_loops'

data/test/suite_relations.rb

@@ -1,8 +1,8 @@
+$LOAD_PATH.unshift File.expand_path(File.join('..', 'lib'), File.dirname(__FILE__))
 require 'test_relations'
-require 'relations/test_hierarchy'
+require 'relations/test_dependency'
 require 'relations/test_executed_by'
 require 'relations/test_planned_by'
 require 'relations/test_conflicts'
-
 require 'relations/test_ensured'
 

data/test/tasks/test_external_process.rb

@@ -0,0 +1,126 @@
+$LOAD_PATH.unshift File.expand_path(File.join('..', '..', 'lib'), File.dirname(__FILE__))
+require 'roby/test/common'
+require 'roby/external_process_task'
+require 'roby/test/tasks/simple_task'
+require 'roby/test/tasks/empty_task'
+
+class TC_ThreadTask < Test::Unit::TestCase 
+    include Roby::Test
+
+    MOCKUP = File.expand_path(
+        File.join("..", "mockups", "external_process"),
+        File.dirname(__FILE__))
+
+    class MockupTask < Roby::ExternalProcessTask
+        event :stop do
+            FileUtils.touch "/tmp/external_process_mockup_stop"
+        end
+    end
+
+    def assert_polling_successful(timeout, sleep = 0.05)
+        now = Time.now
+        while (Time.now - now) < timeout
+            if yield
+                return
+            end
+        end
+        flunk "reached timeout"
+    end
+
+    def test_nominal
+        plan.add_permanent(task = ExternalProcessTask.new(:command_line => [MOCKUP, "--no-output"]))
+        engine.run
+        engine.once { task.start! }
+
+        assert_polling_successful(5) { task.success? }
+    end
+
+    def test_nominal_array_with_one_element
+        plan.add_permanent(task = ExternalProcessTask.new(:command_line => [MOCKUP]))
+        engine.run
+        engine.once { task.start! }
+
+        assert_polling_successful(5) { task.success? }
+    end
+
+    def test_nominal_no_array
+        plan.add_permanent(task = ExternalProcessTask.new(:command_line => MOCKUP))
+        engine.run
+        engine.once { task.start! }
+
+        assert_polling_successful(5) { task.success? }
+    end
+
+    def test_inexistent_program
+        plan.add_permanent(task = ExternalProcessTask.new(:command_line => ['does_not_exist', "--error"]))
+        engine.run
+        engine.once { task.start! }
+
+        assert_polling_successful(5) { task.failed? }
+        assert_equal 1, task.event(:failed).last.context.first.exitstatus
+    end
+
+    def test_failure
+        plan.add_permanent(task = ExternalProcessTask.new(:command_line => [MOCKUP, "--error"]))
+        engine.run
+        engine.once { task.start! }
+
+        assert_polling_successful(5) { task.failed? }
+        assert_equal 1, task.event(:failed).last.context.first.exitstatus
+    end
+
+    def test_signaling
+        plan.add_permanent(task = ExternalProcessTask.new(:command_line => [MOCKUP, "--block"]))
+        engine.run
+        engine.once { task.start! }
+        assert_polling_successful(5) { task.running? }
+
+        Process.kill 'KILL', task.pid
+        assert_polling_successful(5) { task.failed? }
+        assert task.event(:signaled).happened?
+
+        ev = task.event(:signaled).last
+        assert_equal 9, ev.context.first.termsig
+    end
+
+    def do_redirection(expected)
+        plan.add_permanent(task = ExternalProcessTask.new(:command_line => [MOCKUP]))
+        yield(task)
+        engine.run
+        engine.once { task.start! }
+
+        assert_polling_successful(5) { task.success? }
+
+        assert File.exists?("mockup-#{task.pid}.log")
+        File.read("mockup-#{task.pid}.log")
+
+    ensure
+        FileUtils.rm_f "mockup-#{task.pid}.log"
+    end
+
+    def test_stdout_redirection
+        do_redirection `#{MOCKUP}` do |task|
+            task.redirect_output :stdout => 'mockup-%p.log'
+        end
+    end
+
+    def test_stderr_redirection
+        do_redirection `#{MOCKUP}` do |task|
+            task.command_line << "--stderr"
+            task.redirect_output :stderr => 'mockup-%p.log'
+        end
+    end
+
+    def test_common_redirection
+        output = do_redirection(nil) do |task|
+            task.command_line << "--common"
+            task.redirect_output 'mockup-%p.log'
+        end
+
+
+        expected = `#{MOCKUP} --common 2>&1`
+        assert_equal expected, output
+    end
+end
+
+

data/test/{test_thread_task.rb → tasks/test_thread_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/thread_task'
 require 'roby/test/tasks/simple_task'
@@ -7,6 +7,15 @@ require 'roby/test/tasks/empty_task'
 class TC_ThreadTask < Test::Unit::TestCase 
     include Roby::Test
 
+    # Starts +task+ and waits for the thread to end
+    def wait_thread_end(task)
+        task.start!
+        while task.thread
+            process_events
+            sleep 0.1
+        end
+    end
+
     def test_normal
         model = Class.new(Roby::ThreadTask) do
             implementation do
@@ -14,12 +23,8 @@ class TC_ThreadTask < Test::Unit::TestCase
             end
         end
 
-        plan.insert(task = model.new)
-        task.start!
-        while task.thread
-            process_events
-            sleep 0.1
-        end
+        plan.add_mission(task = model.new)
+	wait_thread_end(task)
 
         assert task.success?
         assert_equal 1, task.result
@@ -27,19 +32,15 @@ class TC_ThreadTask < Test::Unit::TestCase
 
     def test_implementation_fails
         Thread.abort_on_exception = false
-        Roby.control.abort_on_exception = false
+        Roby.app.abort_on_exception = false
         model = Class.new(Roby::ThreadTask) do
             implementation do
                 raise ArgumentError, "blaaaaaaaaah"
             end
         end
 
-        plan.discover(task = model.new)
-        task.start!
-        while task.thread
-            process_events
-            sleep 0.1
-        end
+        plan.add_permanent(task = model.new)
+	wait_thread_end(task)
 
         assert task.failed?
         assert_kind_of ArgumentError, task.event(:failed).last.context.first
@@ -58,12 +59,8 @@ class TC_ThreadTask < Test::Unit::TestCase
             end
         end
 
-        plan.discover(task = model.new)
-        task.start!
-        while task.thread
-            process_events
-            sleep 0.1
-        end
+        plan.add(task = model.new)
+	wait_thread_end(task)
 
         assert task.failed?
         assert_kind_of Interrupt, task.event(:failed).last.context.first

data/test/test_bgl.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 'enumerator'
 require 'flexmock'
@@ -75,6 +75,26 @@ class TC_BGL < Test::Unit::TestCase
 	assert_equal(2, v4[v3, graph])
     end
 
+    def test_clear
+	g1, g2 = Graph.new, Graph.new
+
+	vertices = (1..3).map do
+            g1.insert(v = Vertex.new)
+            g2.insert(v)
+
+            assert g1.include?(v)
+            assert g2.include?(v)
+            v
+        end
+
+        g1.clear
+        vertices.each do |v|
+            assert !g1.include?(v)
+            assert g2.include?(v)
+            assert_equal [g2], v.enum_for(:each_graph).to_a
+        end
+    end
+
     def test_edge_objects
 	g1, g2 = Graph.new, Graph.new
 

data/test/test_event.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'
@@ -6,17 +6,28 @@ require 'roby/test/tasks/simple_task'
 require 'roby'
 class TC_Event < Test::Unit::TestCase
     include Roby::Test
+    def setup
+        super
+        Roby.app.filter_backtraces = false
+    end
+
+    def test_no_plan
+        event = EventGenerator.new { }
+        assert(!event.executable?)
+        assert_raises(Roby::EventNotExecutable) { event.emit }
+        assert_raises(Roby::EventNotExecutable) { event.call }
 
-    def test_properties
-	event = EventGenerator.new
-	assert(! event.controlable?)
+        plan.add(event)
+        assert(event.executable?)
+    end
 
+    def test_controlable_events
 	event = EventGenerator.new(true)
 	assert(event.controlable?)
 
 	# Check command & emission behavior for controlable events
 	FlexMock.use do |mock|
-	    plan.discover(event = EventGenerator.new { |context| mock.call_handler(context); event.emit(*context) })
+	    plan.add(event = EventGenerator.new { |context| mock.call_handler(context); event.emit(*context) })
 	    event.on { |event| mock.event_handler(event.context) }
 
 	    assert(event.controlable?)
@@ -24,19 +35,22 @@ class TC_Event < Test::Unit::TestCase
 	    mock.should_receive(:event_handler).once.with([42])
 	    event.call(42)
 	end
+    end
 
+    def test_contingent_events
 	# Check emission behavior for non-controlable events
 	FlexMock.use do |mock|
 	    event = EventGenerator.new
-	    plan.discover(event)
+	    plan.add(event)
 	    event.on { |event| mock.event(event.context) }
 	    mock.should_receive(:event).once.with([42])
 	    event.emit(42)
 	end
     end
 
-    def test_executable
-	plan.discover(event = EventGenerator.new(true))
+    def test_explicit_executable_flag
+	plan.add(event = EventGenerator.new(true))
+        assert(event.executable?)
 	event.executable = false
 	assert_raises(EventNotExecutable) { event.call(nil) }
 	assert_raises(EventNotExecutable) { event.emit(nil) }
@@ -45,14 +59,14 @@ class TC_Event < Test::Unit::TestCase
 	assert_nothing_raised { event.call(nil) }
 	assert_nothing_raised { event.emit(nil) }
 
-	plan.discover(other = EventGenerator.new(true))
+	plan.add(other = EventGenerator.new(true))
 	other.executable = false
-	event.on other
+	event.signals other
 	assert_raises(EventNotExecutable) { event.call(nil) }
 
 	event.remove_signal(other)
 	assert_nothing_raised { event.emit(nil) }
-	other.emit_on event
+	event.forward_to other
 	assert_raises(EventNotExecutable) { event.call(nil) }
 
 	event.remove_forwarding(other)
@@ -61,9 +75,8 @@ class TC_Event < Test::Unit::TestCase
 	assert_original_error(EventNotExecutable, EventHandlerError) { event.call(nil) }
     end
 
-    def test_emit_failed
-	event = EventGenerator.new
-	plan.discover(event)
+    def test_emit_failed_raises
+	plan.add(event = EventGenerator.new)
 	assert_original_error(NilClass, EmissionFailed) { event.emit_failed }
 	assert_original_error(NilClass, EmissionFailed) { event.emit_failed("test") }
 
@@ -82,9 +95,11 @@ class TC_Event < Test::Unit::TestCase
 	    assert_equal(event, e.failed_generator)
 	    assert( e.message =~ /: test$/ )
 	end
+    end
 
+    def test_emit_failed_removes_pending
 	event = EventGenerator.new { }
-	plan.discover(event)
+	plan.add(event)
 	event.call
 	assert(event.pending?)
 	assert_raises(EmissionFailed) { event.emit_failed }
@@ -93,8 +108,8 @@ class TC_Event < Test::Unit::TestCase
 
     def test_propagation_id
 	e1, e2, e3 = (1..3).map { EventGenerator.new(true) }.
-	    each { |e| plan.discover(e) }
-	e1.on e2
+	    each { |e| plan.add(e) }
+	e1.signals e2
 	e1.emit(nil)
 	assert_equal(e1.last.propagation_id, e2.last.propagation_id)
 
@@ -107,21 +122,82 @@ class TC_Event < Test::Unit::TestCase
     end
 
 
-    def test_signal_relation
+    def test_signals_without_delay
 	e1, e2 = EventGenerator.new(true), Roby::EventGenerator.new(true)
-	plan.discover([e1, e2])
+	plan.add([e1, e2])
 
-	e1.on e2
-	assert( e1.child_object?( e2, EventStructure::Signal ))
-	assert( e2.parent_object?( e1, EventStructure::Signal ))
+        e1.signals e2
 
-	e1.call(nil)
-	assert(e2.happened?)
+        assert( e1.child_object?( e2, EventStructure::Signal ))
+        assert( e2.parent_object?( e1, EventStructure::Signal ))
+
+        e1.call(nil)
+        assert(e2.happened?)
+    end
+
+    def test_forward_to_without_delay
+	e1, e2 = EventGenerator.new, Roby::EventGenerator.new
+	plan.add([e1, e2])
+
+        e1.forward_to e2
+
+        assert( e1.child_object?( e2, EventStructure::Forwarding ))
+        assert( e2.parent_object?( e1, EventStructure::Forwarding ))
+
+        e1.emit(nil)
+        assert(e2.happened?)
+    end
+
+    # b.emit_on(a) is replaced by a.forward_to(b)
+    def test_deprecated_emit_on
+	e1, e2 = EventGenerator.new, Roby::EventGenerator.new
+	plan.add([e1, e2])
+
+        deprecated_feature do
+            e2.emit_on e1
+        end
+
+        assert( e1.child_object?( e2, EventStructure::Forwarding ))
+        assert( e2.parent_object?( e1, EventStructure::Forwarding ))
+
+        e1.emit(nil)
+        assert(e2.happened?)
+    end
+
+    # forward has been renamed into #forward_to
+    def test_deprecated_forward
+	e1, e2 = EventGenerator.new, Roby::EventGenerator.new
+	plan.add([e1, e2])
+
+        deprecated_feature do
+            e1.forward e2
+        end
+
+        assert( e1.child_object?( e2, EventStructure::Forwarding ))
+        assert( e2.parent_object?( e1, EventStructure::Forwarding ))
+
+        e1.emit(nil)
+        assert(e2.happened?)
+    end
+
+    def test_deprecated_on
+	e1, e2 = EventGenerator.new(true), Roby::EventGenerator.new(true)
+	plan.add([e1, e2])
+
+        deprecated_feature do
+            e1.on e2
+        end
+
+        assert( e1.child_object?( e2, EventStructure::Signal ))
+        assert( e2.parent_object?( e1, EventStructure::Signal ))
+
+        e1.call(nil)
+        assert(e2.happened?)
     end
  
     def test_handlers
 	e1, e2 = EventGenerator.new(true), Roby::EventGenerator.new(true)
-	plan.discover([e1, e2])
+	plan.add([e1, e2])
 	e1.on { e2.call(nil) }
 
 	FlexMock.use do |mock|
@@ -135,45 +211,45 @@ class TC_Event < Test::Unit::TestCase
 	end
     end
 
-    def test_event_sources
-	events = (1..6).map { EventGenerator.new(true) }
-	forwarded, signalled, 
-	    emitted_in_handler, called_in_handler,
-	    emitted_in_command, called_in_command = *events
-
-	src = EventGenerator.new(true)
-	e = EventGenerator.new do
-	    called_in_command.call
-	    emitted_in_command.emit
-	    e.emit
-	end
-	events << e
-
-	plan.discover(events)
-
-	e.forward forwarded
-	e.on signalled
-	e.on do 
-	    called_in_handler.call 
-	    emitted_in_handler.emit
-	end
-
-	src.on e
-	src.call
-	assert_equal([e.last], forwarded.last.sources.to_a)
-	assert_equal([e.last], emitted_in_handler.last.sources.to_a)
-	assert_equal([], emitted_in_command.last.sources.to_a)
-	assert_equal([], signalled.last.sources.to_a)
-	assert_equal([], called_in_handler.last.sources.to_a)
-	assert_equal([], called_in_command.last.sources.to_a)
+    def common_test_source_setup(forwarding)
+	src    = EventGenerator.new(true)
+	e      = EventGenerator.new(true)
+        target = EventGenerator.new(true)
+        plan.add([src, e, target])
+        src.signals e
+        yield(e, target)
+        src.call
+        if forwarding
+            assert_equal([e.last], target.last.sources.to_a)
+        else
+            assert_equal([], target.last.sources.to_a)
+        end
+    end
+    def test_forward_source
+        common_test_source_setup(true) { |e, target| e.forward_to target }
+    end
+    def test_forward_in_handler_source
+        common_test_source_setup(true) { |e, target| e.on { target.emit } }
+    end
+    def test_forward_in_command_source
+        common_test_source_setup(false) { |e, target| e.command = lambda { |_| target.emit; e.emit } }
+    end
+    def test_signal_source
+        common_test_source_setup(false) { |e, target| e.signals target }
+    end
+    def test_signal_in_handler_source
+        common_test_source_setup(false) { |e, target| e.on { target.call } }
+    end
+    def test_signal_in_command_source
+        common_test_source_setup(false) { |e, target| e.command = lambda { |_| target.call; e.emit } }
     end
 
     def test_simple_signal_handler_ordering
 	e1, e2, e3 = (1..3).map { EventGenerator.new(true) }.
-	    each { |e| plan.discover(e) }
-	e1.on(e2)
+	    each { |e| plan.add(e) }
+	e1.signals(e2)
 	e1.on { e2.remove_signal(e3) }
-	e2.on(e3)
+	e2.signals(e3)
 
 	e1.call(nil)
 	assert( e2.happened? )
@@ -194,7 +270,7 @@ class TC_Event < Test::Unit::TestCase
             generator = Class.new(EventGenerator) do
 		include mod
 	    end.new(true)
-	    plan.discover(generator)
+	    plan.add(generator)
             
 	    hooks.each do |name|
 		mock.should_receive(name).once.with(generator).ordered
@@ -206,7 +282,7 @@ class TC_Event < Test::Unit::TestCase
     def test_postpone
 	wait_for = EventGenerator.new(true)
 	event = EventGenerator.new(true)
-	plan.discover([wait_for, event])
+	plan.add([wait_for, event])
 	event.singleton_class.class_eval do
 	    define_method(:calling) do |context|
 		super if defined? super
@@ -228,7 +304,7 @@ class TC_Event < Test::Unit::TestCase
         FlexMock.use do |mock|
 	    wait_for = EventGenerator.new(true)
 	    event = EventGenerator.new(true)
-	    plan.discover([wait_for, event])
+	    plan.add([wait_for, event])
 	    event.singleton_class.class_eval do
 		define_method(:calling) do |context|
 		    super if defined? super
@@ -251,31 +327,18 @@ class TC_Event < Test::Unit::TestCase
 
     def test_can_signal
 	a, b = EventGenerator.new(true), EventGenerator.new
-	plan.discover([a, b])
-	assert_raises(EventNotControlable) { a.on b }
-	assert_nothing_raised { a.forward b }
+	plan.add([a, b])
+	assert_raises(EventNotControlable) { a.signals b }
+	assert_nothing_raised { a.forward_to b }
 
 	a, b = EventGenerator.new(true), EventGenerator.new(true)
-	plan.discover([a, b])
-	a.on b
+	plan.add([a, b])
+	a.signals b
 	def b.controlable?; false end
 
 	assert_raise(EmissionFailed) { a.call(nil) }
     end
 
-    def test_emit_on
-	e1, e2 = (1..2).map { EventGenerator.new(true) }.
-	    each { |e| plan.discover(e) }
-	e1.emit_on e2
-        FlexMock.use do |mock|
-	    e1.on { mock.e1 }
-	    e2.on { mock.e2 }
-	    mock.should_receive(:e2).once.ordered
-	    mock.should_receive(:e1).once.ordered
-	    e2.call(nil)
-	end
-    end
-
     def test_and_generator
 	and_event = AndGenerator.new
 	FlexMock.use do |mock|
@@ -283,7 +346,7 @@ class TC_Event < Test::Unit::TestCase
 	    mock.should_receive(:called).once
 
 	    events = 5.enum_for(:times).map { EventGenerator.new(true) }
-	    plan.discover(events)
+	    plan.add(events)
 	    events.each { |ev| and_event << ev }
 
 	    events.each do |ev| 
@@ -304,7 +367,7 @@ class TC_Event < Test::Unit::TestCase
 	
 	# Check the behavior of the & operator
 	e1, e2, e3, e4 = (1..4).map { EventGenerator.new(true) }.
-	    each { |e| plan.discover(e) }
+	    each { |e| plan.add(e) }
 	and_event = e1 & e2
 	and_and = and_event & e3
 	assert_equal([e1, e2].to_set, and_event.waiting.to_set)
@@ -313,10 +376,10 @@ class TC_Event < Test::Unit::TestCase
 
 	# Check dynamic behaviour
 	a, b, c, d = (1..4).map { EventGenerator.new(true) }.
-	    each { |e| plan.discover(e) }
+	    each { |e| plan.add(e) }
         and1 = a & b
 	and2 = and1 & c
-        and2.on d
+        and2.signals d
         assert_equal([and1], a.enum_for(:each_signal).to_a)
         assert_equal([and1], b.enum_for(:each_signal).to_a)
         assert_equal([and2], and1.enum_for(:each_signal).to_a)
@@ -341,7 +404,7 @@ class TC_Event < Test::Unit::TestCase
     end
 
     def test_and_empty
-	plan.discover(and_event = AndGenerator.new)
+	plan.add(and_event = AndGenerator.new)
 
 	assert(and_event.empty?)
 	and_event << EventGenerator.new(true)
@@ -351,7 +414,7 @@ class TC_Event < Test::Unit::TestCase
 
     def test_and_unreachability
 	a, b = (1..2).map { EventGenerator.new(true) }.
-	    each { |e| plan.discover(e) }
+	    each { |e| plan.add(e) }
 
 	# Test unreachability
 	## it is unreachable once emitted, but if_unreachable(true) blocks
@@ -379,7 +442,7 @@ class TC_Event < Test::Unit::TestCase
 
     def test_and_reset
 	a, b = (1..2).map { EventGenerator.new(true) }.
-	    each { |e| plan.discover(e) }
+	    each { |e| plan.add(e) }
 	and_event = (a & b)
 	a.emit(nil)
 
@@ -406,10 +469,10 @@ class TC_Event < Test::Unit::TestCase
 
     def setup_aggregation(mock)
 	e1, e2, m1, m2, m3 = 5.enum_for(:times).map { EventGenerator.new(true) }
-	plan.discover([e1, e2, m1, m2, m3])
-	e1.on e2
-	m1.on m2
-	m2.on m3
+	plan.add([e1, e2, m1, m2, m3])
+	e1.signals e2
+	m1.signals m2
+	m2.signals m3
 
         (e1 & e2 & m2).on { mock.and }
         (e2 | m1).on { mock.or }
@@ -422,7 +485,7 @@ class TC_Event < Test::Unit::TestCase
     def test_aggregator
         FlexMock.use do |mock|
             e1, e2, m1, *_ = setup_aggregation(mock)
-	    e2.on m1
+	    e2.signals m1
             mock.should_receive(:or).once
             mock.should_receive(:and).once
             mock.should_receive(:and_or).once
@@ -451,7 +514,7 @@ class TC_Event < Test::Unit::TestCase
 
     def test_or_generator
 	a, b, c = (1..3).map { EventGenerator.new(true) }.
-	    each { |e| plan.discover(e) }
+	    each { |e| plan.add(e) }
 
 	or_event = OrGenerator.new
 	assert(or_event.empty?)
@@ -459,7 +522,7 @@ class TC_Event < Test::Unit::TestCase
 	assert(!or_event.empty?)
 
         or_event = (a | b)
-        or_event.on c
+        or_event.signals c
         assert( a.enum_for(:each_causal_link).find { |ev| ev == or_event } )
         assert( or_event.enum_for(:each_causal_link).find { |ev| ev == c } )
 	a.call(nil)
@@ -468,7 +531,7 @@ class TC_Event < Test::Unit::TestCase
     end
 
     def test_or_emission
-	plan.discover(or_event = OrGenerator.new)
+	plan.add(or_event = OrGenerator.new)
 	events = (1..4).map { EventGenerator.new(true) }.
 	    each { |e| or_event << e }
 
@@ -483,7 +546,7 @@ class TC_Event < Test::Unit::TestCase
     end
 
     def test_or_reset
-	plan.discover(or_event = OrGenerator.new)
+	plan.add(or_event = OrGenerator.new)
 	events = (1..4).map { EventGenerator.new(true) }.
 	    each { |e| or_event << e }
 
@@ -499,7 +562,7 @@ class TC_Event < Test::Unit::TestCase
     def test_or_unreachability
 	# Test unreachability properties
 	a, b = (1..3).map { EventGenerator.new(true) }.
-	    each { |e| plan.discover(e) }
+	    each { |e| plan.add(e) }
         or_event = (a | b)
 	
 	## must be unreachable once emitted, but if_unreachable(true) blocks
@@ -526,10 +589,10 @@ class TC_Event < Test::Unit::TestCase
 
     def test_until
 	source, sink, filter, limit = 4.enum_for(:times).map { EventGenerator.new(true) }
-	plan.discover [source, sink, filter, limit]
+	plan.add [source, sink, filter, limit]
 
-	source.on(filter)
-	filter.until(limit).on(sink)
+	source.signals(filter)
+	filter.until(limit).signals(sink)
 
 	FlexMock.use do |mock|
 	    sink.on { mock.passed }
@@ -544,19 +607,19 @@ class TC_Event < Test::Unit::TestCase
     def test_event_creation
 	# Test for validation of the return value of #event
 	generator = Class.new(EventGenerator) do
-	    def new(context); [Propagation.propagation_id, context] end
+	    def new(context); [] end
 	end.new(true)
-	plan.discover(generator)
+	plan.add(generator)
 
 	assert_raises(EmissionFailed) { generator.emit(nil) }
 
 	generator = Class.new(EventGenerator) do
 	    def new(context); 
 		event_klass = Struct.new :propagation_id, :context, :generator, :sources
-		event_klass.new(Propagation.propagation_id, context, self)
+		event_klass.new(plan.engine.propagation_id, context, self)
 	    end
 	end.new(true)
-	plan.discover(generator)
+	plan.add(generator)
 	assert_nothing_raised { generator.call(nil) }
     end
 
@@ -564,10 +627,10 @@ class TC_Event < Test::Unit::TestCase
 	FlexMock.use do |mock|
 	    e1 = EventGenerator.new { |context| mock.e1_cmd(context); e1.emit(*context) }
 	    e2 = EventGenerator.new { |context| mock.e2_cmd(context); e2.emit(*context) }
-	    e1.on e2
+	    e1.signals e2
 	    e1.on { |event| mock.e1(event.context) }
 	    e2.on { |event| mock.e2(event.context) }
-	    plan.discover([e1, e2])
+	    plan.add([e1, e2])
 
 	    mock.should_receive(:e1_cmd).with([mock]).once
 	    mock.should_receive(:e2_cmd).with([mock]).once
@@ -579,10 +642,10 @@ class TC_Event < Test::Unit::TestCase
 	FlexMock.use do |mock|
 	    pass_through = EventGenerator.new(true)
 	    e2 = EventGenerator.new { |context| mock.e2_cmd(context); e2.emit(*context) }
-	    pass_through.on e2
+	    pass_through.signals e2
 	    pass_through.on { |event| mock.e1(event.context) }
 	    e2.on { |event| mock.e2(event.context) }
-	    plan.discover([pass_through, e2])
+	    plan.add([pass_through, e2])
 
 	    mock.should_receive(:e2_cmd).with([mock]).once
 	    mock.should_receive(:e1).with([mock]).once
@@ -593,10 +656,10 @@ class TC_Event < Test::Unit::TestCase
 	FlexMock.use do |mock|
 	    e1 = EventGenerator.new { |context| mock.e1_cmd(context); e1.emit(*context) }
 	    e2 = EventGenerator.new { |context| mock.e2_cmd(context); e2.emit(*context) }
-	    e1.on e2
+	    e1.signals e2
 	    e1.on { |event| mock.e1(event.context) }
 	    e2.on { |event| mock.e2(event.context) }
-	    plan.discover([e1, e2])
+	    plan.add([e1, e2])
 
 	    mock.should_receive(:e1_cmd).with(nil).once
 	    mock.should_receive(:e2_cmd).with(nil).once
@@ -607,7 +670,7 @@ class TC_Event < Test::Unit::TestCase
     end
 
     def test_preconditions
-	plan.discover(e1 = EventGenerator.new(true))
+	plan.add(e1 = EventGenerator.new(true))
 	e1.precondition("context must be non-nil") do |generator, context|
 	    context
 	end
@@ -622,27 +685,27 @@ class TC_Event < Test::Unit::TestCase
 		cancel("testing cancel method")
 	    end
 	end.new(true)
-	plan.discover(e1)
+	plan.add(e1)
 	assert_raises(EventCanceled) { e1.call(nil) }
     end
 
     def test_related_events
 	e1, e2 = (1..2).map { EventGenerator.new(true) }.
-	    each { |ev| plan.discover(ev) }
+	    each { |ev| plan.add(ev) }
 
 	assert_equal([].to_value_set, e1.related_events)
-	e1.on e2
+	e1.signals e2
 	assert_equal([e2].to_value_set, e1.related_events)
 	assert_equal([e1].to_value_set, e2.related_events)
     end
 
     def test_related_tasks
 	e1, e2 = (1..2).map { EventGenerator.new(true) }.
-	    each { |ev| plan.discover(ev) }
+	    each { |ev| plan.add(ev) }
 	t1 = SimpleTask.new
 
 	assert_equal([].to_value_set, e1.related_tasks)
-	e1.on t1.event(:start)
+	e1.signals t1.event(:start)
 	assert_equal([t1].to_value_set, e1.related_tasks)
     end
 
@@ -652,7 +715,7 @@ class TC_Event < Test::Unit::TestCase
 		ev.emit(*context)
 		mock.called(*context)
 	    end
-	    plan.discover(ev)
+	    plan.add(ev)
 
 	    mock.should_receive(:called).with(42).once
 	    ev.call(42)
@@ -666,7 +729,7 @@ class TC_Event < Test::Unit::TestCase
     def test_set_command
 	FlexMock.use do |mock|
 	    ev = EventGenerator.new
-	    plan.discover(ev)
+	    plan.add(ev)
 	    assert(!ev.controlable?)
 
 	    ev.command = lambda { mock.first }
@@ -685,19 +748,25 @@ class TC_Event < Test::Unit::TestCase
     end
 
     def test_once
-	ev1, ev2 = EventGenerator.new(true), EventGenerator.new(true)
-	plan.discover([ev1, ev2])
+	plan.add(ev = EventGenerator.new(true))
+	FlexMock.use do |mock|
+	    ev.once { mock.called_once }
+	    mock.should_receive(:called_once).once
+
+	    ev.call
+	    ev.call
+	end
+    end
 
+    def test_signal_once
+	ev1, ev2 = EventGenerator.new(true), EventGenerator.new(true)
+	plan.add([ev1, ev2])
 
 	FlexMock.use do |mock|
-	    ev1.once(ev2) do
-		mock.called_once
-	    end
-
+	    ev1.signals_once(ev2)
 	    ev2.on { mock.called }
 
 	    mock.should_receive(:called).once
-	    mock.should_receive(:called_once).once
 
 	    ev1.call
 	    ev1.call
@@ -706,10 +775,10 @@ class TC_Event < Test::Unit::TestCase
 
     def test_forward_once
 	ev1, ev2 = EventGenerator.new(true), EventGenerator.new(true)
-	plan.discover([ev1, ev2])
+	plan.add([ev1, ev2])
 
 	FlexMock.use do |mock|
-	    ev1.forward_once(ev2)
+	    ev1.forward_to_once(ev2)
 	    ev2.on { mock.called }
 
 	    mock.should_receive(:called).once
@@ -721,16 +790,16 @@ class TC_Event < Test::Unit::TestCase
 
     def test_filter
 	ev1, ev_block, ev_value, ev_nil = (1..4).map { EventGenerator.new(true) }.
-	    each { |e| plan.discover(e) }
+	    each { |e| plan.add(e) }
 
 	FlexMock.use do |mock|
-	    ev1.filter { |v| mock.filtering(v); v*2 }.on ev_block
+	    ev1.filter { |v| mock.filtering(v); v*2 }.signals ev_block
 	    ev_block.on { |ev| mock.block_filter(ev.context) }
 
-	    ev1.filter(42).on ev_value
+	    ev1.filter(42).signals ev_value
 	    ev_value.on { |ev| mock.value_filter(ev.context) }
 
-	    ev1.filter.on ev_nil
+	    ev1.filter.signals ev_nil
 	    ev_nil.on { |ev| mock.nil_filter(ev.context) }
 
 	    mock.should_receive(:filtering).with(21).once
@@ -743,7 +812,7 @@ class TC_Event < Test::Unit::TestCase
 
     def test_gather_events
 	e1, e2 = (1..2).map { EventGenerator.new(true) }.
-	    each { |e| plan.discover(e) }
+	    each { |e| plan.add(e) }
 
 	collection = []
 
@@ -774,7 +843,7 @@ class TC_Event < Test::Unit::TestCase
 	master = EventGenerator.new do
 	    master.achieve_with slave
 	end
-	plan.discover([master, slave])
+	plan.add([master, slave])
 
 	master.call
 	assert(!master.happened?)
@@ -786,7 +855,7 @@ class TC_Event < Test::Unit::TestCase
 	master = EventGenerator.new do
 	    master.achieve_with slave
 	end
-	plan.discover([master, slave])
+	plan.add([master, slave])
 
 	master.call
 	assert(!master.happened?)
@@ -797,7 +866,7 @@ class TC_Event < Test::Unit::TestCase
 	master = EventGenerator.new do
 	    master.achieve_with(slave) { [21, 42] }
 	end
-	plan.discover([master, slave])
+	plan.add([master, slave])
 
 	master.call
 	slave.emit
@@ -808,28 +877,28 @@ class TC_Event < Test::Unit::TestCase
 
     def test_if_unreachable
 	FlexMock.use do |mock|
-	    plan.discover(ev = EventGenerator.new(true))
+	    plan.add(ev = EventGenerator.new(true))
 	    ev.if_unreachable(false) { mock.called }
 	    ev.if_unreachable(true) { mock.canceled_called }
 	    ev.call
 
 	    mock.should_receive(:called).once
 	    mock.should_receive(:canceled_called).never
-	    plan.garbage_collect
+	    engine.garbage_collect
 	end
     end
 
     def test_when_unreachable
-        plan.discover(ev = EventGenerator.new(true))
+        plan.add(ev = EventGenerator.new(true))
         ev.when_unreachable.on { |ev| mock.unreachable_fired }
         ev.call
-        plan.garbage_collect
+        engine.garbage_collect
         assert(ev.happened?)
     end
 
     def test_or_if_unreachable
-	plan.discover(e1 = EventGenerator.new(true))
-	plan.discover(e2 = EventGenerator.new(true))
+	plan.add(e1 = EventGenerator.new(true))
+	plan.add(e2 = EventGenerator.new(true))
 	a = e1 | e2
 	FlexMock.use do |mock|
 	    a.if_unreachable(false) { mock.called }
@@ -846,8 +915,8 @@ class TC_Event < Test::Unit::TestCase
 
     def test_and_if_unreachable
 	FlexMock.use do |mock|
-	    plan.discover(e1 = EventGenerator.new(true))
-	    plan.discover(e2 = EventGenerator.new(true))
+	    plan.add(e1 = EventGenerator.new(true))
+	    plan.add(e2 = EventGenerator.new(true))
 	    a = e1 & e2
 
 	    a.if_unreachable(false) { mock.called }
@@ -858,8 +927,8 @@ class TC_Event < Test::Unit::TestCase
 	end
 
 	FlexMock.use do |mock|
-	    plan.discover(e1 = EventGenerator.new(true))
-	    plan.discover(e2 = EventGenerator.new(true))
+	    plan.add(e1 = EventGenerator.new(true))
+	    plan.add(e2 = EventGenerator.new(true))
 	    a = e1 & e2
 
 	    a.if_unreachable(false) { mock.called }
@@ -871,7 +940,7 @@ class TC_Event < Test::Unit::TestCase
     end
 
     def test_dup
-	plan.discover(e = EventGenerator.new(true))
+	plan.add(e = EventGenerator.new(true))
 
 	e.call
 	new = e.dup
@@ -881,15 +950,20 @@ class TC_Event < Test::Unit::TestCase
     end
 
     def test_event_after
-	plan.discover(e = EventGenerator.new(true))
-        e.call
-        sleep(0.5)
-        plan.discover(delayed = e.last.after(1))
-        delayed.poll
-        assert(!delayed.happened?)
-        sleep(0.5)
-        delayed.poll
-        assert(delayed.happened?)
+	FlexMock.use(Time) do |time_proxy|
+	    current_time = Time.now + 5
+	    time_proxy.should_receive(:now).and_return { current_time }
+
+	    plan.add(e = EventGenerator.new(true))
+	    e.call
+	    current_time += 0.5
+	    plan.add(delayed = e.last.after(1))
+	    delayed.poll
+	    assert(!delayed.happened?)
+	    current_time += 0.5
+	    delayed.poll
+	    assert(delayed.happened?)
+	end
     end
 end