roby 0.8.0 → 3.0.0

data/lib/roby/test/common.rb

@@ -1,638 +1,415 @@
-require 'test/unit'
-require 'utilrb/time/to_hms'
+require 'minitest/spec'
+require 'roby/test/assertions'
+require 'flexmock/minitest'
+require 'timecop'
+
+# simplecov must be loaded FIRST. Only the files required after it gets loaded
+# will be profiled !!!
+if ENV['TEST_ENABLE_COVERAGE'] == '1' || ENV['TEST_COVERAGE_MODE']
+    mode = ENV['TEST_COVERAGE_MODE'] || 'simplecov'
+    begin
+        require mode
+    rescue LoadError => e
+        require 'roby'
+        Roby.warn "coverage is disabled because the code coverage gem cannot be loaded: #{e.message}"
+    rescue Exception => e
+        require 'roby'
+        Roby.warn "coverage is disabled: #{e.message}"
+    end
+end
+
+if ENV['TEST_ENABLE_PRY'] != '0'
+    begin
+        require 'pry'
+    rescue Exception
+        require 'roby'
+        Roby.warn "debugging is disabled because the 'pry' gem cannot be loaded"
+    end
+end
+
 require 'roby'
-require 'utilrb/module/attr_predicate'
+
+require 'roby/test/assertion'
+require 'roby/test/error'
+require 'roby/test/minitest_helpers'
+require 'roby/test/execution_expectations'
+require 'roby/test/validate_state_machine'
+require 'roby/test/teardown_plans'
+
+FlexMock.partials_are_based = true
 
 module Roby
+    # This module is defining common support for tests that need the Roby
+    # infrastructure
+    #
+    # It assumes that the tests are started using roby's test command. Tests
+    # using this module can NOT be started with only e.g. testrb.
+    #
+    # @see SelfTest
     module Test
-	include Roby
-	Unit = ::Test::Unit
-
-	BASE_PORT     = 1245
-	DISCOVERY_SERVER = "druby://localhost:#{BASE_PORT}"
-	REMOTE_PORT    = BASE_PORT + 1
-	LOCAL_PORT     = BASE_PORT + 2
-	REMOTE_SERVER  = "druby://localhost:#{BASE_PORT + 3}"
-	LOCAL_SERVER   = "druby://localhost:#{BASE_PORT + 4}"
+        include Roby
+        include TeardownPlans
 
+        extend Logger::Hierarchy
+        extend Logger::Forward
 
-	attr_reader :timings
-	class << self
-	    attr_accessor :check_allocation_count
-	end
+        BASE_PORT     = 21000
+        DISCOVERY_SERVER = "druby://localhost:#{BASE_PORT}"
+        REMOTE_PORT    = BASE_PORT + 1
+        LOCAL_PORT     = BASE_PORT + 2
+        REMOTE_SERVER  = "druby://localhost:#{BASE_PORT + 3}"
+        LOCAL_SERVER   = "druby://localhost:#{BASE_PORT + 4}"
 
-	# The plan used by the tests
+        # The plan used by the tests
         attr_reader :plan
         # The decision control component used by the tests
         attr_reader :control
-        def engine; plan.engine end
 
-	# Clear the plan and return it
-	def new_plan
-	    plan.clear
-	    plan
-	end
+        def execution_engine
+            plan.execution_engine if plan && plan.executable?
+        end
+
+        def execute(&block)
+            execution_engine.execute(&block)
+        end
+
+        # Clear the plan and return it
+        def new_plan
+            plan.clear
+            plan
+        end
+
+        def create_transaction
+            t = Roby::Transaction.new(plan)
+            @transactions << t
+            t
+        end
 
         def deprecated_feature
             Roby.enable_deprecation_warnings = false
+            flexmock(Roby).should_receive(:warn_deprecated).at_least.once
             yield
         ensure
             Roby.enable_deprecation_warnings = true
         end
 
