roby 0.7

data/test/planning/test_task.rb

@@ -0,0 +1,106 @@
+$LOAD_PATH.unshift File.expand_path('..', File.dirname(__FILE__))
+require 'roby/test/common'
+require 'roby/planning'
+
+require 'flexmock'
+require 'roby/test/tasks/simple_task'
+
+class TC_PlanningTask < Test::Unit::TestCase
+    include Roby::Planning
+    include Roby::Test
+
+    def planning_task_result(planning_task)
+        assert(planning_task)
+	plan.permanent(planning_task)
+	planning_task.start! if planning_task.pending?
+	planning_task.thread.join
+	process_events
+	assert(planning_task.success?, planning_task.terminal_event.context)
+	planning_task.planned_task
+    end
+
+    def test_planning_task_one_shot
+	result_task = SimpleTask.new
+	planner = Class.new(Planning::Planner) do
+	    method(:task) do
+		raise arguments.to_s unless arguments[:bla] == 42
+		raise arguments.to_s unless arguments[:blo] == 84
+		raise arguments.to_s unless arguments[:context] == [42]
+		result_task
+	    end
+	end
+
+	planning_task = PlanningTask.new(:planner_model => planner, :method_name => :task,
+				:method_options => { :bla => 42 },
+				:blo => 84)
+	plan.insert(planned_task = Task.new)
+	planned_task.planned_by planning_task
+
+	planning_task.start!(42)
+	FlexMock.use do |mock|
+	    planning_task.on(:success) do
+	        mock.planned_task(planning_task.planned_task)
+		planning_task.planned_task.start!
+	    end
+	    mock.should_receive(:planned_task).with(result_task).once
+	    planning_task.thread.join
+	    process_events
+	end
+
+	plan_task = plan.missions.find { true }
+        assert_equal(result_task, plan_task)
+	assert_equal(result_task, planning_task.planned_task)
+    end
+
+    def test_planning_interruption
+        Thread.abort_on_exception = false
+        started, normal_finish = nil
+        planner = Class.new(Planning::Planner) do
+            method(:interruptible) do
+                started = true
+                10.times do
+                    sleep 0.1
+                    interruption_point
+                end
+                normal_finish = true
+            end
+        end
+
+	planning_task = PlanningTask.new(:planner_model => planner, :method_name => :interruptible)
+	plan.permanent(planning_task)
+        planning_task.start!
+        loop { sleep 0.1 ; break if started }
+        planning_task.stop!
+        loop do
+            begin
+                process_events
+            rescue Interrupt
+            end
+            break unless planning_task.running?
+        end
+        assert(!normal_finish)
+    end
+
+    def test_replan_task
+	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
+	    end
+	end.new(plan)
+
+	plan.permanent(task = planner.test_task(:task_id => 100))
+	assert_kind_of(SimpleTask, task)
+	assert_equal(100, task.arguments[:id])
+
+	assert(planning_task = task.enum_child_objects(Roby::TaskStructure::Hierarchy).to_a.first)
+	assert_kind_of(PlanningTask, planning_task)
+	assert(planning_task.pending?)
+
+	new_task = planning_task_result(planning_task)
+	assert_kind_of(SimpleTask, new_task, planning_task)
+	assert_equal(101, new_task.arguments[:id])
+    end
+end

data/test/relations/test_conflicts.rb

@@ -0,0 +1,42 @@
+$LOAD_PATH.unshift File.expand_path('../..', File.dirname(__FILE__))
+
+require 'roby/test/common'
+require 'roby/test/tasks/simple_task'
+require 'roby/relations/conflicts'
+require 'flexmock'
+
+class TC_Conflicts < Test::Unit::TestCase
+    include Roby::Test
+
+    def test_model_relations
+	m1, m2 = (1..2).map do
+	    Class.new(SimpleTask)
+	end
+
+	m1.conflicts_with m2
+	assert(!m1.conflicts_with?(m1))
+	assert(m1.conflicts_with?(m2))
+	assert(m2.conflicts_with?(m1))
+
+	# Create two tasks ...
+	plan.discover(t1 = m1.new)
+	plan.discover(t2 = m2.new)
+	assert !t1.child_object?(t2, Roby::TaskStructure::Conflicts)
+	assert !t2.child_object?(t1, Roby::TaskStructure::Conflicts)
+
+	# Start t1 ...
+	t1.start!
+	assert !t1.child_object?(t2, Roby::TaskStructure::Conflicts)
+	assert t2.child_object?(t1, Roby::TaskStructure::Conflicts)
+
+	# And now, start the conflicting task. The default decision control
+	# should postpone start until t1 is stopped
+	t2.start!
+	assert(!t2.running?)
+	assert t1.event(:stop).child_object?(t2.event(:start), Roby::EventStructure::Signal)
+	t1.stop!
+	assert(!t1.running?)
+	assert(t2.running?)
+    end
+end
+

