roby 0.7.3 → 0.8.0

data/lib/roby/task_index.rb

@@ -0,0 +1,80 @@
+module Roby
+    # TaskIndex objects are used to maintain a set of tasks as classified sets,
+    # speeding up query operations. See Plan#task_index.
+    class TaskIndex
+        # A model => ValueSet map of the tasks for each model
+	attr_reader :by_model
+	# A state => ValueSet map of tasks given their state. The state is
+	# a symbol in [:pending, :starting, :running, :finishing,
+	# :finished]
+	attr_reader :by_state
+	# A peer => ValueSet map of tasks given their owner.
+	attr_reader :by_owner
+	# The set of tasks which have an event which is being repaired
+	attr_reader :repaired_tasks
+
+	STATE_PREDICATES = [:pending?, :running?, :finished?, :success?, :failed?].to_value_set
+
+	def initialize
+	    @by_model = Hash.new { |h, k| h[k] = ValueSet.new }
+	    @by_state = Hash.new
+	    STATE_PREDICATES.each do |state_name|
+		by_state[state_name] = ValueSet.new
+	    end
+	    @by_owner = Hash.new
+	    @task_state = Hash.new
+	    @repaired_tasks = ValueSet.new
+	end
+
+        # Add a new task to this index
+	def add(task)
+	    for klass in task.model.ancestors
+		by_model[klass] << task
+	    end
+	    by_state[:pending?] << task
+	    for owner in task.owners
+		add_owner(task, owner)
+	    end
+	end
+
+        # Updates the index to reflect that +new_owner+ now owns +task+
+	def add_owner(task, new_owner)
+	    (by_owner[new_owner] ||= ValueSet.new) << task
+	end
+
+        # Updates the index to reflect that +peer+ no more owns +task+
+	def remove_owner(task, peer)
+	    if set = by_owner[peer]
+		set.delete(task)
+		if set.empty?
+		    by_owner.delete(peer)
+		end
+	    end
+	end
+
+        # Updates the index to reflect a change of state for +task+
+	def set_state(task, new_state)
+	    for state_set in by_state
+		state_set.last.delete(task)
+	    end
+	    by_state[new_state] << task
+	    if new_state == :success? || new_state == :failed?
+		by_state[:finished?] << task
+	    end
+	end
+
+        # Remove all references of +task+ from the index.
+	def remove(task)
+	    for klass in task.model.ancestors
+		by_model[klass].delete(task)
+	    end
+	    for state_set in by_state
+		state_set.last.delete(task)
+	    end
+	    for owner in task.owners
+		remove_owner(task, owner)
+	    end
+	end
+    end
+end
+

data/lib/roby/test/common.rb

@@ -22,14 +22,24 @@ module Roby
 	end
 
 	# The plan used by the tests
-	def plan; Roby.plan end
+        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
-	    Roby.plan.clear
+	    plan.clear
 	    plan
 	end
 
+        def deprecated_feature
+            Roby.enable_deprecation_warnings = false
+            yield
+        ensure
+            Roby.enable_deprecation_warnings = true
+        end
+
 	# a [collection, collection_backup] array of the collections saved
 	# by #original_collections
 	attr_reader :original_collections
@@ -54,18 +64,25 @@ module Roby
 	end
 
 	def setup
+            super if defined? super
+
 	    @console_logger ||= false
+            @event_logger   ||= false
 	    if !defined? Roby::State
-		Roby.app.reset
+                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 = true
+	    Thread.abort_on_exception = false
 	    @remote_processes = []
 
+            Roby.app.setup_loggers
+
 	    if Test.check_allocation_count
 		GC.start
 		GC.disable
@@ -79,34 +96,48 @@ module Roby
 		Roby::Planning::Planner.last_id = 0 
 	    end
 
-	    # Save and restore Control's global arrays
-	    save_collection Roby::Control.event_processing
-	    save_collection Roby::Control.structure_checks
-	    save_collection Roby::Control.at_cycle_end_handlers
-	    save_collection Roby::EventGenerator.event_gathering
-	    Roby.control.abort_on_exception = true
-	    Roby.control.abort_on_application_exception = true
-	    Roby.control.abort_on_framework_exception = true
+            @plan ||= Plan.new
+            @control ||= DecisionControl.new
+            if !plan.engine
+                ExecutionEngine.new(@plan, @control)
+            end
+            plan.engine.gc_warning = false
 
-	    save_collection Roby::Propagation.event_ordering
-	    save_collection Roby::Propagation.delayed_events
+	    # 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 Roby.exception_handlers
+	    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 !Roby.control.running?
-		Roby.control.run :detach => true
+	    if !engine.running?
+		engine.run
 	    end
 
