roby 0.7.3 → 0.8.0

data/test/mockups/external_process

@@ -0,0 +1,28 @@
+#! /usr/bin/env ruby
+
+require 'optparse'
+
+io = STDOUT
+common = false
+parser = OptionParser.new do |opt|
+    opt.on("--common") { common = true }
+    opt.on("--error") { exit(1) }
+    opt.on("--stderr") { io = STDERR }
+    opt.on("--no-output") { io = nil }
+    opt.on("--block") do
+        sleep
+    end
+end
+parser.parse! ARGV
+
+if common
+    STDOUT.puts "O: FIRST LINE"
+    STDERR.puts "E: FIRST LINE"
+    STDOUT.puts "O: SECOND LINE"
+    STDERR.puts "E: SECOND LINE"
+
+elsif io
+    io.puts "FIRST LINE"
+    io.puts "SECOND LINE"
+end
+exit 0

data/test/planning/test_loops.rb

@@ -1,4 +1,4 @@
-$LOAD_PATH.unshift File.expand_path('..', File.dirname(__FILE__))
+$LOAD_PATH.unshift File.expand_path(File.join('..', '..', 'lib'), File.dirname(__FILE__))
 require 'roby/test/common'
 require 'roby/planning'
 
@@ -8,6 +8,7 @@ require 'roby/test/tasks/simple_task'
 class TC_PlanningLoop < Test::Unit::TestCase
     include Roby::Planning
     include Roby::Test
+    include Roby::Test::Assertions
 
     # The planner model
     attr_reader :planner_model
@@ -19,6 +20,7 @@ class TC_PlanningLoop < Test::Unit::TestCase
 
     def setup
         super
+	Roby.app.filter_backtraces = false
 
 	task_model = @task_model = Class.new(SimpleTask)
         pattern_id = 0
@@ -33,7 +35,8 @@ class TC_PlanningLoop < Test::Unit::TestCase
 	    :planning_owners => nil,
 	    :planner_model => planner_model, 
 	    :planned_model => SimpleTask, 
-	    :method_name => :task, 
+	    :planning_method => "task", 
+	    :method_name => 'task', 
 	    :method_options => {} }
     end
 
@@ -44,7 +47,7 @@ class TC_PlanningLoop < Test::Unit::TestCase
 
     # Prepare the default plan for all planning loop tests
     def prepare_plan(loop_options = {})
-	plan.insert(main_task = Roby::Task.new)
+	plan.add_mission(main_task = Roby::Task.new)
 	loop_task_options = planning_task_options.merge(loop_options)
 	loop_planner = PlanningLoop.new(loop_task_options)
 	main_task.planned_by loop_planner
@@ -52,6 +55,11 @@ class TC_PlanningLoop < Test::Unit::TestCase
         return main_task, loop_planner
     end
 
+    def wait_for_planning_end(planning_task)
+        planning_task.thread.join
+        process_events
+    end
+
     # Waits for +planning_task+ to finish and returns the planned result
     def planning_task_result(planning_task)
         assert(planning_task)
@@ -214,92 +222,126 @@ class TC_PlanningLoop < Test::Unit::TestCase
 
     # Test periodic loop tasks with zero lookahead
     def test_periodic_zero_lookahead
-        main_task, loop_planner = prepare_plan :period => 0.5, :lookahead => 0
-	loop_planner.start!
+	FlexMock.use(Time) do |time_proxy|
+	    current_time = Time.now + 5
+	    time_proxy.should_receive(:now).and_return { current_time }
 
-        # Zero lookahead: no children until we call #loop_start!
-	assert(main_task.children.empty?)
+	    main_task, loop_planner = prepare_plan :period => 0.5, :lookahead => 0
+	    loop_planner.start!
 
-        # Start a first pattern
-        loop_planner.loop_start!(:id => 1)
-        assert_equal(1, loop_planner.patterns.size)
-        first_planner = loop_planner.last_planning_task
-        first_task    = planning_task_result(first_planner)
-	assert_equal(1, first_task.arguments[:id])
+	    # Zero lookahead: no children until we call #loop_start!
+	    assert(main_task.children.empty?)
 
