roby 0.8.0 → 3.0.0

data/lib/roby/test/tasks/empty_task.rb

@@ -1,9 +1,9 @@
 module Roby
     module Test
-	class EmptyTask < Roby::Task
-	    terminates
-	    forward :start => :success
-	end
+        class EmptyTask < Roby::Task
+            terminates
+            forward start: :success
+        end
     end
 end
 

data/lib/roby/test/tasks/goto.rb

@@ -1,36 +1,37 @@
 
 module Roby
     module Test
-	class Goto2D < Roby::Task
-	    terminates
-	    argument :x, :y
+        class Goto2D < Roby::Task
+            terminates
+            argument :x
+            argument :y
 
-	    def speed; State.goto_speed end
-	    def x; arguments[:x] end
-	    def y; arguments[:y] end
+            def speed; State.goto_speed end
+            def x; arguments[:x] end
+            def y; arguments[:y] end
 
-	    poll do
-		dx = x - State.pos.x
-		dy = y - State.pos.y
-		d = Math.sqrt(dx * dx + dy * dy)
-		if d > speed
-		    State.pos.x += speed * dx / d
-		    State.pos.y += speed * dy / d
- 		else
-		    State.pos.x = x
-		    State.pos.y = y
-		    emit :success
-		end
-		STDERR.puts "#{x} #{y} #{speed} #{State.pos}"
-	    end
+            poll do
+                dx = x - State.pos.x
+                dy = y - State.pos.y
+                d = Math.sqrt(dx * dx + dy * dy)
+                if d > speed
+                    State.pos.x += speed * dx / d
+                    State.pos.y += speed * dy / d
+                else
+                    State.pos.x = x
+                    State.pos.y = y
+                    emit :success
+                end
+                STDERR.puts "#{x} #{y} #{speed} #{State.pos}"
+            end
 
-	    module Planning
-		planning_library
-		method(:go_to) do
-		    Goto2D.new(arguments)
-		end
-	    end
-	end
+            module Planning
+                planning_library
+                method(:go_to) do
+                    Goto2D.new(arguments)
+                end
+            end
+        end
     end
 end
 

data/lib/roby/test/teardown_plans.rb

@@ -0,0 +1,100 @@
+module Roby
+    module Test
+        module TeardownPlans
+            attr_reader :registered_plans
+
+            def register_plan(plan)
+                if !plan
+                    raise "registering nil plan"
+                end
+                (@registered_plans ||= Array.new) << plan
+            end
+
+            def clear_registered_plans
+                registered_plans.each do |p|
+                    if p.respond_to?(:execution_engine)
+                        p.execution_engine.killall
+                        p.execution_engine.reset
+                        execute(plan: p) { p.clear }
+                    end
+                end
+                registered_plans.clear
+            end
+
+            def teardown_registered_plans
+                old_gc_roby_logger_level = Roby.logger.level
+                if self.registered_plans.all? { |p| p.empty? }
+                    return
+                end
+
+                plans = self.registered_plans.map do |p|
+                    if p.executable?
+                        [p, p.execution_engine, Set.new, Set.new]
+                    end
+                end.compact
+
+                counter = 0
+                while !plans.empty?
+                    plans = plans.map do |plan, engine, last_tasks, last_quarantine|
+                        plan_quarantine = plan.quarantined_tasks
+                        if counter > 100
+                            Roby.warn "more than #{counter} iterations while trying to shut down #{plan} after #{self.class.name}##{name}, quarantine=#{plan_quarantine.size} tasks, tasks=#{plan.tasks.size} tasks"
+                            if last_tasks != plan.tasks
+                                Roby.warn "Known tasks:"
+                                plan.tasks.each do |t|
+                                    Roby.warn "  #{t} running=#{t.running?} finishing=#{t.finishing?}"
+                                end
+                                last_tasks = plan.tasks.dup
+                            end
+                            if last_quarantine != plan_quarantine
+                                Roby.warn "Quarantined tasks:"
+                                plan_quarantine.each do |t|
+                                    Roby.warn "  #{t}"
+                                end
+                                last_quarantine = plan_quarantine.dup
+                            end
+                            sleep 1
+                        end
+                        engine.killall
+
+                        quarantine_and_dependencies = plan.compute_useful_tasks(plan.quarantined_tasks)
+                        
+                        if quarantine_and_dependencies.size != plan.tasks.size
+                            [plan, engine, last_tasks, last_quarantine]
+                        end
+                    end.compact
+                    counter += 1
+                end
+
+                registered_plans.each do |plan|
+                    if !plan.empty?
+                        if plan.tasks.all? { |t| t.pending? }
+                            plan.clear
+                        else
+                            Roby.warn "failed to teardown: #{plan} has #{plan.tasks.size} tasks and #{plan.free_events.size} events, #{plan.quarantined_tasks.size} of which are in quarantine"
+                            if !plan.execution_engine
+                                Roby.warn "this is most likely because this plan does not have an execution engine. Either add one or clear the plan in the tests"
+                            end
+                        end
+                    end
+                    plan.clear
+                    if engine = plan.execution_engine
+                        engine.clear
+                        engine.emitted_events.clear
+                    end
+
+                    if !plan.transactions.empty?
+                        Roby.warn "  #{plan.transactions.size} transactions left attached to the plan"
+                        plan.transactions.each do |trsc|
+                            trsc.discard_transaction
+                        end
+                    end
+                end
+
+            ensure
+                Roby.logger.level = old_gc_roby_logger_level
+            end
+        end
+    end
+end
+