-	# a [collection, collection_backup] array of the collections saved
-	# by #original_collections
-	attr_reader :original_collections
-
-	# Saves the current state of +obj+. This state will be restored by
-	# #restore_collections. +obj+ must respond to #<< to add new elements
-	# (hashes do not work whild arrays or sets do)
-	def save_collection(obj)
-	    original_collections << [obj, obj.dup]
-	end
-
-	# Restors the collections saved by #save_collection to their previous state
-	def restore_collections
-	    original_collections.each do |col, backup|
-		col.clear
-		if col.kind_of?(Hash)
-		    col.merge! backup
-		else
-		    backup.each(&col.method(:<<))
-		end
-	    end
-	end
-
-	def setup
-            super if defined? super
-
-	    @console_logger ||= false
-            @event_logger   ||= false
-	    if !defined? Roby::State
-                Roby.const_set(:State, StateSpace.new)
-            else
-                Roby::State.clear
-	    end
-
-	    @original_roby_logger_level = Roby.logger.level
-	    @timings = { :start => Time.now }
-
-	    @original_collections = []
-	    Thread.abort_on_exception = false
-	    @remote_processes = []
-
-            Roby.app.setup_loggers
-
-	    if Test.check_allocation_count
-		GC.start
-		GC.disable
-	    end
-
-	    unless DRb.primary_server
-		DRb.start_service 'druby://localhost:0'
-	    end
-
-	    if defined? Roby::Planning::Planner
-		Roby::Planning::Planner.last_id = 0 
-	    end
-
-            @plan ||= Plan.new
-            @control ||= DecisionControl.new
-            if !plan.engine
-                ExecutionEngine.new(@plan, @control)
-            end
-            plan.engine.gc_warning = false
-
-	    # Save and restore some arrays
-	    save_collection engine.propagation_handlers
-	    save_collection Roby::ExecutionEngine.propagation_handlers
-	    save_collection plan.structure_checks
-	    save_collection Roby::Plan.structure_checks
-	    save_collection engine.at_cycle_end_handlers
-	    save_collection Roby::EventGenerator.event_gathering
-	    Roby.app.abort_on_exception = true
-	    Roby.app.abort_on_application_exception = true
-
-	    save_collection engine.event_ordering
-	    save_collection engine.delayed_events
-	    save_collection plan.exception_handlers
-	    timings[:setup] = Time.now
-
-            engine.at_cycle_end(&Test.method(:check_event_assertions))
-            engine.finalizers << Test.method(:finalize_event_assertions)
-	end
-
-
-	def teardown_plan
-            engine.at_cycle_end_handlers.delete(Test.method(:check_event_assertions))
-            engine.finalizers.delete(Test.method(:finalize_event_assertions))
-
-	    old_gc_roby_logger_level = Roby.logger.level
-	    if debug_gc?
-		Roby.logger.level = Logger::DEBUG
-	    end
-
-	    if !engine.running?
-		engine.run
-	    end
-
-	    engine.quit
-	    engine.join
-	    plan.clear
-
-	ensure
-	    Roby.logger.level = old_gc_roby_logger_level
-	end
-
-	def teardown
-	    timings[:quit] = Time.now
-	    teardown_plan
-	    timings[:teardown_plan] = Time.now
-
-	    stop_remote_processes
-	    DRb.stop_service if DRb.thread
-
-	    restore_collections
-
-	    # Clear all relation graphs in TaskStructure and EventStructure
-	    spaces = []
-	    if defined? Roby::TaskStructure
-		spaces << Roby::TaskStructure
-	    end
-	    if defined? Roby::EventStructure
-		spaces << Roby::EventStructure
-	    end
-	    spaces.each do |space|
-		space.relations.each do |rel| 
-		    vertices = rel.enum_for(:each_vertex).to_a
-		    unless vertices.empty?
-			Roby.warn "  the following vertices are still present in #{rel}: #{vertices.to_a}"
-			vertices.each { |v| v.clear_vertex }
-		    end
-		end
-	    end
-
-	    Roby::TaskStructure::Hierarchy.interesting_events.clear
-	    if defined? Roby::Application
-		Roby.app.abort_on_exception = false
-		Roby.app.abort_on_application_exception = false
-	    end
-
-	    if defined? Roby::Log
-		Roby::Log.known_objects.clear
-	    end
-
-	    if Test.check_allocation_count
-		require 'utilrb/objectstats'
-		count = ObjectStats.count
-		GC.start
-		remains = ObjectStats.count
-		Roby.warn "#{count} -> #{remains} (#{count - remains})"
-	    end
-	    timings[:end] = Time.now
-
-	    if display_timings?
-		begin
-		    display_timings!
-		rescue
-		    Roby.warn $!.full_message
-		end
-	    end
-
-            super if defined? super
-
-	rescue Exception => e
-	    STDERR.puts "failed teardown: #{e.full_message}"
-
-	ensure
-	    while engine.running?
-		engine.quit
-		engine.join rescue nil
-	    end
-	    plan.clear
-            @plan = nil
-
-	    Roby.logger.level = @original_roby_logger_level
-	    self.console_logger = false
-            self.event_logger   = false
-	end
-
-	# Process pending events
-	def process_events
-	    Roby.synchronize do
-		engine.process_events
-	    end
-	end
-
-	# The list of children started using #remote_process
-	attr_reader :remote_processes
-
-	# Creates a set of tasks and returns them. Each task is given an unique
-	# 'id' which allows to recognize it in a failed assertion.
-	#
-	# Known options are:
-	# missions:: how many mission to create [0]
-	# discover:: how many tasks should be discovered [0]
-	# tasks:: how many tasks to create outside the plan [0]
-	# model:: the task model [Roby::Task]
-	# plan:: the plan to apply on [plan]
-	#
-	# The return value is [missions, discovered, tasks]
-	#   (t1, t2), (t3, t4, t5), (t6, t7) = prepare_plan :missions => 2,
-	#	:discover => 3, :tasks => 2
-	#
-	# An empty set is omitted
-	#   (t1, t2), (t6, t7) = prepare_plan :missions => 2, :tasks => 2
-	#
-	# If a set is a singleton, the only object of this singleton is returned
-	#   t1, (t6, t7) = prepare_plan :missions => 1, :tasks => 2
-	#    
-	def prepare_plan(options)
-	    options = validate_options options,
-		:missions => 0, :add => 0, :discover => 0, :tasks => 0,
-		:permanent => 0,
-		:model => Roby::Task, :plan => plan
-
-	    missions, permanent, added, tasks = [], [], [], []
-	    (1..options[:missions]).each do |i|
-		options[:plan].add_mission(t = options[:model].new(:id => "mission-#{i}"))
-		missions << t
-	    end
-	    (1..options[:permanent]).each do |i|
-		options[:plan].add_permanent(t = options[:model].new(:id => "perm-#{i}"))
-		permanent << t
-	    end
-	    (1..(options[:discover] + options[:add])).each do |i|
-		options[:plan].add(t = options[:model].new(:id => "discover-#{i}"))
-		added << t
-	    end
-	    (1..options[:tasks]).each do |i|
-		tasks << options[:model].new(:id => "task-#{i}")
-	    end
-
-	    result = []
-	    [missions, permanent, added, tasks].each do |set|
-		unless set.empty?
-		    set = *set
-		    result << set
-		end
-	    end
-	    if result.size == 1 then result.first
-	    else result
-	    end
-	end
-
-	# Start a new process and saves its PID in #remote_processes. If a block is
-	# given, it is called in the new child. #remote_process returns only after
-	# this block has returned.
-	def remote_process
-	    start_r, start_w= IO.pipe
-	    quit_r, quit_w = IO.pipe
-	    remote_pid = fork do
-                begin
-                    start_r.close
-                    yield
-                rescue Exception => e
-                    puts e.full_message
+        # a [collection, collection_backup] array of the collections saved
+        # by #original_collections
+        attr_reader :original_collections
+
+        # Saves the current state of +obj+. This state will be restored by
+        # #restore_collections. +obj+ must respond to #<< to add new elements
+        # (hashes do not work whild arrays or sets do)
+        def save_collection(obj)
+            original_collections << [obj, obj.dup]
+        end
+
+        # Restors the collections saved by #save_collection to their previous state
+        def restore_collections
+            original_collections.each do |col, backup|
+                col.clear
+                if col.kind_of?(Hash)
+                    col.merge! backup
+                else
+                    backup.each do |obj|
+                        col << obj
+                    end
                 end