-        # Check the normal behaviour: a new pattern is to be added only when
-        # the first pattern has finished AND the period has occured.
-        assert(first_task.running?)
-        assert_equal(1, main_task.children.to_a.size)
-        first_task.success!
-        assert_equal(1, main_task.children.to_a.size)
-        sleep(0.6)
-        process_events
-        assert_equal(2, main_task.children.to_a.size)
-        assert(second_planner = loop_planner.last_planning_task)
-        assert(second_planner.running?)
-        second_task = planning_task_result(second_planner)
-        assert(second_task.running?)
-        assert_equal(1, main_task.children.to_a.size)
-
-        # And queue one other. The second call to #loop_start! should be
-        # completely ignored because there is already one pending pattern.
-        loop_planner.loop_start!(:id => 3)
-        loop_planner.loop_start!(:id => 4)
-	assert_equal(2, main_task.children.to_a.size)
-        third_planner = loop_planner.last_planning_task
-        third_task  = planning_task_result(third_planner)
-        assert_equal(3, third_task.arguments[:id])
+	    # Start a first pattern
+	    loop_planner.loop_start!(:id => 1)
+	    assert_equal(1, loop_planner.patterns.size)
+	    first_planner = loop_planner.last_planning_task
+	    first_task    = planning_task_result(first_planner)
+	    assert_equal(1, first_task.arguments[:id])
 
-        # Check the dynamic behaviour
-        # - the 3rd task should start as soon as the 2nd has: the call to
-        #   #loop_start! should have done that for us.
-	assert(second_task.running?)
-	assert(third_task.pending?)
-	second_task.success!
-	assert(second_task.success?)
-	assert(third_task.running?)
-	third_task.success!
-	assert(third_task.success?)
+	    # Check the normal behaviour: a new pattern is to be added only when
+	    # the first pattern has finished AND the period has occured.
+	    assert(first_task.running?)
+	    assert_equal([first_task], main_task.children.to_a)
+	    first_task.success!
+	    assert_equal([first_task], main_task.children.to_a)
+	    current_time += 0.6
+	    process_events
+            second_proxy_task = main_task.children.to_a.first
+            assert(second_proxy_task != first_task)
+	    assert_equal(1, main_task.children.to_a.size)
+	    assert(second_planner = loop_planner.last_planning_task)
+	    assert(second_planner.running?)
+	    second_task = planning_task_result(second_planner)
+	    assert(second_task.running?)
+	    assert_equal([second_task], main_task.children.to_a)
+
+	    # And queue one other. The second call to #loop_start! should be
+	    # completely ignored because there is already one pending pattern.
+	    loop_planner.loop_start!(:id => 3)
+	    loop_planner.loop_start!(:id => 4)
+	    assert_equal(2, main_task.children.to_a.size)
+	    assert(main_task.children.to_a.include?(second_task))
+	    third_planner = loop_planner.last_planning_task
+	    third_task  = planning_task_result(third_planner)
+	    assert_equal(3, third_task.arguments[:id])
+            assert_equal([second_task, third_task].to_value_set, main_task.children.to_value_set)
+
+	    # Check the dynamic behaviour
+	    # - the 3rd task should start as soon as the 2nd has: the call to
+	    #   #loop_start! should have done that for us.
+	    assert(second_task.running?)
+	    assert(third_task.pending?)
+	    second_task.success!
+	    assert(second_task.success?)
+            process_events
+            assert_equal([third_task], main_task.children.to_a)
+	    assert(third_task.running?)
+	    third_task.success!
+	    assert(third_task.success?)
+	end
     end
 
     def test_reinit_periodic
+        Roby.app.abort_on_exception = false
         main_task, loop_planner = prepare_plan :period => 0.5, :lookahead => 3
 