-	    Roby.control.quit
-	    Roby.control.join
+	    engine.quit
+	    engine.join
 	    plan.clear
 
 	ensure
@@ -142,10 +173,9 @@ module Roby
 	    end
 
 	    Roby::TaskStructure::Hierarchy.interesting_events.clear
-	    if defined? Roby::Control
-		Roby.control.abort_on_exception = false
-		Roby.control.abort_on_application_exception = false
-		Roby.control.abort_on_framework_exception = false
+	    if defined? Roby::Application
+		Roby.app.abort_on_exception = false
+		Roby.app.abort_on_application_exception = false
 	    end
 
 	    if defined? Roby::Log
@@ -169,24 +199,28 @@ module Roby
 		end
 	    end
 
+            super if defined? super
+
 	rescue Exception => e
 	    STDERR.puts "failed teardown: #{e.full_message}"
 
 	ensure
-	    while Roby.control.running?
-		Roby.control.quit
-		Roby.control.join rescue nil
+	    while engine.running?
+		engine.quit
+		engine.join rescue nil
 	    end
-	    Roby.plan.clear
+	    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::Control.synchronize do
-		Roby.control.process_events
+	    Roby.synchronize do
+		engine.process_events
 	    end
 	end
 
@@ -215,29 +249,29 @@ module Roby
 	#    
 	def prepare_plan(options)
 	    options = validate_options options,
-		:missions => 0, :discover => 0, :tasks => 0,
+		:missions => 0, :add => 0, :discover => 0, :tasks => 0,
 		:permanent => 0,
 		:model => Roby::Task, :plan => plan
 
-	    missions, permanent, discovered, tasks = [], [], [], []
+	    missions, permanent, added, tasks = [], [], [], []
 	    (1..options[:missions]).each do |i|
-		options[:plan].insert(t = options[:model].new(:id => "mission-#{i}"))
+		options[:plan].add_mission(t = options[:model].new(:id => "mission-#{i}"))
 		missions << t
 	    end
 	    (1..options[:permanent]).each do |i|
-		options[:plan].permanent(t = options[:model].new(:id => "perm-#{i}"))
+		options[:plan].add_permanent(t = options[:model].new(:id => "perm-#{i}"))
 		permanent << t
 	    end
-	    (1..options[:discover]).each do |i|
-		options[:plan].discover(t = options[:model].new(:id => "discover-#{i}"))
-		discovered << t
+	    (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, discovered, tasks].each do |set|
+	    [missions, permanent, added, tasks].each do |set|
 		unless set.empty?
 		    set = *set
 		    result << set
@@ -255,19 +289,24 @@ module Roby
 	    start_r, start_w= IO.pipe
 	    quit_r, quit_w = IO.pipe
 	    remote_pid = fork do
-		start_r.close
-		yield
-		start_w.write('OK')
-		quit_r.read(2)
+                begin
+                    start_r.close
+                    yield
+                rescue Exception => e
+                    puts e.full_message
+                end
+
+                start_w.write('OK')
+                quit_r.read(2)
 	    end
 	    start_w.close
-	    start_r.read(2)
+	    result = start_r.read(2)
 
 	    remote_processes << [remote_pid, quit_w]
 	    remote_pid
 
 	ensure
-	    start_r.close
+	    # start_r.close
 	end
 
 	# Stop all the remote processes that have been started using #remote_process
@@ -295,7 +334,8 @@ module Roby
 	    assert_nothing_raised do
 		begin
 		    yield
-		rescue localized_error_type => e
+		rescue Exception => e
+                    assert_kind_of(localized_error_type, e)
 		    assert_respond_to(e, :error)
 		    assert_kind_of(klass, e.error)
 		end
@@ -372,6 +412,21 @@ module Roby
 	    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
+            end
+        end
+
 	def wait_thread_stopped(thread)
 	    while !thread.stop?
 		sleep(0.1)
@@ -394,6 +449,190 @@ module Roby
 
 	    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
+        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"
+            end
+            failure = negative.find_all { |ev| ev.happened? }
+            unless failure.empty?
+                return true, "#{failure} happened"
+            end
+
+            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)
+                end
+                return true, "all positive events are unreachable"
+            end
+
+            nil
+        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
+                end
+            end
+        end
+
+        def self.finalize_event_assertions
+            check_event_assertions
+            event_assertions.dup.each do |thread, *_|
+                thread.raise ControlQuitError
+            end
+        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
+                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
+
     end
 end