+            end
+            original_collections.clear
+        end
 
-                start_w.write('OK')
-                quit_r.read(2)
-	    end
-	    start_w.close
-	    result = start_r.read(2)
-
-	    remote_processes << [remote_pid, quit_w]
-	    remote_pid
-
-	ensure
-	    # start_r.close
-	end
-
-	# Stop all the remote processes that have been started using #remote_process
-	def stop_remote_processes
-	    remote_processes.reverse.each do |pid, quit_w|
-		begin
-		    quit_w.write('OK') 
-		rescue Errno::EPIPE
-		end
-		begin
-		    Process.waitpid(pid)
-		rescue Errno::ECHILD
-		end
-	    end
-	    remote_processes.clear
-	end
-
-	# Exception raised in the block of assert_doesnt_timeout when the timeout
-	# is reached
-	class FailedTimeout < RuntimeError; end
-
-	def assert_original_error(klass, localized_error_type = LocalizedError)
-	    old_level = Roby.logger.level
-	    Roby.logger.level = Logger::FATAL
-	    assert_nothing_raised do
-		begin
-		    yield
-		rescue Exception => e
-                    assert_kind_of(localized_error_type, e)
-		    assert_respond_to(e, :error)
-		    assert_kind_of(klass, e.error)
-		end
-	    end
-	ensure
-	    Roby.logger.level = old_level
-	end
-
-	# Checks that the given block returns within +seconds+ seconds
-	def assert_doesnt_timeout(seconds, message = "watchdog #{seconds} failed")
-	    watched_thread = Thread.current
-	    watchdog = Thread.new do
-		sleep(seconds)
-		watched_thread.raise FailedTimeout
-	    end
-
-	    assert_block(message) do
-		begin
-		    yield
-		    true
-		rescue FailedTimeout
-		ensure
-		    watchdog.kill
-		    watchdog.join
-		end
-	    end
-	end
-
-	def assert_marshallable(object)
-	    begin
-		Marshal.dump(object)
-		true
-	    rescue TypeError
-	    end
-	end
-
-	# The console logger object. See #console_logger=
-	attr_reader :console_logger
-
-	attr_predicate :debug_gc?, true
-	attr_predicate :display_timings?, true
-	def display_timings!
-	    timings = self.timings.sort_by { |_, t| t }
-	    ref = timings[0].last
-
-	    format, header, times = "", [], []
-	    format << "%#{method_name.size}s"
-	    header << method_name
-	    times  << ""
-	    timings.each do |name, time| 
-		name = name.to_s
-		time = "%.2f" % [time - ref]
-
-		col_size = [name.size, time.size].max
-		format << " % #{col_size}s"
-		header << name
-		times << time
-	    end
-
-	    puts
-	    puts format % header
-	    puts format % times
-	end
-
-	# Enable display of all plan events on the console
-	def console_logger=(value)
-	    if value && !@console_logger
-		require 'roby/log/console'
-		@console_logger = Roby::Log::ConsoleLogger.new(STDERR)
-		Roby::Log.add_logger console_logger
-	    elsif @console_logger
-		Roby::Log.remove_logger console_logger
-		@console_logger = nil
-	    end
-	end
-
-        attr_reader :event_logger
-        def event_logger=(value)
-            if value && !@event_logger
-		require 'roby/log/file'
-		logfile = @method_name + ".log"
-		logger  = Roby::Log::FileLogger.new(logfile)
-		logger.stats_mode = false
-		Roby::Log.add_logger logger
-                @event_logger = logger
-            elsif !value && @event_logger
-                Roby::Log.remove_logger @event_logger
-                @event_logger = nil
+        attr_reader :app
+
+        def setup
+            @app = Roby.app
+            @app.development_mode = false
+            Roby.app.reload_config
+            @log_levels = Hash.new
+            @transactions = Array.new
+
+            if !@plan
+                @plan = Roby.app.plan
+            end
+            register_plan(@plan)
+
+            super
+
+            @console_logger ||= false
+            @event_logger   ||= false
+
+            @original_roby_logger_level = Roby.logger.level
+
+            @original_collections = []
+            Thread.abort_on_exception = false
+            @remote_processes = []
+
+            Roby.app.log_server = false
+
+            plan.execution_engine.gc_warning = false
+
+            @watched_events = nil
+            @handler_ids = Array.new
+        end
+
+        # @deprecated use {Assertions#capture_log} instead
+        def inhibit_fatal_messages(&block)
+            Roby.warn_deprecated "##{__method__} is deprecated, use #capture_log instead"
+            with_log_level(Roby, Logger::FATAL, &block)
+        end
+
+        # @deprecated use {Assertions#capture_log} instead
+        def set_log_level(log_object, level)
+            Roby.warn_deprecated "#set_log_level is deprecated, use #capture_log instead"
+            if log_object.respond_to?(:logger)
+                log_object = log_object.logger
             end