data/lib/roby/test/testcase.rb

@@ -6,318 +6,250 @@
 
 module Roby
     module Test
-	extend Logger::Hierarchy
-	extend Logger::Forward
-
-	# This is the base class for running tests which uses a Roby control
-	# loop (i.e. plan execution).
-	#
-	# Because configuration and planning can be robot-specific, parts of
-	# the tests can also be splitted into generic parts and specific parts.
-	# The TestCase.robot statement allows to specify that a given test case
-	# is specific to a given robot, in which case it is ran only if the
-	# call to <tt>scripts/test</tt> specified a robot which matches (i.e.
-	# same name and type).
-	#
-	# Finally, two other mode of operation control the way tests are ran
-	# [simulation]
-	#   if the <tt>--sim</tt> flag is given to <tt>scripts/test</tt>, the
-	#   tests are ran under simulation. Otherwise, they are run in live
-	#   mode (see Roby::Application for a description of simulation and
-	#   live modes). It is possible to constrain that a given test method
-	#   is run only in simulation or live mode with the TestCase.sim and
-	#   TestCase.nosim statements:
-	#
-	#     sim :sim_only
-	#     def test_sim_only
-	#     end
-	#
-	#     nosim :live_only
-	#     def test_live_only
-	#     end
-	# [interactive]
-	#   Sometime, it is hard to actually assess the quality of processing
-	#   results automatically. In these cases, it is possible to show the
-	#   user the result of data processing, and then ask if the result is
-	#   valid by using the #user_validation method. Nonetheless, the tests
-	#   can be ran in automatic mode, in which the assertions which require
-	#   user validation are simply skipped. The <tt>--interactive</tt> or
-	#   <tt>-i</tt> flags of <tt>scripts/test</tt> specify that user
-	#   interaction is possible.
-	class TestCase < Test::Unit::TestCase
-	    include Roby::Test
-	    include Assertions
-	    class << self
-		attribute(:case_config) { Hash.new }
-		attribute(:methods_config) { Hash.new }
-		attr_reader :app_setup
-	    end
-
-	    # Sets the robot configuration for this test case. If a block is
-	    # given, it is called between the time the robot configuration is
-	    # loaded and the time the test methods are started. It can
-	    # therefore be used to change the robot configuration for the need
-	    # of this particular test case
-	    def self.robot(name, kind = name, &block)
-		@app_setup = [name, kind, block]
-		apply_robot_setup
-	    end
-
-	    @@first_time = true
-	    # Loads the configuration as specified by TestCase.robot
-	    def self.apply_robot_setup
-		app = Roby.app
-		if @@first_time
-		    # Make sure the log directory is empty
-		    if File.exists?(app.log_dir)
-			if !Dir.new(app.log_dir).empty?
-			    if !STDIN.ask("#{app.log_dir} still exists and must be cleaned before starting. Proceed ? [N,y]", false)
-				raise "user abort"
-			    end
-			end
-			FileUtils.rm_rf app.log_dir
-		    end
-		    @@first_time = false
-		end
-
-		name, kind, block = app_setup
-		# Silently ignore the test suites which use a different robot
-		if app.robot_name && 
-		    (app.robot_name != name || app.robot_type != kind)
-		    return
-		end
-		app.robot name, kind
-		app.reset
-		app.single
-		app.setup
-		if block
-		    block.call
-		end
-
-		yield if block_given?
-	    end
-
-	    # Returns a fresh MainPlanner object for the current plan
-	    def planner
-		MainPlanner.new(plan)
-	    end
-
-	    def setup # :nodoc:
+        extend Logger::Hierarchy
+        extend Logger::Forward
+
+        # This is the base class for running tests which uses a Roby control
+        # loop (i.e. plan execution).
+        #
+        # Because configuration and planning can be robot-specific, parts of
+        # the tests can also be splitted into generic parts and specific parts.
+        # The TestCase.robot statement allows to specify that a given test case
+        # is specific to a given robot, in which case it is ran only if the
+        # call to <tt>scripts/test</tt> specified a robot which matches (i.e.
+        # same name and type).
+        #
+        # Finally, two other mode of operation control the way tests are ran
+        # [simulation]
+        #   if the <tt>--sim</tt> flag is given to <tt>scripts/test</tt>, the
+        #   tests are ran under simulation. Otherwise, they are run in live
+        #   mode (see Roby::Application for a description of simulation and
+        #   live modes). It is possible to constrain that a given test method
+        #   is run only in simulation or live mode with the TestCase.sim and
+        #   TestCase.nosim statements:
+        #
+        #     sim :sim_only
+        #     def test_sim_only
+        #     end
+        #
+        #     nosim :live_only
+        #     def test_live_only
+        #     end
+        # [interactive]
+        #   Sometime, it is hard to actually assess the quality of processing
+        #   results automatically. In these cases, it is possible to show the
+        #   user the result of data processing, and then ask if the result is
+        #   valid by using the #user_validation method. Nonetheless, the tests
+        #   can be ran in automatic mode, in which the assertions which require
+        #   user validation are simply skipped. The <tt>--interactive</tt> or
+        #   <tt>-i</tt> flags of <tt>scripts/test</tt> specify that user
+        #   interaction is possible.
+        class TestCase < Test::Unit::TestCase
+            include Roby::Test
+            include Assertions
+            class << self
+                attribute(:case_config) { Hash.new }
+                attribute(:methods_config) { Hash.new }
+                attr_reader :app_setup
+            end
+
+            # Sets the robot configuration for this test case. If a block is
+            # given, it is called between the time the robot configuration is
+            # loaded and the time the test methods are started. It can
+            # therefore be used to change the robot configuration for the need
+            # of this particular test case
+            def self.robot(name, kind = name, &block)
+                @app_setup = [name, kind, block]
+            end
+
+            # Loads the configuration as specified by TestCase.robot
+            def self.apply_robot_setup
+                app = Roby.app
+
+                name, kind, block = app_setup
+                # Ignore the test suites which use a different robot
+                if name || kind && (app.robot_name && 
+                    (app.robot_name != name || app.robot_type != kind))
+                    Test.info "ignoring #{self} as it is for robot #{name} and we are running for #{app.robot_name}:#{app.robot_type}"
+                    return
+                end
+                if block
+                    block.call
+                end
+
+                yield if block_given?
+            end
+
+            # Returns a fresh MainPlanner object for the current plan
+            def planner
+                MainPlanner.new(plan)
+            end
+
+            def setup # :nodoc:
                 @plan = Roby.plan