-	FlexMock.use do |mock|
-	    mock.should_receive(:started).twice
-	    task_model.on(:start) { mock.started }
-
-	    loop_planner.start!
-            planners = loop_planner.patterns.reverse.map { |t, _| t }
-            tasks    = planners.map { |p| planning_task_result(p) }
-
-	    loop_planner.loop_start!
-	    assert(tasks[0].running?)
-
-	    loop_planner.reinit!
-            process_events
-            sleep(0.1)
-            process_events
-            
-            # reinit should keep the first pattern because it is running, but
-            # the other ones should be new (and the second pattern should be
-            # being planned)
-            assert(loop_planner.event(:reinit).happened?)
-            assert_equal(3, loop_planner.patterns.size)
-
-            new_planners = loop_planner.patterns.reverse.map { |t, _| t }
-            new_tasks    = new_planners.map { |p| planning_task_result(p) }
-
-            new_tasks.each do |t|
-                assert(!tasks.include?(t))
+	FlexMock.use(Time) do |time_proxy|
+	    current_time = Time.now + 5
+	    time_proxy.should_receive(:now).and_return { current_time }
+            FlexMock.use do |mock|
+                mock.should_receive(:started).twice
+                task_model.on(:start) { mock.started }
+
+                loop_planner.start!
+                planners = loop_planner.patterns.reverse.map { |t, _| t }
+                tasks    = planners.map { |p| planning_task_result(p) }
+                assert_equal 3, tasks.size
+                assert_equal tasks.to_value_set, main_task.children.to_value_set
+
+                loop_planner.loop_start!
+                assert(tasks[0].running?)
+                # First task is started, one pattern should be planning for the
+                # sake of the lookahead
+                assert_equal 1, (main_task.children.to_value_set - tasks.to_value_set).size
+                assert_equal 4, loop_planner.patterns.size
+
+                current_planning_task = loop_planner.patterns.first.first
+                original_patterns = loop_planner.patterns.dup
+
+                # reinit should remove all children and recreate the structure
+                # for three patterns
+                loop_planner.reinit!
+                process_events
+                assert(!loop_planner.event(:reinit).happened?)
+                assert(tasks[0].running?)
+                process_events
+                assert(!tasks[0].running?)
+                # if we're lucky, the planning task is not finished yet and
+                # therefore the loop planner should not have emitted :reinit yet
+                # either
+                if current_planning_task.running?
+                    wait_for_planning_end current_planning_task
+                    assert(loop_planner.reinit_event.last.time >= current_planning_task.stop_event.last.time)
+                end
+                # Wait for the planning task to finish if it is not yet finished
+                assert_equal 3, (loop_planner.patterns - original_patterns).size
+                assert_equal 3, loop_planner.patterns.size
+                assert_equal 3, main_task.children.to_a.size
+                assert_equal 3, (main_task.children.to_value_set - tasks.to_value_set).size
+
+                new_planners = loop_planner.patterns.reverse.map { |t, _| t }
+                new_tasks    = new_planners.map { |p| planning_task_result(p) }
+
+                new_tasks.each do |t|
+                    assert(!tasks.include?(t))
+                end
+                # ... but the first pattern should be GCed right now, and the next
+                # pattern started
+                process_events
+                assert(new_tasks[0].running?)
             end
-            # assert_equal([1, 5, 6, 7], new_tasks.map { |t| t.arguments[:id] })
-            # ... but the first pattern should be GCed right now, and the next
-            # pattern started
-	    process_events
-	    assert(new_tasks[0].running?)
-	end
+        end
     end
 
     #def test_planning_loop_reinit_zero_lookahead
@@ -311,7 +353,7 @@ class TC_PlanningLoop < Test::Unit::TestCase
     #        end
     #    end
 
-    #    plan.insert(main_task = Roby::Task.new)
+    #    plan.add_mission(main_task = Roby::Task.new)
     #    loop_planner = PlanningLoop.new :period => nil, :lookahead => 0, 
     #        :planner_model => planner_model, :planned_model => Roby::Task, 
     #        :method_name => :task, :method_options => {}	
@@ -342,47 +384,49 @@ class TC_PlanningLoop < Test::Unit::TestCase
     #    end
     #end
 