+            @log_levels[log_object] ||= log_object.level
+            log_object.level = level
         end
 
-	def wait_thread_stopped(thread)
-	    while !thread.stop?
-		sleep(0.1)
-		raise "#{thread} died" unless thread.alive?
-	    end
-	end
-
-	def display_event_structure(object, relation, indent = "  ")
-	    result   = object.to_s
-	    object.history.each do |event|
-		result << "#{indent}#{event.time.to_hms} #{event}"
-	    end
-	    children = object.child_objects(relation)
-	    unless children.empty?
-		result << " ->\n" << indent
-		children.each do |child|
-		    result << display_event_structure(child, relation, indent + "  ")
-		end
-	    end
-
-	    result
-	end
-
-	@event_assertions = []
-	@waiting_threads  = []
-
-	ASSERT_ANY_EVENTS_TLS = :assert_any_events
-
-        class << self
-            # A [thread, cv, positive, negative] list of event assertions
-            attr_reader :event_assertions
+        # @deprecated use {Assertions#capture_log} instead
+        def reset_log_levels(warn_deprecated: true)
+            if warn_deprecated
+                Roby.warn_deprecated "##{__method__} is deprecated, use #capture_log instead"
+            end
+            @log_levels.each do |log_object, level|
+                log_object.level = level
+            end
+            @log_levels.clear
         end
 
