roby 0.7.3 → 0.8.0

data/lib/roby/test/distributed.rb

@@ -10,7 +10,6 @@ module Roby
 	    def setup
 		super
 
-		save_collection Distributed.new_neighbours_observers
 		@old_distributed_logger_level = Distributed.logger.level
 
 		timings[:setup] = Time.now
@@ -32,7 +31,7 @@ module Roby
 		super
 
 		unless Distributed.peers.empty?
-		    Roby.warn "  still referencing #{Distributed.peers.keys}"
+		    Roby::Distributed.warn "  still referencing #{Distributed.peers.keys}"
 		    Distributed.peers.clear
 		end
 
@@ -44,9 +43,13 @@ module Roby
 		    @__droby_remote_id__ = nil
 		    @__droby_marshalled__ = nil
 		end
+                Roby.class_eval do
+                    @plan = nil
+                    @engine = nil
+                end
 
-		if Distributed.state
-		    Distributed.state.quit
+		if local
+		    local.quit
 		end
 
 		timings[:end] = Time.now
@@ -63,64 +66,81 @@ module Roby
 		attr_accessor :testcase
 
 		def enable_communication
-		    Roby::Distributed.state.synchronize do
+		    synchronize do
 			local_peer.enable_rx
 			# make sure we wake up the communication thread
-			Roby::Distributed.state.finished_discovery.broadcast
+			finished_discovery.broadcast
 		    end
 		end
 		def disable_communication
 		    local_peer.disable_rx
 		end
 		def flush; local_peer.flush end
-		def process_events; Roby.control.process_events end
+		def process_events; engine.process_events end
 		def local_peer
-		    @local_peer ||= Distributed.peers.find { true }.last
+		    @local_peer ||= peers.find { true }.last
 		end
 		def reset_local_peer; @local_peer = nil end
 		def send_local_peer(*args); local_peer.send(*args) end
-		def wait_one_cycle; Roby.control.wait_one_cycle end
+		def wait_one_cycle; engine.wait_one_cycle end
 		def console_logger=(value); testcase.console_logger = value end
 		def log_level=(value); Roby.logger.level = value end
 		def cleanup
-		    Roby.control.quit
-		    Roby.control.join
-		end
+		    engine.quit
+		    engine.join
+		end
+                def disable_logging
+                    logger = Roby::Distributed.logger
+                    @orig_logger_level = logger.level
+                    logger.level = Logger::UNKNOWN
+                end
+                def enable_logging
+                    logger = Roby::Distributed.logger
+                    logger.level = (@orig_logger_level || Logger::WARN)
+                end
 	    end
 
 	    # Start a central discovery service, a remote connectionspace and a local
 	    # connection space. It yields the remote connection space *in the forked
 	    # child* if a block is given.
-	    def start_peers(detached_control = false)
+	    def start_peers
 		DRb.stop_service
 		remote_process do
 		    DRb.start_service DISCOVERY_SERVER, Rinda::TupleSpace.new
 		end
 
-		if detached_control && Roby.control.running?
+		if engine.running?
 		    begin
-			Roby.control.quit
-			Roby.control.join
+			engine.quit
+			engine.join
 		    rescue ControlQuitError
 		    end
 		end
 
 		remote_process do
 		    central_tuplespace = DRbObject.new_with_uri(DISCOVERY_SERVER)
+
 		    cs = ConnectionSpace.new :ring_discovery => false, 
-			:discovery_tuplespace => central_tuplespace, :name => "remote" do |remote|
-			    getter = Class.new { def get; DRbObject.new(Distributed.state) end }.new
-			    DRb.start_service REMOTE_SERVER, getter
-			end
+			:discovery_tuplespace => central_tuplespace, :name => "remote",
+                        :plan => plan
+
+                    getter = Class.new do
+                        attr_accessor :cs
+                        def get; DRbObject.new(cs) end
+                    end.new
+                    getter.cs = cs
+
+                    Distributed.state = cs
+
+                    DRb.start_service REMOTE_SERVER, getter
+
 		    cs.extend RemotePeerSupport
 		    cs.testcase = self
 
 		    def cs.start_control_thread