data/test/relations/test_ensured.rb

@@ -0,0 +1,38 @@
+$LOAD_PATH.unshift File.expand_path('../..', File.dirname(__FILE__))
+require 'roby/test/common'
+require 'flexmock'
+
+class TC_EnsuredEvent < Test::Unit::TestCase
+    include Roby::Test
+
+    def test_ensure
+	setup = lambda do |mock|
+	    e1, e2 = EventGenerator.new(true), Roby::EventGenerator.new(true)
+	    plan.discover [e1, e2]
+	    e1.ensure e2
+	    e1.on { mock.e1 }
+	    e2.on { mock.e2 }
+	    [e1, e2]
+	end
+	FlexMock.use do |mock|
+	    e1, e2 = setup[mock]
+	    mock.should_receive(:e2).ordered.once
+	    mock.should_receive(:e1).ordered.once
+	    e1.call(nil)
+	end
+	FlexMock.use do |mock|
+	    e1, e2 = setup[mock]
+	    mock.should_receive(:e1).never
+	    mock.should_receive(:e2).once
+	    e2.call(nil)
+	end
+	FlexMock.use do |mock|
+	    e1, e2 = setup[mock]
+	    mock.should_receive(:e2).ordered.once
+	    mock.should_receive(:e1).ordered.once
+	    e2.call(nil)
+	    e1.call(nil)
+	end
+    end
+end
+

data/test/relations/test_executed_by.rb