-        # Tests for events in +positive+ and +negative+ and returns
-        # the set of failing events if the assertion has finished.
-        # If the set is empty, it means that the assertion finished
-        # successfully
-        def self.assert_any_event_result(positive, negative)
-            if positive_ev = positive.find { |ev| ev.happened? }
-                return false, "#{positive_ev} happened"
+        # @deprecated use {Assertions#capture_log} instead
+        def with_log_level(log_object, level)
+            Roby.warn_deprecated "##{__method__} is deprecated, use #capture_log instead"
+            if log_object.respond_to?(:logger)
+                log_object = log_object.logger
+            end
+            current_level = log_object.level
+            log_object.level = level
+
+            yield
+
+        ensure
+            if current_level
+                log_object.level = current_level
             end
-            failure = negative.find_all { |ev| ev.happened? }
-            unless failure.empty?
-                return true, "#{failure} happened"
+        end
+
+        def teardown
+            Timecop.return
+
+            @transactions.each do |trsc|
+                if !trsc.finalized?
+                    trsc.discard_transaction
+                end
             end
+            teardown_registered_plans
 
-            if positive.all? { |ev| ev.unreachable? }
-                positive.each do |ev|
-                    Robot.info "#{ev} is unreachable because of the following emission:"
-                    Roby.log_exception(ev.unreachability_reason, Robot.logger, :info)
+            if @handler_ids && execution_engine
+                @handler_ids.each do |handler_id|
+                    execution_engine.remove_propagation_handler(handler_id)
                 end
