roby 0.8.0 → 3.0.0

data/test/relations/test_conflicts.rb

@@ -1,42 +0,0 @@
-$LOAD_PATH.unshift File.expand_path(File.join('..', '..', 'lib'), 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.add(t1 = m1.new)
-	plan.add(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_dependency.rb

@@ -1,324 +0,0 @@
-$LOAD_PATH.unshift File.expand_path(File.join('..', '..', 'lib'), File.dirname(__FILE__))
-require 'roby/test/common'
-require 'roby/test/tasks/simple_task'
-
-class TC_RealizedBy < Test::Unit::TestCase
-    include Roby::Test
-
-    def test_check_structure_registration
-        assert plan.structure_checks.include?(Dependency.method(:check_structure))
-    end
-
-    def test_definition
-	tag   = TaskModelTag.new
-	klass = Class.new(SimpleTask) do
-	    argument :id
-	    include tag
-	end
-	plan.add(t1 = SimpleTask.new)
-
-	# Check validation of the model
-	child = nil
-	assert_nothing_raised { t1.depends_on((child = klass.new), :model => SimpleTask) }
-	assert_equal([SimpleTask, {}], t1[child, Dependency][:model])
-
-	assert_nothing_raised { t1.depends_on klass.new, :model => [Roby::Task, {}] }
-	assert_nothing_raised { t1.depends_on klass.new, :model => tag }
-
-	plan.add(simple_task = SimpleTask.new)
-	assert_raises(ArgumentError) { t1.depends_on simple_task, :model => [Class.new(Roby::Task), {}] }
-	assert_raises(ArgumentError) { t1.depends_on simple_task, :model => TaskModelTag.new }
-	
-	# Check validation of the arguments
-	plan.add(model_task = klass.new)
-	assert_raises(ArgumentError) { t1.depends_on model_task, :model => [SimpleTask, {:id => 'bad'}] }
-
-	plan.add(child = klass.new(:id => 'good'))
-	assert_raises(ArgumentError) { t1.depends_on child, :model => [klass, {:id => 'bad'}] }
-	assert_nothing_raised { t1.depends_on child, :model => [klass, {:id => 'good'}] }
-	assert_equal([klass, { :id => 'good' }], t1[child, TaskStructure::Dependency][:model])
-
-	# Check edge annotation
-	t2 = SimpleTask.new
-	t1.depends_on t2, :model => SimpleTask
-	assert_equal([SimpleTask, {}], t1[t2, TaskStructure::Dependency][:model])
-	t2 = klass.new(:id => 10)
-	t1.depends_on t2, :model => [klass, { :id => 10 }]
-    end
-
-    Dependency = TaskStructure::Dependency
-
-    def test_exception_printing
-        parent, child = prepare_plan :add => 2, :model => SimpleTask
-        parent.depends_on child
-        parent.start!
-        child.start!
-        child.failed!
-
-	error = plan.check_structure.find { true }[0].exception
-	assert_kind_of(ChildFailedError, error)
-        assert_nothing_raised do
-            Roby.format_exception(error)
-        end
-
-        parent.stop!
-    end
-
-    # This method is a common method used in the various error/nominal tests
-    # below. It creates two tasks:
-    #  p1 which is an instance of SimpleTask
-    #  child which is an instance of a task model with two controllable events
-    #  'first' and 'second'
-    #
-    # p1 is a parent of child. Both tasks are started and returned.
-    def create_pair(options)
-	child_model = Class.new(SimpleTask) do
-	    event :first, :command => true
-	    event :second, :command => true
-	end
-
-	p1 = SimpleTask.new
-	child = child_model.new
-	plan.add([p1, child])
-	p1.depends_on child, options
-	plan.add_mission(p1)
-
-	child.start!; p1.start!
-        return p1, child
-    end
-
-    def assert_child_failed(child, reason, plan)
-	result = plan.check_structure
-	assert_equal([child].to_set, result.map { |e, _| e.exception.failed_task }.to_set)
-	assert_equal([reason].to_set, result.map { |e, _| e.exception.failed_event }.to_set)
-    end
-
-
-    def test_success
-        parent, child = create_pair :success => [:first], 
-            :failure => [:stop],
-            :remove_when_done => false
-
-	assert_equal({}, plan.check_structure)
-	child.first!
-	assert_equal({}, plan.check_structure)
-        assert(parent.depends_on?(child))
-    end
-
-    def test_success_removal
-        parent, child = create_pair :success => [:first], 
-            :failure => [:stop],
-            :remove_when_done => true
-
-	child.first!
-	assert_equal({}, plan.check_structure)
-        assert(!parent.depends_on?(child))
-    end
-
-    def test_success_preempts_explicit_failed
-        parent, child = create_pair :success => [:first], 
-            :failure => [:stop]
-
-	child.first!
-        child.stop!
-	assert_equal({}, plan.check_structure)
-    end
-
-    def test_success_preempts_failure_on_unreachable
-        parent, child = create_pair :success => [:first]
-
-	child.first!
-        child.stop!
-	assert_equal({}, plan.check_structure)
-    end
-
-    def test_failure_explicit
-        parent, child = create_pair :success => [:first], 
-            :failure => [:stop]
-
-        child.stop!
-	assert_child_failed(child, child.event(:stop).last, plan)
-        plan.clear
-    end
-
-    def test_failure_on_unreachable
-        parent, child = create_pair :success => [:first]
-
-        child.stop!
-	assert_child_failed(child, child.event(:failed).last, plan)
-        plan.clear
-    end
-
-    def test_fullfilled_model_validation
-	tag = TaskModelTag.new
-	klass = Class.new(Roby::Task)
-
-	p1, p2, child = prepare_plan :add => 3, :model => SimpleTask
-	p1.depends_on child, :model => [SimpleTask, { :id => "discover-3" }]
-        p2.depends_on child, :model => [SimpleTask, { :id => 'discover-3' }]
-
-        # Mess with the relation definition
-        p1[child, Dependency][:model].last[:id] = 'discover-10'
-        assert_raises(ModelViolation) { child.fullfilled_model }
-        p1[child, Dependency][:model] = [klass, {}]
-        assert_raises(ModelViolation) { child.fullfilled_model }
-    end
-
-    def test_fullfilled_model
-	tag = TaskModelTag.new
-	klass = Class.new(SimpleTask) do
-	    include tag
-	end
-
-	p1, p2, child = prepare_plan :add => 3, :model => klass
-
-	p1.depends_on child, :model => [SimpleTask, { :id => "discover-3" }]
-	p2.depends_on child, :model => Roby::Task
-	assert_equal([[SimpleTask], {:id => 'discover-3'}], child.fullfilled_model)
-	p1.remove_child(child)
-	assert_equal([[Roby::Task], {}], child.fullfilled_model)
-	p1.depends_on child, :model => tag
-	assert_equal([[Roby::Task, tag], {}], child.fullfilled_model)
-	p2.remove_child(child)
-	p2.depends_on child, :model => [klass, { :id => 'discover-3' }]
-	assert_equal([[klass, tag], {:id => 'discover-3'}], child.fullfilled_model)
-    end
-
-    def test_fullfilled_model_transaction
-	tag = TaskModelTag.new
-	klass = Class.new(SimpleTask) do
-	    include tag
-	end
-
-	p1, p2, child = prepare_plan :add => 3, :model => Class.new(klass)
-        trsc = Transaction.new(plan)
-
-	p1.depends_on child, :model => [SimpleTask, { :id => "discover-3" }]
-	p2.depends_on child, :model => klass
-
-        t_child = trsc[child]
-        assert_equal([[klass], {:id => "discover-3"}], t_child.fullfilled_model)
-        t_p2 = trsc[p2]
-        assert_equal([[klass], {:id => "discover-3"}], t_child.fullfilled_model)
-        t_p2.remove_child(t_child)
-        assert_equal([[SimpleTask], { :id => 'discover-3' }], t_child.fullfilled_model)
-	t_p2.depends_on t_child, :model => klass
-        assert_equal([[klass], { :id => 'discover-3' }], t_child.fullfilled_model)
-        trsc.remove_object(t_p2)
-        assert_equal([[SimpleTask], { :id => 'discover-3' }], t_child.fullfilled_model)
-    end
-
-    def test_first_children
-	p, c1, c2 = prepare_plan :add => 3, :model => SimpleTask
-	p.depends_on c1
-	p.depends_on c2
-	assert_equal([c1, c2].to_value_set, p.first_children)
-
-	c1.signals(:start, c2, :start)
-	assert_equal([c1].to_value_set, p.first_children)
-    end
-
-    def test_remove_finished_children
-	p, c1, c2 = prepare_plan :add => 3, :model => SimpleTask
-        plan.add_permanent(p)
-	p.depends_on c1
-	p.depends_on c2
-
-        p.start!
-        c1.start!
-        c1.success!
-        p.remove_finished_children
-        process_events
-        assert(!plan.include?(c1))
-        assert(plan.include?(c2))
-    end
-
-    def test_role_definition
-        plan.add(parent = SimpleTask.new)
-
-        child = SimpleTask.new
-        parent.depends_on child, :role => 'child1'
-        assert_equal(['child1'].to_set, parent.roles_of(child))
-
-        child = SimpleTask.new
-        parent.depends_on child, :roles => ['child1', 'child2']
-        assert_equal(['child1', 'child2'].to_set, parent.roles_of(child))
-    end
-
-    def setup_merging_test
-        plan.add(parent = SimpleTask.new)
-        tag = TaskModelTag.new
-        intermediate = Class.new(SimpleTask)
-        intermediate.include tag
-        child_model = Class.new(intermediate)
-        child = child_model.new(:id => 'child')
-        parent.depends_on child, :role => 'child1', :model => Task, :success => [], :failure => []
-
-        expected_info = { :remove_when_done=>true,
-            :model => [Roby::Task, {}],
-            :roles => ['child1'].to_set,
-            :success=>[],
-            :failure=>[] }
-        assert_equal expected_info, parent[child, Dependency]
-
-        return parent, child, expected_info, child_model, tag
-    end
-
-    def test_merging_events
-        parent, child, info, child_model, _ = setup_merging_test
-        parent.depends_on child, :success => []
-        info[:model] = [child_model, {:id => 'child'}]
-        assert_equal info, parent[child, Dependency]
-
-        parent.depends_on child, :success => [:success]
-        info[:success] = [:success]
-        assert_equal info, parent[child, Dependency]
-
-        assert_raises(ModelViolation) { parent.depends_on child, :failure => [:success] }
-        assert_equal info, parent[child, Dependency]
-
-        parent.depends_on child, :failure => [:stop]
-        info[:failure] = [:stop]
-        assert_equal info, parent[child, Dependency]
-    end
-    
-    def test_merging_remove_when_done_cannot_change
-        parent, child, info, _ = setup_merging_test
-        assert_raises(ModelViolation) { parent.depends_on child, :remove_when_done => false }
-        parent.depends_on child, :model => info[:model], :remove_when_done => true, :success => []
-        assert_equal info, parent[child, Dependency]
-    end
-
-    def test_merging_models
-        parent, child, info, child_model, tag = setup_merging_test
-
-        # Test that models are "upgraded"
-        parent.depends_on child, :model => SimpleTask, :success => []
-        info[:model][0] = SimpleTask
-        assert_equal info, parent[child, Dependency]
-        parent.depends_on child, :model => Roby::Task, :remove_when_done => true, :success => []
-        assert_equal info, parent[child, Dependency]
-
-        # Test that arguments are merged
-        parent.depends_on child, :model => [SimpleTask, {:id => 'child'}], :success => []
-        info[:model][1] = {:id => 'child'}
-        assert_equal info, parent[child, Dependency]
-        # note: arguments can't be changed on the task *and* #depends_on
-        # validates them, so we don't need to test that.
-
-        # Test model/tag handling: #depends_on should find the most generic
-        # model matching +task+ that includes all required models
-        parent.depends_on child, :model => tag, :success => []
-        info[:model][0] = child_model.superclass
-        assert_equal info, parent[child, Dependency]
-    end
-
-    def test_merging_roles
-        parent, child, info, _ = setup_merging_test
-
-        parent.depends_on child, :model => Roby::Task, :role => 'child2', :success => []
-        info[:roles] << 'child2'
-        assert_equal info, parent[child, Dependency]
-    end
-end
-

data/test/relations/test_ensured.rb

@@ -1,38 +0,0 @@
-$LOAD_PATH.unshift File.expand_path(File.join('..', '..', 'lib'), 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.add [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

@@ -1,224 +0,0 @@
-$LOAD_PATH.unshift File.expand_path(File.join('..', '..', 'lib'), 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
-    class SecondExecutionModel < SimpleTask
-	event :ready
-	forward :start => :ready
-    end
-
-    def test_relationships
-	plan.add(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, :id => 20
-	end
-	submodel = Class.new(model)
-
-	assert_equal([ExecutionAgentModel, {:id => 20}], submodel.execution_agent)
-    end
-
-    def test_nominal
-	plan.add(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.add(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.add_mission(task = SimpleTask.new)
-	exec = Class.new(SimpleTask) do
-	    event :ready
-	    signal :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_spawns
-	task_model = Class.new(SimpleTask)
-
-	task_model.executed_by ExecutionAgentModel, :id => 10
-	plan.add_mission(task = task_model.new)
-	assert(task.execution_agent)
-        assert_equal(10, task.execution_agent.arguments[:id])
-	assert_kind_of(ExecutionAgentModel, task.execution_agent)
-
-	task.start!
-	assert(task.running?)
-	assert(task.execution_agent.running?)
-    end
-
-    def test_agent_model_reuses
-        plan.add_permanent(agent = ExecutionAgentModel.new)
-
-	task_model = Class.new(SimpleTask)
-	task_model.executed_by ExecutionAgentModel
-
-	plan.add_mission(task = task_model.new)
-	assert_same(agent, task.execution_agent)
-
-	task.start!
-	assert(task.running?)
-	assert(task.execution_agent.running?)
-    end
-
-    def test_agent_model_reuses_running_agent
-        plan.add_permanent(agent = ExecutionAgentModel.new)
-        agent.start!
-
-	task_model = Class.new(SimpleTask)
-	task_model.executed_by ExecutionAgentModel
-
-	plan.add_mission(task = task_model.new)
-	assert_same(agent, task.execution_agent)
-
-	task.start!
-	assert(task.running?)
-    end
-
-    def test_agent_model_arguments
-        plan.add_permanent(agent1 = ExecutionAgentModel.new(:id => 1))
-        plan.add_permanent(agent2 = ExecutionAgentModel.new(:id => 2))
-
-	task_model = Class.new(SimpleTask)
-	task_model.executed_by ExecutionAgentModel, :id => 2
-
-	plan.add_mission(task = task_model.new)
-	assert_same(agent2, task.execution_agent)
-
-	task.start!
-	assert(task.running?)
-	assert(task.execution_agent.running?)
-    end
-
-    def test_task_has_wrong_agent
-	task_model = Class.new(SimpleTask)
-	task_model.executed_by ExecutionAgentModel, :id => 2
-
-	plan.add_mission(task = task_model.new)
-
-        # Wrong agent type
-        plan.remove_object(task.execution_agent)
-        task.executed_by SecondExecutionModel.new(:id => 2)
-        assert_raises(Roby::CommandFailed) { task.start! }
-
-        # Wrong agent arguments
-        plan.remove_object(task.execution_agent)
-        task.executed_by ExecutionAgentModel.new(:id => 3)
-        assert_raises(Roby::CommandFailed) { task.start! }
-    end
-
-    def test_model_requires_agent_but_none_exists
-	task_model = Class.new(SimpleTask)
-	task_model.executed_by ExecutionAgentModel, :id => 2
-
-	plan.add_mission(task = task_model.new)
-        plan.remove_object(task.execution_agent)
-
-        assert_raises(Roby::CommandFailed) { task.start! }
-    end
-
-    def test_respawn
-	task_model = Class.new(SimpleTask)
-	task_model.executed_by ExecutionAgentModel
-	first, second = prepare_plan :add => 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.add(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.add_mission(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, :add => 2, :model => SimpleTask
-	task.executed_by agent
-	init1.executed_by agent
-	init2.executed_by agent
-
-	agent.depends_on(init = (init1 + init2))
-	agent.signals(:start, init, :start)
-	init.forward_to(: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
-