@@ -0,0 +1,149 @@
+$LOAD_PATH.unshift File.expand_path('../..', File.dirname(__FILE__))
+require 'roby/test/common'
+require 'roby/test/tasks/simple_task'
+require 'flexmock'
+
+class TC_ExecutedBy < Test::Unit::TestCase
+    include Roby::Test
+
+    class ExecutionAgentModel < SimpleTask
+	event :ready
+	forward :start => :ready
+    end
+
+    def test_relationships
+	plan.discover(task = SimpleTask.new)
+	exec_task = ExecutionAgentModel.new
+
+	task.executed_by exec_task
+	assert_equal(exec_task, task.execution_agent)
+    end
+
+    def test_inherits_execution_model
+	model = Class.new(Roby::Task) do
+	    executed_by ExecutionAgentModel
+	end
+	submodel = Class.new(model)
+
+	assert_equal(ExecutionAgentModel, submodel.execution_agent)
+    end
+
+    def test_nominal
+	plan.discover(task = SimpleTask.new)
+	task.executed_by(ExecutionAgentModel.new)
+	task.executed_by(exec = ExecutionAgentModel.new)
+
+	FlexMock.use do |mock|
+	    exec.on(:start) { mock.agent_started }
+	    exec.on(:ready) { mock.agent_ready }
+	    task.on(:start) { mock.task_started }
+
+	    mock.should_receive(:agent_started).once.ordered
+	    mock.should_receive(:agent_ready).once.ordered
+	    mock.should_receive(:task_started).once.ordered
+	    task.start!
+	end
+
+	task.stop!
+	assert_nothing_raised { exec.stop! }
+    end
+
+    def test_agent_fails
+	plan.discover(task = SimpleTask.new)
+	exec = ExecutionAgentModel.new
+	task.executed_by exec
+	task.start!
+
+	FlexMock.use do |mock|
+	    task.on(:aborted) { mock.aborted }
+	    mock.should_receive(:aborted).once
+	    exec.stop!
+	end
+	assert(!task.running?)
+    end
+
+    def test_agent_start_failed
+	plan.insert(task = SimpleTask.new)
+	exec = Class.new(SimpleTask) do
+	    event :ready
+	    on :start => :failed
+	end.new
+	task.executed_by exec
+
+	assert_original_error(NilClass, EmissionFailed) { task.start! }
+	assert(!task.running?)
+	assert(!exec.running?)
+	assert(exec.finished?)
+    end
+
+    def test_agent_model
+	task_model = Class.new(SimpleTask)
+
+	task_model.executed_by ExecutionAgentModel
+	plan.insert(task = task_model.new)
+	assert(task.execution_agent)
+	assert(ExecutionAgentModel, task.execution_agent.class)
+
+	task.start!
+	assert(task.running?)
+	assert(task.execution_agent.running?)
+    end
+
+    def test_respawn
+	task_model = Class.new(SimpleTask)
+	task_model.executed_by ExecutionAgentModel
+	first, second = prepare_plan :discover => 2, :model => task_model
+	assert(first.execution_agent)
+	assert(ExecutionAgentModel, first.execution_agent.class)
+	assert(second.execution_agent)
+	assert(ExecutionAgentModel, second.execution_agent.class)
+	assert_same(first.execution_agent, second.execution_agent)
+
+	first.start!
+	assert(first.running?)
+	first_agent = first.execution_agent
+	assert(first_agent.running?)
+
+	plan.discover(third = task_model.new)
+	assert_equal(first.execution_agent, third.execution_agent)
+
+	first.execution_agent.stop!
+	assert(first.event(:aborted).happened?)
+	assert(first_agent.finished?)
+	assert(second.execution_agent)
+	assert(second.execution_agent.pending?)
+    end
+
+    def test_cannot_respawn
+	plan.insert(task  = Class.new(SimpleTask).new)
+	task.executed_by(agent = ExecutionAgentModel.new)
+
+	agent.start!
+	agent.stop!
+	assert_raises(CommandFailed) { task.start! }
+    end
+
+    def test_initialization
+	agent = Class.new(SimpleTask) do
+	    event :ready, :command => true
+	end.new
+	task, (init1, init2) = prepare_plan :missions => 1, :discover => 2, :model => SimpleTask
+	task.executed_by agent
+	init1.executed_by agent
+	init2.executed_by agent
+
+	agent.realized_by(init = (init1 + init2))
+	agent.on(:start, init, :start)
+	init.forward(:success, agent, :ready)
+
+	task.start!
+	assert(!task.running?)
+	assert(!agent.event(:ready).happened?)
+	assert(init1.running?)
+	assert(!init2.running?)
+	init1.success!
+	init2.success!
+	assert(agent.event(:ready).happened?)
+    end
+end
+

data/test/relations/test_hierarchy.rb