-                return true, "all positive events are unreachable"
             end
 
-            nil
+            # Plan teardown would have disconnected the peers already
+            stop_remote_processes
+
+            restore_collections
+
+            if defined? Roby::Application
+                Roby.app.abort_on_exception = false
+                Roby.app.abort_on_application_exception = true
+            end
+
+            super
+
+        ensure
+            reset_log_levels(warn_deprecated: false)
+            clear_registered_plans
+
+            if @original_roby_logger_level
+                Roby.logger.level = @original_roby_logger_level
+            end
+        end
+        
+        # Process pending events
+        def process_events(timeout: 2, enable_scheduler: nil, join_all_waiting_work: true, raise_errors: true, garbage_collect_pass: true, &caller_block)
+            Roby.warn_deprecated "Test#process_events is deprecated, use #expect_execution instead"
+            exceptions = Array.new
+            registered_plans.each do |p|
+                engine = p.execution_engine
+
+                begin
+                    engine.start_new_cycle
+                    errors =
+                        begin
+                            current_scheduler_state = engine.scheduler.enabled?
+                            if !enable_scheduler.nil?
+                                engine.scheduler.enabled = enable_scheduler
+                            end
+
+                            engine.process_events(garbage_collect_pass: garbage_collect_pass, &caller_block)
+                        ensure
+                            engine.scheduler.enabled = current_scheduler_state
+                        end
+
+                    if join_all_waiting_work
+                        engine.join_all_waiting_work(timeout: timeout)
+                    end
+
+                    exceptions.concat(errors.exceptions)
+                    engine.cycle_end(Hash.new)
+                    caller_block = nil
+                end while engine.has_waiting_work? && join_all_waiting_work
+            end
+
+            if raise_errors && !exceptions.empty?
+                if exceptions.size == 1
+                    e = exceptions.first
+                    raise e.exception
+                else
+                    raise SynchronousEventProcessingMultipleErrors.new(exceptions.map(&:exception))
+                end
+            end
         end
 
-        # This method is inserted in the control thread to implement
-        # Assertions#assert_events
-        def self.check_event_assertions
-            event_assertions.delete_if do |thread, cv, positive, negative|
-                error, result = Test.assert_any_event_result(positive, negative)
-                if !error.nil?
-                    thread[ASSERT_ANY_EVENTS_TLS] = [error, result]
-                    cv.broadcast
-                    true
+        # Repeatedly process events until a condition is met
+        #
+        # @yieldreturn [Boolean] true if the condition is met, false otherwise
+        #
+        # @param (see #process_events)
+        def process_events_until(timeout: 5, join_all_waiting_work: false, **options)
+            Roby.warn_deprecated "Test#process_events_until is deprecated, use #expect_execution.to { achieve { ... } } instead"
+            start = Time.now
+            while !yield
+                now = Time.now
+                remaining = timeout - (now - start)
+                if remaining < 0
+                    flunk("failed to reach condition #{proc} within #{timeout} seconds")
                 end
+                process_events(timeout: remaining, join_all_waiting_work: join_all_waiting_work, **options)
+                sleep 0.01
             end
         end
 