-			Control.event_processing << Distributed.state.method(:start_neighbour_discovery)
-			Roby.control.run :detach => true
+			engine.run
 		    end
 
-		    Distributed.state = cs
 		    yield(cs) if block_given?
 		end
 
@@ -130,14 +150,10 @@ module Roby
 		@local   = ConnectionSpace.new :ring_discovery => false, 
 		    :discovery_tuplespace => central_tuplespace, :name => 'local', 
 		    :plan => plan
+                Distributed.state = local
 
-		Distributed.state = local
-
-		if detached_control
-		    remote.start_control_thread
-		    Control.event_processing << Distributed.state.method(:start_neighbour_discovery)
-		    Roby.control.run :detach => true
-		end
+                remote.start_control_thread
+                engine.run
 	    end
 
 	    def setup_connection
@@ -153,21 +169,21 @@ module Roby
 	    attr_reader :central_tuplespace, :remote, :remote_peer, :remote_plan, :local
 
 	    # Establishes a peer to peer connection between two ConnectionSpace objects
-	    def peer2peer(detached_control = false, &remote_init)
+	    def peer2peer(&remote_init)
 		timings[:starting_peers] = Time.now
-		start_peers(detached_control, &remote_init)
+		start_peers(&remote_init)
 		setup_connection
 		timings[:started_peers] = Time.now
 	    end
 
 	    def process_events
-		if Roby.control.running?
+		if engine.running?
 		    remote.wait_one_cycle
-		    Roby.control.wait_one_cycle
+		    engine.wait_one_cycle
 		elsif remote_peer && !remote_peer.disconnected?
-		    Roby::Control.synchronize do
+		    Roby.synchronize do
 			remote.process_events
-			Roby.control.process_events
+			engine.process_events
 		    end
 		else
 		    super
@@ -181,7 +197,7 @@ module Roby
 		remote_peer.find_tasks.with_arguments(match).each do |task|
 		    assert(!found)
 		    if set_permanent
-			plan.permanent(task)
+			plan.add_permanent(task)
 		    end
 
 		    found = if block_given? then yield(task)

data/lib/roby/test/testcase.rb

@@ -1,9 +1,4 @@
 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'
@@ -14,196 +9,6 @@ module Roby
 	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).
 	#
@@ -289,8 +94,6 @@ module Roby
 		    block.call
 		end
 
-		app.control.delete('executive')
-
 		yield if block_given?
 	    end
 
@@ -300,12 +103,10 @@ module Roby
 	    end
 
 	    def setup # :nodoc:
-		super
-		Roby::Test.waiting_threads << Thread.current
-	    end
+                @plan = Roby.plan
+                @engine = Roby.engine
+                @control = Roby.control
 
-	    def teardown # :nodoc:
-		Roby::Test.waiting_threads.delete(Thread.current)
 		super
 	    end
 
@@ -405,7 +206,9 @@ module Roby
 	    end
 
 	    def run(result) # :nodoc:
-		Roby::Test.waiting_threads.clear
+                if self.class == TestCase
+                    return
+                end
 
 		self.class.apply_robot_setup do
 		    yield if block_given?
@@ -469,7 +272,7 @@ module Roby
 	    # 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}/, '')}"
+		"#{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
@@ -484,6 +287,8 @@ module Roby
 		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'

data/lib/roby/test/tools.rb

@@ -21,11 +21,11 @@ module Roby
 		Roby.condition_variable(true) do |cv, mt|
 		    first_sample = nil
 		    mt.synchronize do
-			id = Roby::Control.every(period) do
+			id = Roby.every(period) do
 			    result = yield
 			    if result
 				if compute_time
-				    result << Roby.control.cycle_start
+				    result << Roby.engine.cycle_start
 				end
 				new_sample = sample_type.new(*result)
 
@@ -43,7 +43,7 @@ module Roby
 			end
 
 			cv.wait(mt)
-			Roby::Control.remove_periodic_handler(id)
+			Roby.engine.remove_periodic_handler(id)
 		    end
 		end