-    #def test_make_loop
-    #    planner_model = Class.new(Planning::Planner) do
-    #        include Test::Unit::Assertions
-
-    #        @result_task = nil
-    #        attr_reader :result_task
-    #        method(:task) {  @result_task = SimpleTask.new(:id => arguments[:task_id])}
-    #        method(:looping_tasks) do
-    #    	t1 = make_loop(:period => 0, :child_argument => 2) do
-    #    	    # arguments of 'my_looping_task' shall be forwarded
-    #    	    raise unless arguments[:parent_argument] == 1
-    #    	    raise unless arguments[:child_argument] == 2
-    #    	    task(:task_id => 'first_loop')
-    #    	end
-    #    	t2 = make_loop do
-    #    	    task(:task_id => 'second_loop')
-    #    	end
-    #    	# Make sure the two loops are different
-    #    	assert(t1.method_options[:id] != t2.method_options[:id])
-    #    	[t1, t2]
-    #        end
-    #    end
+    def test_make_loop
+        planner_model = Class.new(Planning::Planner) do
+            include Test::Unit::Assertions
+
+            @result_task = nil
+            attr_reader :result_task
+            method(:task) {  @result_task = SimpleTask.new(:id => arguments[:task_id])}
+            method(:looping_tasks) do
+        	t1 = make_loop(:period => 0, :child_argument => 2) do
+        	    # arguments of 'my_looping_task' shall be forwarded
+        	    raise unless arguments[:parent_argument] == 1
+        	    raise unless arguments[:child_argument] == 2
+        	    task(:task_id => 'first_loop')
+        	end
+        	t2 = make_loop do
+        	    task(:task_id => 'second_loop')
+        	end
+        	# Make sure the two loops are different
+        	assert(t1.method_options[:id] != t2.method_options[:id])
+        	[t1, t2]
+            end
+        end
 
-    #    planner = planner_model.new(plan)
-    #    t1, t2 = planner.looping_tasks(:parent_argument => 1)
-    #    plan.insert(t1)
-    #    plan.insert(t2)
+        planner = planner_model.new(plan)
+        t1, t2 = planner.looping_tasks(:parent_argument => 1)
+        assert(t1.fully_instanciated?, t1.arguments.keys - t1.class.arguments.to_a)
+        assert(t2.fully_instanciated?)
+        plan.add_mission(t1)
+        plan.add_mission(t2)
 
-    #    t1.start!
-    #    planned_task = planning_task_result(t1.last_planning_task)
-    #    assert_equal('first_loop', planned_task.arguments[:id])
+        t1.start!
+        planned_task = planning_task_result(t1.last_planning_task)
+        assert_equal('first_loop', planned_task.arguments[:id])
 
-    #    t2.start!
-    #    planned_task = planning_task_result(t2.last_planning_task)
-    #    assert_equal('second_loop', planned_task.arguments[:id])
+        t2.start!
+        planned_task = planning_task_result(t2.last_planning_task)
+        assert_equal('second_loop', planned_task.arguments[:id])
 
-    #    t3 = planner.make_loop(:period => 0, :parent_argument => 1, :child_argument => 2) do
-    #        task(:task_id => 'third_loop')
-    #    end
-    #    plan.insert(t3)
-    #    t3.start!
-    #    assert_equal('third_loop', planning_task_result(t3.last_planning_task).arguments[:id])
-    #end
+        t3 = planner.make_loop(:period => 0, :parent_argument => 1, :child_argument => 2) do
+            task(:task_id => 'third_loop')
+        end
+        plan.add_mission(t3)
+        t3.start!
+        assert_equal('third_loop', planning_task_result(t3.last_planning_task).arguments[:id])
+    end
 end

data/test/planning/test_model.rb

@@ -1,4 +1,4 @@
-$LOAD_PATH.unshift File.expand_path('..', File.dirname(__FILE__))
+$LOAD_PATH.unshift File.expand_path(File.join('..', '..', 'lib'), File.dirname(__FILE__))
 require 'roby/test/common'
 require 'roby/planning'
 