-        def self.finalize_event_assertions
-            check_event_assertions
-            event_assertions.dup.each do |thread, *_|
-                thread.raise ControlQuitError
+        # Use to call the original method on a partial mock
+        def flexmock_call_original(object, method, *args, &block)
+            Test.warn "#flexmock_call_original is deprecated, use #flexmock_invoke_original instead"
+            flexmock_invoke_original(object, method, *args, &block)
+        end
+
+        # Use to call the original method on a partial mock
+        def flexmock_invoke_original(object, method, *args, &block)
+            object.instance_variable_get(:@flexmock_proxy).proxy.flexmock_invoke_original(method, args, &block)
+        end
+
+        # The list of children started using #remote_process
+        attr_reader :remote_processes
+
+        # Creates a set of tasks and returns them. Each task is given an unique
+        # 'id' which allows to recognize it in a failed assertion.
+        #
+        # Known options are:
+        # missions:: how many mission to create [0]
+        # discover:: how many tasks should be discovered [0]
+        # tasks:: how many tasks to create outside the plan [0]
+        # model:: the task model [Roby::Task]
+        # plan:: the plan to apply on [plan]
+        #
+        # The return value is [missions, discovered, tasks]
+        #   (t1, t2), (t3, t4, t5), (t6, t7) = prepare_plan missions: 2,
+        #       discover: 3, tasks: 2
+        #
+        # An empty set is omitted
+        #   (t1, t2), (t6, t7) = prepare_plan missions: 2, tasks: 2
+        #
+        # If a set is a singleton, the only object of this singleton is returned
+        #   t1, (t6, t7) = prepare_plan missions: 1, tasks: 2
+        #    
+        def prepare_plan(options)
+            options = validate_options options,
+                missions: 0, add: 0, discover: 0, tasks: 0,
+                permanent: 0,
+                model: Roby::Task, plan: plan
+
+            missions, permanent, added, tasks = [], [], [], []
+            (1..options[:missions]).each do |i|
+                options[:plan].add_mission_task(t = options[:model].new(id: "mission-#{i}"))
+                missions << t
+            end
+            (1..options[:permanent]).each do |i|
+                options[:plan].add_permanent_task(t = options[:model].new(id: "perm-#{i}"))
+                permanent << t
+            end
+            (1..(options[:discover] + options[:add])).each do |i|
+                options[:plan].add(t = options[:model].new(id: "discover-#{i}"))
+                added << t
+            end
+            (1..options[:tasks]).each do |i|
+                tasks << options[:model].new(id: "task-#{i}")
+            end
+
+            result = []
+            [missions, permanent, added, tasks].each do |set|
+                unless set.empty?
+                    result << set
+                end
             end
+
+            result = result.map do |set|
+                if set.size == 1 then set.first
+                else set
+                end
+            end
+
+            if result.size == 1
+                return result.first
+            end
+            return *result
         end
 