-                @engine = Roby.engine
-                @control = Roby.control
-
-		super
-	    end
-
-	    def method_config # :nodoc:
-		self.class.case_config.merge(self.class.methods_config[method_name] || Hash.new)
-	    end
-
-	    # Returns true if user interaction is to be disabled during this test
-	    def automatic_testing?
-		Roby.app.automatic_testing?
-	    end
-
-	    # Progress report for the curren test. If +max+ is given, then
-	    # +value+ is assumed to be between 0 and +max+. Otherwise, +value+
-	    # is a float value between 0 and 1 and is displayed as a percentage.
-	    def progress(value, max = nil)
-		if max
-		    print "\r#{@method_name} progress: #{value}/#{max}"
-		else
-		    print "\r#{@method_name} progress: #{"%.2f %%" % [value * 100]}"
-		end
-		STDOUT.flush
-	    end
-
-	    def user_interaction
-		return unless automatic_testing?
-
-		test_result = catch(:validation_result) do
-		    yield 
-		    return
-		end
-		if test_result
-		    flunk(*test_result)
-		end
-	    end
-
-	    # Ask for user validation. The method first yields, and then asks
-	    # the user if the showed dataset is nominal. If the tests are ran
-	    # in automated mode (#automatic_testing? returns true), it does
-	    # nothing.
-	    def user_validation(msg)
-		return if automatic_testing?
-
-		assert_block(msg) do
-		    STDOUT.puts "Now validating #{msg}"
-		    yield
-
-		    STDIN.ask("\rIs the result OK ? [N,y]", false)
-		end
-	    end
-
-	    # Do not run +test_name+ inside a simulation environment
-	    # +test_name+ is the name of the method without +test_+. For
-	    # instance:
-	    #   nosim :init
-	    #   def test_init
-	    #   end
-	    #
-	    # See also TestCase.sim
-	    def self.nosim(*names)
-		names.each do |test_name|
-		    config = (methods_config[test_name.to_s] ||= Hash.new)
-		    config[:mode] = :nosim
-		end
-	    end
-
-	    # Run +test_name+ only inside a simulation environment
-	    # +test_name+ is the name of the method without +test_+. For
-	    # instance:
-	    #   sim :init
-	    #   def test_init
-	    #   end
-	    #
-	    # See also TestCase.nosim
-	    def self.sim(*names)
-		names.each do |test_name|
-		    config = (methods_config[test_name.to_s] ||= Hash.new)
-		    config[:mode] = :sim
-		end
-	    end
-
-	    def self.suite # :nodoc:
-		method_names = public_instance_methods(true)
-		tests = method_names.delete_if {|method_name| method_name !~ /^(dataset|test)./}
-		suite = Test::Unit::TestSuite.new(name)
-		tests.sort.each do |test|
-		    catch(:invalid_test) do
-			suite << new(test)
-		    end
-		end
-		if (suite.empty?)
-		    catch(:invalid_test) do
-			suite << new("default_test")
-		    end
-		end
-		return suite
-	    end
-
-	    def run(result) # :nodoc:
+                @engine = plan.engine
+                @control = plan.engine.control
+
+                super
+            end
+
+            # Returns true if user interaction is to be disabled during this test
+            def automatic_testing?
+                Roby.app.automatic_testing?
+            end
+
+            # Progress report for the curren test. If +max+ is given, then
+            # +value+ is assumed to be between 0 and +max+. Otherwise, +value+
+            # is a float value between 0 and 1 and is displayed as a percentage.
+            def progress(value, max = nil)
+                if max
+                    print "\rprogress: #{value}/#{max}"
+                else
+                    print "\rprogress: #{"%.2f %%" % [value * 100]}"
+                end
+                STDOUT.flush
+            end
+
+            def user_interaction
+                return unless automatic_testing?
+
+                test_result = catch(:validation_result) do
+                    yield 
+                    return
+                end
+                if test_result
+                    flunk(*test_result)
+                end
+            end
+
+            # Ask for user validation. The method first yields, and then asks
+            # the user if the showed dataset is nominal. If the tests are ran
+            # in automated mode (#automatic_testing? returns true), it does
+            # nothing.
+            def user_validation(msg)
+                return if automatic_testing?
+
+                assert_block(msg) do
+                    STDOUT.puts "Now validating #{msg}"
+                    yield
+
+                    STDIN.ask("\rIs the result OK ? [N,y]", false)
+                end
+            end
+
+            # Do not run +test_name+ inside a simulation environment
+            # +test_name+ is the name of the method without +test_+. For
+            # instance:
+            #   nosim :init
+            #   def test_init
+            #   end
+            #
+            # See also TestCase.sim
+            def self.nosim(*names)
+                names.each do |test_name|
+                    config = (methods_config[test_name.to_s] ||= Hash.new)
+                    config[:mode] = :nosim
+                end
+            end
+
+            # Run +test_name+ only inside a simulation environment
+            # +test_name+ is the name of the method without +test_+. For
+            # instance:
+            #   sim :init
+            #   def test_init
+            #   end
+            #
+            # See also TestCase.nosim
+            def self.sim(*names)
+                names.each do |test_name|
+                    config = (methods_config[test_name.to_s] ||= Hash.new)
+                    config[:mode] = :sim
+                end
+            end
+
+            def run(result) # :nodoc:
                 if self.class == TestCase
                     return
                 end
 