@@ -115,7 +115,7 @@ class TC_Planner < Test::Unit::TestCase
 	planner = model.new(plan)
 	assert_raises(NotFound) { planner.empty_set }
 
-	plan.insert(task = task_model.new)
+	plan.add_mission(task = task_model.new)
 	found_task = nil
 	assert_nothing_raised { found_task = planner.empty_set }
 	assert_equal(found_task, task)
@@ -126,7 +126,7 @@ class TC_Planner < Test::Unit::TestCase
 	planner = planner_model.new(plan)
 	result = planner.send(method, options)
 	result.each do |task|
-	    planner.plan.insert(task)
+	    planner.plan.add_mission(task)
 	end
 	assert_equal(size, planner.plan.size, planner.plan.known_tasks.to_a.inspect)
 

data/test/planning/test_task.rb

@@ -1,4 +1,4 @@
-$LOAD_PATH.unshift File.expand_path('..', File.dirname(__FILE__))
+$LOAD_PATH.unshift File.expand_path(File.join('..', '..', 'lib'), File.dirname(__FILE__))
 require 'roby/test/common'
 require 'roby/planning'
 
@@ -11,7 +11,7 @@ class TC_PlanningTask < Test::Unit::TestCase
 
     def planning_task_result(planning_task)
         assert(planning_task)
-	plan.permanent(planning_task)
+	plan.add_permanent(planning_task)
 	planning_task.start! if planning_task.pending?
 	planning_task.thread.join
 	process_events
@@ -33,7 +33,7 @@ class TC_PlanningTask < Test::Unit::TestCase
 	planning_task = PlanningTask.new(:planner_model => planner, :method_name => :task,
 				:method_options => { :bla => 42 },
 				:blo => 84)
-	plan.insert(planned_task = Task.new)
+	plan.add_mission(planned_task = Task.new)
 	planned_task.planned_by planning_task
 
 	planning_task.start!(42)
@@ -67,7 +67,7 @@ class TC_PlanningTask < Test::Unit::TestCase
         end
 
 	planning_task = PlanningTask.new(:planner_model => planner, :method_name => :interruptible)
-	plan.permanent(planning_task)
+	plan.add_permanent(planning_task)
         planning_task.start!
         loop { sleep 0.1 ; break if started }
         planning_task.stop!
@@ -85,13 +85,13 @@ class TC_PlanningTask < Test::Unit::TestCase
 	planner = Class.new(Planning::Planner) do
 	    method(:test_task) do
 	       	result_task = SimpleTask.new(:id => arguments[:task_id])
-		result_task.realized_by replan_task(:task_id => arguments[:task_id] + 1)
-		plan.permanent(result_task)
+		result_task.depends_on replan_task(:task_id => arguments[:task_id] + 1)
+		plan.add_permanent(result_task)
 		result_task
 	    end
 	end.new(plan)
 
-	plan.permanent(task = planner.test_task(:task_id => 100))
+	plan.add_permanent(task = planner.test_task(:task_id => 100))
 	assert_kind_of(SimpleTask, task)
 	assert_equal(100, task.arguments[:id])
 
@@ -103,4 +103,24 @@ class TC_PlanningTask < Test::Unit::TestCase
 	assert_kind_of(SimpleTask, new_task, planning_task)
 	assert_equal(101, new_task.arguments[:id])
     end
+
+    def test_method_object
+	planner_model = Class.new(Planning::Planner)
+
+        FlexMock.use do |mock|
+            mock.should_receive(:method_called).with(:context => nil, :arg => 10).once
+
+            body = lambda do
+                mock.method_called(arguments)
+                Roby::Task.new(:id => 'result_of_lambda')
+            end
+            m = FreeMethod.new 'test_object', {:id => 10}, body
+            planning_task = PlanningTask.new(:planner_model => planner_model, :planning_method => m, :arg => 10)
+            plan.add_permanent(planning_task)
+            planning_task.start!
+            new_task = planning_task_result(planning_task)
+            assert_equal 'result_of_lambda', new_task.arguments[:id]
+        end
+    end
 end
+