-	module Assertions
-	    # Wait for any event in +positive+ to happen. If +negative+ is
-	    # non-empty, any event happening in this set will make the
-	    # assertion fail. If events in +positive+ are task events, the
-	    # :stop events of the corresponding tasks are added to negative
-	    # automatically.
-	    #
-	    # If a block is given, it is called from within the control thread
-	    # after the checks are in place
-	    #
-	    # So, to check that a task fails, do
-	    #
-	    #	assert_events(task.event(:fail)) do
-	    #	    task.start!
-	    #	end
-	    #
-	    def assert_any_event(positive, negative = [], msg = nil, &block)
-		control_priority do
-                    engine.waiting_threads << Thread.current
-		    Roby.condition_variable(false) do |cv|
-			positive = Array[*positive].to_value_set
-			negative = Array[*negative].to_value_set
-
-			unreachability_reason = ValueSet.new
-			Roby.synchronize do
-			    positive.each do |ev|
-				ev.if_unreachable(true) do |reason|
-				    unreachability_reason << reason if reason
-				end
-			    end
-
-			    error, result = Test.assert_any_event_result(positive, negative)
-			    if error.nil?
-				this_thread = Thread.current
-
-				Test.event_assertions << [this_thread, cv, positive, negative]
-				engine.once(&block) if block_given?
-				begin
-				    cv.wait(Roby.global_lock)
-				ensure
-				    Test.event_assertions.delete_if { |thread, _| thread == this_thread }
-				end
-
-				error, result = this_thread[ASSERT_ANY_EVENTS_TLS]
-			    end
-
-			    if error
-				if !unreachability_reason.empty?
-				    msg = unreachability_reason.map do |reason|
-					if reason.respond_to?(:context)
-					    context = (reason.context || []).map do |obj|
-						if obj.kind_of?(Exception)
-						    obj.full_message
-						else
-						    obj.to_s
-						end
-					    end
-					    reason.to_s + context.join("\n  ")
-					end
-				    end
-				    msg.join("\n  ")
-
-				    flunk("#{msg} all positive events are unreachable for the following reason:\n  #{msg}")
-				elsif msg
-				    flunk("#{msg} failed: #{result}")
-				else
-				    flunk(result)
-				end
-			    end
-			end
-		    end
-		end
-            ensure
-                engine.waiting_threads.delete(Thread.current)
-	    end
-
-	    # Starts +task+ and checks it succeeds
-	    def assert_succeeds(task, *args)
-		control_priority do
-		    if !task.kind_of?(Roby::Task)
-			engine.execute do
-			    plan.add_mission(task = planner.send(task, *args))
-			end
-		    end
-
-		    assert_any_event([task.event(:success)], [], nil) do
-			plan.add_permanent(task)
-			task.start! if task.pending?
-			yield if block_given?
-		    end
-		end
-	    end
-
-	    def control_priority
-                if !engine.thread
-                    return yield
+        # Start a new process and saves its PID in #remote_processes. If a block is
+        # given, it is called in the new child. #remote_process returns only after
+        # this block has returned.
+        def remote_process
+            start_r, start_w= IO.pipe
+            quit_r, quit_w = IO.pipe
+            remote_pid = fork do
+                begin
+                    start_r.close
+                    yield
+                rescue Exception => e
+                    puts e.full_message
                 end
 
-		old_priority = Thread.current.priority 
-		Thread.current.priority = engine.thread.priority + 1
-
-		yield
-	    ensure
-		Thread.current.priority = old_priority if old_priority
-	    end
-
-	    # This assertion fails if the relative error between +found+ and
-	    # +expected+is more than +error+
-	    def assert_relative_error(expected, found, error, msg = "")
-		if expected == 0
-		    assert_in_delta(0, found, error, "comparing #{found} to #{expected} in #{msg}")
-		else
-		    assert_in_delta(0, (found - expected) / expected, error, "comparing #{found} to #{expected} in #{msg}")
-		end
-	    end
-
-	    # This assertion fails if +found+ and +expected+ are more than +dl+
-	    # meters apart in the x, y and z coordinates, or +dt+ radians apart
-	    # in angles
-	    def assert_same_position(expected, found, dl = 0.01, dt = 0.01, msg = "")
-		assert_relative_error(expected.x, found.x, dl, msg)
-		assert_relative_error(expected.y, found.y, dl, msg)
-		assert_relative_error(expected.z, found.z, dl, msg)
-		assert_relative_error(expected.yaw, found.yaw, dt, msg)
-		assert_relative_error(expected.pitch, found.pitch, dt, msg)
-		assert_relative_error(expected.roll, found.roll, dt, msg)
-	    end
-	end
+                start_w.write('OK')
+                quit_r.read(2)
+            end
+            start_w.close
+            result = start_r.read(2)
+
+            remote_processes << [remote_pid, quit_w]
+            remote_pid
+
+        ensure
+            # start_r.close
+        end
 
+        # Stop all the remote processes that have been started using #remote_process
+        def stop_remote_processes
+            remote_processes.reverse.each do |pid, quit_w|
+                begin
+                    quit_w.write('OK') 
+                rescue Errno::EPIPE
+                end
+                begin
+                    Process.waitpid(pid)
+                rescue Errno::ECHILD
+                end
+            end
+            remote_processes.clear
+        end
     end
 end