-		self.class.apply_robot_setup do
-		    yield if block_given?
-
-		    case method_config[:mode]
-		    when :nosim
-			return if Roby.app.simulation?
-		    when :sim
-			return unless Roby.app.simulation?
-		    end
-
-		    @failed_test = false
-		    begin
-			Roby.app.run do
-			    super
-			end
-		    rescue Exception => e
-			if @_result
-			    add_error(e)
-			else
-			    raise
-			end
-		    end
-
-		    keep_logdir = @failed_test || Roby.app.testing_keep_logs?
-		    save_logdir = (@failed_test && automatic_testing?) ||  Roby.app.testing_keep_logs?
-		    if save_logdir
-			subdir = @failed_test ? 'failures' : 'results'
-			basedir = File.join(APP_DIR, 'test', subdir)
-			dirname = Roby::Application.unique_dirname(basedir, dataset_prefix)
-
-			if Roby.app.testing_overwrites_logs?
-			    dirname.gsub! /\.\d+$/, ''
-			    FileUtils.rm_rf dirname
-			end
-
-			FileUtils.mv Roby.app.log_dir, dirname
-		    end
-		    if !keep_logdir
-			FileUtils.rm_rf Roby.app.log_dir
-		    end
-		end
-
-	    rescue Exception
-		puts "testcase #{method_name} teardown failed with\n#{$!.full_message}"
-	    end
-
-	    def add_error(*args, &block) # :nodoc:
-		@failed_test = true
-		super
-	    end
-	    def add_failure(*args, &block) # :nodoc:
-		@failed_test = true
-		super
-	    end
-
-	    # The directory in which datasets are to be saved
-	    def datasets_dir
-		"#{APP_DIR}/test/datasets" 
-	    end
-	    # The directory into which the datasets generated by the current
-	    # testcase are to be saved.
-	    def dataset_prefix
-		"#{Roby.app.robot_name}-#{self.class.name.gsub('TC_', '').underscore}-#{@method_name.gsub(/(?:test|dataset)_/, '')}"
-	    end
-	    # Returns the full path of the file name into which the log file +file+
-	    # should be saved to be referred to as the +dataset_name+ dataset
-	    def dataset_file_path(dataset_name, file)
-		path = File.join(datasets_dir, dataset_name, file)
-		if !File.file?(path)
-		    raise "#{path} does not exist"
-		end
-
-		path
-	    rescue
-		flunk("dataset #{dataset_name} has not been generated: #{$!.message}")
-	    end
-
-
-
-	    # Saves +file+, which is taken in the log directory, in the
-	    # test/datasets directory.  The data set is saved as
-	    # 'robot-testname-testmethod-suffix'
-	    def save_dataset(files = nil, suffix = '')
-		destname = dataset_prefix
-		destname << "-#{suffix}" unless suffix.empty?
-
-		dir = File.join(datasets_dir, destname)
-		if File.exists?(dir)
-		    relative_dir = dir.gsub(/^#{Regexp.quote(APP_DIR)}/, '')
-		    unless STDIN.ask("\r#{relative_dir} already exists. Delete ? [N,y]", false)
-			raise "user abort"
-		    end
-		    FileUtils.rm_rf dir
-		end
-		FileUtils.mkdir_p(dir)
-
-		files ||= Dir.entries(Roby.app.log_dir).find_all do |path|
-		    File.file? File.join(Roby.app.log_dir, path)
-		end
-
-		[*files].each do |path|
-		    FileUtils.mv "#{Roby.app.log_dir}/#{path}", dir
-		end
-	    end
-
-	    def sampling(*args, &block); Test.sampling(*args, &block) end
-	    def stats(*args, &block); Test.stats(*args, &block) end
-	end
+                self.class.apply_robot_setup do
+                    yield if block_given?
+
+                    @failed_test = false
+                    begin
+                        super
+                    rescue Exception => e
+                        if @_result
+                            add_error(e)
+                        else
+                            raise
+                        end
+                    end
+                end
+            end
+
+            def add_error(*args, &block) # :nodoc:
+                @failed_test = true
+                super
+            end
+            def add_failure(*args, &block) # :nodoc:
+                @failed_test = true
+                super
+            end
+
+            # The directory in which datasets are to be saved
+            def datasets_dir
+                "#{Roby.app.app_dir}/test/datasets" 
+            end
+            # The directory into which the datasets generated by the current
+            # testcase are to be saved.
+            def dataset_prefix
+                "#{Roby.app.robot_name}-#{self.class.name.gsub('TC_', '').underscore}-#{@method_name.gsub(/(?:test|dataset)_/, '')}"
+            end
+            # Returns the full path of the file name into which the log file +file+
+            # should be saved to be referred to as the +dataset_name+ dataset
+            def dataset_file_path(dataset_name, file)
+                path = File.join(datasets_dir, dataset_name, file)
+                if !File.file?(path)
+                    raise "#{path} does not exist"
+                end
+
+                path
+            rescue
+                flunk("dataset #{dataset_name} has not been generated: #{$!.message}")
+            end
+
+
+
+            # Saves +file+, which is taken in the log directory, in the
+            # test/datasets directory.  The data set is saved as
+            # 'robot-testname-testmethod-suffix'
+            def save_dataset(files = nil, suffix = '')
+                destname = dataset_prefix
+                destname << "-#{suffix}" unless suffix.empty?
+
+                dir = File.join(datasets_dir, destname)
+                if File.exists?(dir)
+                    relative_dir = dir.gsub(/^#{Regexp.quote(Roby.app.app_dir)}/, '')
+                    unless STDIN.ask("\r#{relative_dir} already exists. Delete ? [N,y]", false)
+                        raise "user abort"
+                    end
+                    FileUtils.rm_rf dir
+                end
+                FileUtils.mkdir_p(dir)
+
+                files ||= Dir.entries(Roby.app.log_dir).find_all do |path|
+                    File.file? File.join(Roby.app.log_dir, path)
+                end
+
+                [*files].each do |path|
+                    FileUtils.mv "#{Roby.app.log_dir}/#{path}", dir
+                end
+            end
+
+            def sampling(*args, &block); Test.sampling(engine, *args, &block) end
+            def stats(*args, &block); Test.stats(*args, &block) end
+        end
     end
 end