roby 0.7

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

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

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

@@ -0,0 +1,36 @@
+
+module Roby
+    module Test
+	class Goto2D < Roby::Task
+	    terminates
+	    argument :x, :y
+
+	    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
+
+	    module Planning
+		planning_library
+		method(:go_to) do
+		    Goto2D.new(arguments)
+		end
+	    end
+	end
+    end
+end
+

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

@@ -0,0 +1,23 @@
+require 'roby/task'
+
+module Roby
+    module Test
+        # This task model is a simple task where +start+, +success+ and
+        # +failed+ are pass-through controlable events. They have an +id+
+        # argument which is automatically set to the object's #object_id if not
+        # explicitely given at initialization.
+	class SimpleTask < Roby::Task
+	    argument :id
+
+	    def initialize(arguments = {}) # :nodoc:
+		arguments = { :id => object_id.to_s }.merge(arguments)
+		super(arguments)
+	    end
+
+	    event :start, :command => true
+	    event :success, :command => true, :terminal => true
+	    terminates
+	end
+    end
+end
+

data/lib/roby/test/testcase.rb

@@ -0,0 +1,519 @@
+require 'roby'
+require 'active_support/core_ext/string/inflections'
+class String # :nodoc: all
+    include ActiveSupport::CoreExtensions::String::Inflections
+end
+
+require 'test/unit'
+require 'roby/test/common'
+require 'roby/test/tools'
+require 'fileutils'
+
+module Roby
+    module Test
+	extend Logger::Hierarchy
+	extend Logger::Forward
+
+	@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
+
+	    # 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 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? }
+		    return true, "all positive events are unreachable"
+		end
+
+		nil
+	    end
+
+	    # This method is inserted in the control thread to implement
+	    # Assertions#assert_events
+	    def check_event_assertions
+		event_assertions.delete_if do |thread, cv, positive, negative|
+		    error, result = assert_any_event_result(positive, negative)
+		    if !error.nil?
+			thread[ASSERT_ANY_EVENTS_TLS] = [error, result]
+			cv.broadcast
+			true
+		    end
+		end
+	    end
+
+	    def finalize_event_assertions
+		check_event_assertions
+		event_assertions.dup.each do |thread, *_|
+		    thread.raise ControlQuitError
+		end
+	    end
+
+	    # A set of threads waiting for something to happen. This is used
+	    # during #teardown to make sure no threads are block indefinitely
+	    attr_reader :waiting_threads
+
+	    # This proc is to be called by Control when it quits. It makes sure
+	    # that threads which are waiting are interrupted
+	    def interrupt_waiting_threads
+		waiting_threads.dup.each do |task|
+		    task.raise ControlQuitError
+		end
+	    ensure
+		waiting_threads.clear
+	    end
+
+	end
+	Roby::Control.at_cycle_end(&method(:check_event_assertions))
+	Roby::Control.finalizers << method(:finalize_event_assertions)
+	Roby::Control.finalizers << method(:interrupt_waiting_threads)
+
+	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
+		    Roby.condition_variable(false) do |cv|
+			positive = Array[*positive].to_value_set
+			negative = Array[*negative].to_value_set
+
+			unreachability_reason = ValueSet.new
+			Roby::Control.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]
+				Roby.once(&block) if block_given?
+				begin
+				    cv.wait(Roby::Control.mutex)
+				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
+	    end
+
+	    # Starts +task+ and checks it succeeds
+	    def assert_succeeds(task, *args)
+		control_priority do
+		    if !task.kind_of?(Roby::Task)
+			Roby.execute do
+			    plan.insert(task = planner.send(task, *args))
+			end
+		    end
+
+		    assert_any_event([task.event(:success)], [], nil) do
+			plan.permanent(task)
+			task.start! if task.pending?
+			yield if block_given?
+		    end
+		end
+	    end
+
+	    def control_priority
+		old_priority = Thread.current.priority 
+		Thread.current.priority = Roby.control.thread.priority + 1
+
+		yield
+	    ensure
+		Thread.current.priority = 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
+
+	# 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
+
+		app.control.delete('executive')
+
+		yield if block_given?
+	    end
+
+	    # Returns a fresh MainPlanner object for the current plan
+	    def planner
+		MainPlanner.new(plan)
+	    end
+
+	    def setup # :nodoc:
+		super
+		Roby::Test.waiting_threads << Thread.current
+	    end
+
+	    def teardown # :nodoc:
+		Roby::Test.waiting_threads.delete(Thread.current)
+		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:
+		Roby::Test.waiting_threads.clear
+
+		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}/, '')}"
+	    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
+    end
+end
+
+