@@ -0,0 +1,158 @@
+$LOAD_PATH.unshift File.expand_path('..', File.dirname(__FILE__))
+require 'roby/test/common'
+require 'roby/test/tasks/simple_task'
+
+class TC_RealizedBy < Test::Unit::TestCase
+    include Roby::Test
+
+    def test_definition
+	tag   = TaskModelTag.new
+	klass = Class.new(SimpleTask) do
+	    argument :id
+	    include tag
+	end
+	plan.discover(t1 = SimpleTask.new)
+
+	# Check validation of the model
+	child = nil
+	assert_nothing_raised { t1.realized_by((child = klass.new), :model => SimpleTask) }
+
+	assert_same(Hierarchy.interesting_events, EventGenerator.event_gathering[child.event(:success)].find { true })
+	assert_same(Hierarchy.interesting_events, EventGenerator.event_gathering[child.event(:failed)].find { true })
+	assert_equal([SimpleTask, {}], t1[child, Hierarchy][:model])
+
+	assert_nothing_raised { t1.realized_by klass.new, :model => [Roby::Task, {}] }
+	assert_nothing_raised { t1.realized_by klass.new, :model => tag }
+
+	plan.discover(simple_task = SimpleTask.new)
+	assert_raises(ArgumentError) { t1.realized_by simple_task, :model => [Class.new(Roby::Task), {}] }
+	assert_raises(ArgumentError) { t1.realized_by simple_task, :model => TaskModelTag.new }
+	
+	# Check validation of the arguments
+	plan.discover(model_task = klass.new)
+	assert_raises(ArgumentError) { t1.realized_by model_task, :model => [SimpleTask, {:id => 'bad'}] }
+
+	plan.discover(child = klass.new(:id => 'good'))
+	assert_raises(ArgumentError) { t1.realized_by child, :model => [klass, {:id => 'bad'}] }
+	assert_nothing_raised { t1.realized_by child, :model => [klass, {:id => 'good'}] }
+	assert_equal([klass, { :id => 'good' }], t1[child, TaskStructure::Hierarchy][:model])
+
+	# Check edge annotation
+	t2 = SimpleTask.new
+	t1.realized_by t2, :model => SimpleTask
+	assert_equal([SimpleTask, {}], t1[t2, TaskStructure::Hierarchy][:model])
+	t2 = klass.new(:id => 10)
+	t1.realized_by t2, :model => [klass, { :id => 10 }]
+    end
+
+    Hierarchy = TaskStructure::Hierarchy
+
+    def assert_children_failed(children, plan)
+	result = Hierarchy.check_structure(plan)
+	assert_equal(children.to_set, result.map { |e| e.failed_task }.to_set)
+    end
+
+    def test_failure_point
+	model = Class.new(SimpleTask) do
+	    event :specialized_failure, :command => true
+	    forward :specialized_failure => :failed
+	end
+	parent, child = prepare_plan :discover => 1, :tasks => 1, :model => model
+	parent.realized_by child
+
+	parent.start!
+	child.start!
+	child.specialized_failure!
+
+	error = Hierarchy.check_structure(plan).first.exception
+	assert_kind_of(ChildFailedError, error)
+	assert_equal(child.event(:specialized_failure).last, error.failure_point)
+	assert_equal(child.event(:specialized_failure).last, error.failed_event)
+
+	parent.stop!
+    end
+
+    def test_exception_printing
+        parent, child = prepare_plan :discover => 2, :model => SimpleTask
+        parent.realized_by child
+        parent.start!
+        child.start!
+        child.failed!
+
+	error = Hierarchy.check_structure(plan).first.exception
+	assert_kind_of(ChildFailedError, error)
+        assert_nothing_raised do
+            Roby.format_exception(error)
+        end
+
+        parent.stop!
+    end
+
+    def test_structure_checking
+	child_model = Class.new(SimpleTask) do
+	    event :first, :command => true
+	    event :second, :command => true
+	end
+
+	p1 = SimpleTask.new
+	child = child_model.new
+	plan.discover([p1, child])
+	p1.realized_by child
+	plan.insert(p1)
+
+	child.start!; p1.start!
+	assert_equal([], Hierarchy.check_structure(plan))
+	child.stop!
+	assert_equal([child.event(:failed).last], Hierarchy.interesting_events)
+	assert_children_failed([child], plan)
+
+	plan.clear
+	p1 = SimpleTask.new
+	child = child_model.new
+	plan.discover([p1, child])
+	p1.realized_by child, :success => [:second], :failure => [:first]
+	plan.insert(p1)
+	child.start! ; p1.start!
+	child.event(:first).emit(nil)
+	assert_children_failed([child], plan)
+
+	plan.clear
+	p1    = SimpleTask.new
+	child = child_model.new
+	plan.discover([p1, child])
+	p1.realized_by child, :success => [:first], :failure => [:second]
+	plan.insert(p1)
+	child.start! ; p1.start!
+	child.event(:first).emit(nil)
+	assert_children_failed([], plan)
+	child.event(:second).emit(nil)
+	assert_children_failed([], plan)
+    end
+
+    def test_fullfilled_model
+	tag = TaskModelTag.new
+	klass = Class.new(SimpleTask) do
+	    include tag
+	end
+
+	p1, p2, child = prepare_plan :discover => 3, :model => klass
+
+	p1.realized_by child, :model => SimpleTask
+	p2.realized_by child, :model => Roby::Task
+	assert_equal([[SimpleTask], {}], child.fullfilled_model)
+	p1.remove_child(child)
+	assert_equal([[Roby::Task], {}], child.fullfilled_model)
+	p1.realized_by child, :model => tag
+	assert_equal([[Roby::Task, tag], {}], child.fullfilled_model)
+    end
+
+    def test_first_children
+	p, c1, c2 = prepare_plan :discover => 3, :model => SimpleTask
+	p.realized_by c1
+	p.realized_by c2
+	assert_equal([c1, c2].to_value_set, p.first_children)
+
+	c1.on(:start, c2, :start)
+	assert_equal([c1].to_value_set, p.first_children)
+    end
+end