roby 0.8.0 → 3.0.0

data/test/test_query.rb

@@ -1,424 +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/state/information'
-require 'flexmock'
-
-class TC_Query < Test::Unit::TestCase
-    include Roby::Test
-
-    def check_matches_fullfill(task_model, plan, t0, t1, t2)
-	result = TaskMatcher.new.enum_for(:each, plan).to_set
-	assert_equal([t1, t2, t0].to_set, result)
-	result = TaskMatcher.new.with_model(Roby::Task).enum_for(:each, plan).to_set
-	assert_equal([t1, t2, t0].to_set, result, plan.task_index.by_model)
-
-	result = TaskMatcher.which_fullfills(task_model).enum_for(:each, plan).to_set
-	assert_equal([t1, t2].to_set, result)
-
-	result = TaskMatcher.with_model(task_model).enum_for(:each, plan).to_set
-	assert_equal([t1, t2].to_set, result)
-	result = TaskMatcher.with_arguments(:value => 1).enum_for(:each, plan).to_set
-	assert_equal([t0, t1].to_set, result)
-
-	result = TaskMatcher.which_fullfills(task_model, :value => 1).enum_for(:each, plan).to_set
-	assert_equal([t1].to_set, result)
-
-	result = plan.find_tasks.which_fullfills(task_model, :value => 2).to_set
-	assert_equal([t2].to_set, result)
-	# Try the shortcut of find_tasks(model, args) for find_tasks.which_fullfills(model, args)
-	result = plan.find_tasks(task_model, :value => 2).to_set
-	assert_equal([t2].to_set, result)
-	result = plan.find_tasks(task_model).to_set
-	assert_equal([t1, t2].to_set, result)
-
-	assert_marshallable(TaskMatcher.new.which_fullfills(task_model, :value => 2))
-    end
-
-    def test_match_task_fullfills
-	task_model = Class.new(Task) do
-	    argument :value
-	end
-
-	t0 = Roby::Task.new(:value => 1)
-	t1 = task_model.new(:value => 1)
-	t2 = task_model.new(:value => 2)
-
-	plan.add_mission(t0)
-	plan.add_mission(t1)
-	plan.add_mission(t2)
-
-	check_matches_fullfill(task_model, plan, t0, t1, t2)
-    end
-
-    def test_match_tag
-        tag = TaskModelTag.new
-        tag.argument :id
-	task_model = Class.new(SimpleTask)
-        task_model.include tag
-
-        plan.add(task = task_model.new(:id => 3))
-        assert(Task.match(tag)              === task)
-        assert(Task.match(tag, :id => 3)    === task)
-        assert(! (Task.match(tag, :id => 2) === task))
-
-        plan.add(task = SimpleTask.new)
-        assert(! (Task.match(tag)           === task))
-        assert(! (Task.match(tag, :id => 3) === task))
-        assert(! (Task.match(tag, :id => 2) === task))
-    end
-
-    def test_match_proxy_fullfills
-	task_model = Class.new(Task) do
-	    argument :value
-	end
-
-	t0 = Roby::Task.new(:value => 1)
-	t1 = task_model.new(:value => 1)
-	t2 = task_model.new(:value => 2)
-
-	plan.add_mission(t0)
-	plan.add_mission(t1)
-	plan.add_mission(t2)
-
-	trsc = Transaction.new(plan)
-	check_matches_fullfill(task_model, trsc, trsc[t0], trsc[t1], trsc[t2])
-    end
-
-    def test_query_information
-	t1 = Class.new(Task) do
-	    needs :source_info
-	    improves :other_info
-	end.new
-	t2 = Class.new(Task) do
-	    needs :source_info
-	    improves :yet_another_info
-	end.new
-
-	plan.add [t1, t2]
-	result = TaskMatcher.which_needs(:source_info).enum_for(:each, plan).to_set
-	assert_equal([t1, t2].to_set, result)
-	result = TaskMatcher.which_needs(:foo_bar).enum_for(:each, plan).to_set
-	assert_equal(Set.new, result)
-	result = TaskMatcher.which_improves(:foo_bar).enum_for(:each, plan).to_set
-	assert_equal(Set.new, result)
-	result = TaskMatcher.which_improves(:other_info).enum_for(:each, plan).to_set
-	assert_equal([t1].to_set, result)
-	result = TaskMatcher.which_needs(:source_info).
-	    which_improves(:yet_another_info).
-	    enum_for(:each, plan).to_set
-
-	assert_equal([t2].to_set, result)
-    end
-
-    def assert_query_finds_tasks(task_set)
-	assert_equal(task_set.to_set, yield.enum_for(:each).to_set)
-    end
-
-    def assert_finds_tasks(task_set, msg = "")
-	assert_equal(task_set.to_set, yield.enum_for(:each, plan).to_set, msg)
-    end
-
-    def test_query_predicates
-	t1 = Class.new(SimpleTask) { argument :fake }.new
-	t2 = Roby::Task.new
-	plan.add [t1, t2]
-
-	assert_finds_tasks([]) { TaskMatcher.executable }
-	assert_finds_tasks([t1,t2]) { TaskMatcher.not_executable }
-	assert_finds_tasks([t2]) { TaskMatcher.abstract }
-	assert_finds_tasks([t1]) { TaskMatcher.partially_instanciated }
-	assert_finds_tasks([t2]) { TaskMatcher.fully_instanciated }
-	t1.arguments[:fake] = 2
-	assert_finds_tasks([t1, t2]) { TaskMatcher.fully_instanciated }
-	assert_finds_tasks([t2]) { TaskMatcher.fully_instanciated.abstract }
-
-	assert_finds_tasks([t1, t2]) { TaskMatcher.pending }
-	t1.start!
-	assert_finds_tasks([t2]) { TaskMatcher.pending }
-	assert_finds_tasks([t1, t2]) { TaskMatcher.not_failed }
-	assert_finds_tasks([t1, t2]) { TaskMatcher.not_success }
-	assert_finds_tasks([t1, t2]) { TaskMatcher.not_finished }
-
-	assert_finds_tasks([t1]) { TaskMatcher.running }
-	t1.success!
-	assert_finds_tasks([t1], plan.task_index.by_state) { TaskMatcher.success }
-	assert_finds_tasks([t1]) { TaskMatcher.finished }
-	assert_finds_tasks([t1, t2]) { TaskMatcher.not_failed }
-	assert_finds_tasks([t2]) { TaskMatcher.not_finished }
-
-	plan.remove_object(t1)
-
-	t1 = SimpleTask.new
-	plan.add(t1)
-	t1.start!
-	t1.failed!
-	assert_finds_tasks([t1]) { TaskMatcher.failed }
-	assert_finds_tasks([t1]) { TaskMatcher.finished }
-	assert_finds_tasks([t1]) { TaskMatcher.finished.not_success }
-    end
-
-    def test_query_plan_predicates
-	t1, t2, t3 = prepare_plan :missions => 1, :add => 1, :tasks => 1
-	plan.add_permanent(t3)
-	assert_query_finds_tasks([t1]) { plan.find_tasks.mission }
-	assert_query_finds_tasks([t2, t3]) { plan.find_tasks.not_mission }
-	assert_query_finds_tasks([t3]) { plan.find_tasks.permanent }
-	assert_query_finds_tasks([t1, t2]) { plan.find_tasks.not_permanent }
-    end
-
-    def test_negate
-	t1 = Class.new(SimpleTask) { argument :id }.new(:id => 1)
-	t2 = Class.new(SimpleTask) { argument :id }.new(:id => 2)
-	t3 = Roby::Task.new
-	plan.add [t1, t2, t3]
-
-	assert_finds_tasks([t3]) { (TaskMatcher.with_arguments(:id => 1) | TaskMatcher.with_arguments(:id => 2)).negate }
-    end
-
-    def test_or
-	t1 = Class.new(SimpleTask) { argument :id }.new(:id => 1)
-	t2 = Class.new(SimpleTask) { argument :id }.new(:id => 2)
-	t3 = Roby::Task.new
-	plan.add [t1, t2, t3]
-
-	assert_finds_tasks([t1, t2]) { TaskMatcher.with_arguments(:id => 1) | TaskMatcher.with_arguments(:id => 2) }
-    end
-
-    def test_and
-	t1 = Class.new(SimpleTask) { argument :id }.new(:id => 1)
-	t2 = Class.new(SimpleTask) { argument :id }.new(:id => 2)
-	t3 = Roby::Task.new
-	plan.add [t1, t2, t3]
-
-	assert_finds_tasks([t1, t2]) { TaskMatcher.fully_instanciated & TaskMatcher.executable }
-	assert_finds_tasks([t1]) { (TaskMatcher.fully_instanciated & TaskMatcher.executable).with_arguments(:id => 1) }
-	assert_finds_tasks([t3]) { TaskMatcher.fully_instanciated & TaskMatcher.abstract }
-    end
-
-    def test_merged_generated_subgraphs
-	(d1, d2, d3, d4, d5, d6), t1 = prepare_plan :add => 6, :tasks => 1
-
-	trsc = Transaction.new(plan)
-	d1.depends_on d2
-	d2.depends_on d3
-	d4.depends_on d5
-	d5.depends_on d6
-
-	# Add a new relation which connects two components. Beware that
-	# modifying trsc[d3] and trsc[d4] makes d2 and d5 proxies to be
-	# discovered
-	trsc[d3].depends_on t1
-	t1.depends_on trsc[d4]
-	plan_set, trsc_set = trsc.merged_generated_subgraphs(TaskStructure::Hierarchy, [d1], [])
-	assert_equal([trsc[d3], trsc[d4], t1].to_value_set, trsc_set)
-	assert_equal([d1, d2, d5, d6].to_value_set, plan_set)
-	
-	# Remove the relation and check the result
-	trsc[d3].remove_child t1
-	plan_set, trsc_set = trsc.merged_generated_subgraphs(TaskStructure::Hierarchy, [d1], [])
-	assert_equal([d1, d2].to_value_set, plan_set)
-	assert_equal([trsc[d3]].to_value_set, trsc_set)
-	plan_set, trsc_set = trsc.merged_generated_subgraphs(TaskStructure::Hierarchy, [], [t1])
-	assert_equal([d5, d6].to_value_set, plan_set)
-	assert_equal([t1, trsc[d4]].to_value_set, trsc_set)
-
-	# Remove a plan relation inside the transaction, and check it is taken into account
-	trsc[d2].remove_child trsc[d3]
-	plan_set, trsc_set = trsc.merged_generated_subgraphs(TaskStructure::Hierarchy, [d1], [])
-	assert_equal([d1].to_value_set, plan_set)
-	assert_equal([trsc[d2]].to_value_set, trsc_set)
-    end
-
-    def test_roots
-	(t1, t2, t3), (tr1, tr2, tr3) = prepare_plan :add => 3, :tasks => 3
-	trsc = Transaction.new(plan)
-	[tr1, tr2, tr3].each { |t| trsc.add(t) }
-
-	assert_equal([t1, t2, t3].to_value_set, plan.find_tasks.roots(TaskStructure::Hierarchy).to_value_set)
-	t1.depends_on t2
-	assert_equal([t1, t3].to_value_set, plan.find_tasks.roots(TaskStructure::Hierarchy).to_value_set)
-
-	tr1.depends_on tr2
-	trsc[t3].depends_on tr3
-	assert_equal([trsc[t1], trsc[t3], tr1].to_value_set, trsc.find_tasks.roots(TaskStructure::Hierarchy).to_value_set)
-    end
-
-    def test_child_match
-        plan.add(t1 = SimpleTask.new(:id => 1))
-        t2 = Class.new(SimpleTask).new(:id => '2')
-        tag = TaskModelTag.new do
-            argument :tag_id
-        end
-        t3_model = Class.new(SimpleTask)
-        t3_model.include tag
-        t3 = t3_model.new(:id => 3, :tag_id => 3)
-        t1.depends_on t2
-        t2.depends_on t3
-        t1.depends_on t3
-
-        # t1    SimpleTask                   :id => 1
-        # t2    t2_model < SimpleTask        :id => '2'
-        # t3    t3_model < tag < SimpleTask  :id => 3
-        # t1 -> t2 -> t3
-        # t1 -> t3
-
-        assert_equal(3, plan.find_tasks(t1.model).to_a.size)
-
-        child_match = TaskMatcher.which_fullfills(SimpleTask, :id => 1)
-        assert_equal([], plan.find_tasks(t1.model).
-            with_child(child_match).to_a)
-
-        assert_equal([t1, t2].to_set, plan.find_tasks(SimpleTask).
-            with_child(SimpleTask).to_set)
-        assert_equal([t1].to_set, plan.find_tasks(SimpleTask).
-            with_child(SimpleTask, :id => '2').to_set)
-        assert_equal([t1].to_set, plan.find_tasks(SimpleTask).
-            with_child(t2.model).with_child(t3.model).to_set)
-        assert_equal([t1, t2].to_set, plan.find_tasks(SimpleTask).
-            with_child(t3.model).to_set)
-        assert_equal([t1, t2].to_set, plan.find_tasks(SimpleTask).
-            with_child(tag, :id => 3).to_set)
-        # :id is not an argument of +tag+, so the following should match, but
-        # the next one not.
-        assert_equal([t1, t2].to_set, plan.find_tasks(SimpleTask).
-            with_child(tag, :id => 2).to_set)
-        assert_equal([].to_set, plan.find_tasks(SimpleTask).
-            with_child(tag, :tag_id => 2).to_set)
-        assert_equal([], plan.find_tasks(t1.model).
-            with_child(SimpleTask, TaskStructure::PlannedBy).to_a)
-
-        t1.planned_by t2
-        assert_equal([t1], plan.find_tasks(t1.model).
-            with_child(SimpleTask, TaskStructure::PlannedBy).to_a)
-        assert_equal([t1], plan.find_tasks(t1.model).
-            with_child(SimpleTask, :relation => TaskStructure::PlannedBy).to_a)
-        assert_equal([], plan.find_tasks(t1.model).
-            with_child(SimpleTask, :id => 42, :relation => TaskStructure::PlannedBy).to_a)
-        assert_equal([], plan.find_tasks(t1.model).
-            with_child(SimpleTask, TaskStructure::PlannedBy, :an_argument => :which_is_set).to_a)
-        t1.remove_child_object(t2, TaskStructure::PlannedBy)
-
-        child_match = TaskMatcher.which_fullfills(SimpleTask, :id => t2.arguments[:id])
-        assert_equal([t1].to_set, plan.find_tasks(t1.model).
-            with_child(child_match).to_set)
-        assert_equal([], plan.find_tasks(t1.model).
-            with_child(SimpleTask, TaskStructure::PlannedBy).to_a)
-    end
-
-    def test_child_in_transactions
-	(t1, t2), t3 = prepare_plan :add => 2, :tasks => 1, :model => SimpleTask
-        t1.depends_on t2
-	trsc = Transaction.new(plan)
-        trsc[t2].depends_on t3
-
-        assert_equal(3, trsc.find_tasks(t1.model).to_a.size)
-        child_match = TaskMatcher.which_fullfills(SimpleTask, :id => 1)
-        assert_equal([], trsc.find_tasks(t1.model).
-            with_child(child_match).to_a)
-
-        child_match = TaskMatcher.which_fullfills(SimpleTask)
-        assert_equal([trsc[t1], trsc[t2]].to_set, trsc.find_tasks(t1.model).
-            with_child(child_match).to_set)
-
-        child_match = TaskMatcher.which_fullfills(SimpleTask, :id => t2.arguments[:id])
-        assert_equal([trsc[t1]].to_set, trsc.find_tasks(t1.model).
-            with_child(child_match).to_set)
-    end
-
-    def test_parent_match
-        plan.add(t1 = SimpleTask.new(:id => 1))
-        t2 = Class.new(SimpleTask).new(:id => 2)
-        t3 = Class.new(SimpleTask).new(:id => 3)
-        t3.depends_on t2
-        t3.depends_on t1
-        t2.depends_on t1
-
-        assert_equal(3, plan.find_tasks(SimpleTask).to_a.size)
-
-        parent_match = TaskMatcher.which_fullfills(SimpleTask, :id => 1)
-        assert_equal([], plan.find_tasks(SimpleTask).
-            with_parent(parent_match).to_a)
-
-        assert_equal([t1, t2].to_set, plan.find_tasks(SimpleTask).
-            with_parent(SimpleTask).to_set)
-        assert_equal([t1].to_set, plan.find_tasks(SimpleTask).
-            with_parent(t3.model).with_parent(t2.model).to_set)
-        assert_equal([], plan.find_tasks(SimpleTask).
-            with_parent(SimpleTask, TaskStructure::PlannedBy).to_a)
-        t2.planned_by t1
-        assert_equal([t1], plan.find_tasks(t1.model).
-            with_parent(SimpleTask, TaskStructure::PlannedBy).to_a)
-        assert_equal([t1], plan.find_tasks(t1.model).
-            with_parent(SimpleTask, :relation => TaskStructure::PlannedBy).to_a)
-        assert_equal([], plan.find_tasks(t1.model).
-            with_parent(SimpleTask, :id => 42, :relation => TaskStructure::PlannedBy).to_a)
-        assert_equal([], plan.find_tasks(t1.model).
-            with_parent(SimpleTask, TaskStructure::PlannedBy, :an_argument => :which_is_set).to_a)
-        t2.remove_child_object(t1, TaskStructure::PlannedBy)
-
-        assert_equal([t1].to_set, plan.find_tasks(SimpleTask).
-            with_parent(SimpleTask, :id => t2.arguments[:id]).to_set)
-        assert_equal([], plan.find_tasks(SimpleTask).
-            with_parent(SimpleTask, :id => t2.arguments[:id], :relation => TaskStructure::PlannedBy).to_a)
-    end
-
-    def test_parent_in_transaction
-	(t1, t2), t3 = prepare_plan :add => 2, :tasks => 1, :model => SimpleTask
-        t1.depends_on t2
-	trsc = Transaction.new(plan)
-        trsc[t2].depends_on t3
-
-        assert_equal(3, trsc.find_tasks(SimpleTask).to_a.size)
-
-        parent_match = TaskMatcher.which_fullfills(SimpleTask, :id => 1)
-        assert_equal([], trsc.find_tasks(SimpleTask).
-            with_parent(parent_match).to_a)
-
-        parent_match = TaskMatcher.which_fullfills(SimpleTask)
-        assert_equal([trsc[t2], t3].to_set, trsc.find_tasks(SimpleTask).
-            with_parent(parent_match).to_set)
-
-        parent_match = TaskMatcher.which_fullfills(SimpleTask, :id => t2.arguments[:id])
-        assert_equal([t3].to_set, trsc.find_tasks(SimpleTask).
-            with_parent(parent_match).to_set)
-    end
-
-    def test_transactions_simple
-	model = Class.new(Roby::Task) do
-	    argument :id
-	end
-	t1, t2, t3 = (1..3).map { |i| model.new(:id => i) }
-	t1.depends_on t2
-	plan.add(t1)
-
-	trsc = Transaction.new(plan)
-	assert(trsc.find_tasks.which_fullfills(SimpleTask).to_a.empty?)
-	assert(!trsc.include?(t1))
-	assert(!trsc.include?(t2))
-	assert(!trsc.include?(t3))
-
-	result = trsc.find_tasks.which_fullfills(model, :id => 1).to_a
-	assert_equal([trsc[t1]], result)
-	assert(!trsc.include?(t2))
-	assert(!trsc.include?(t3))
-
-	# Now that the proxy is in the transaction, check that it is still
-	# found by the query
-	result = trsc.find_tasks.which_fullfills(model, :id => 1).to_a
-	assert_equal([trsc[t1]], result)
-
-	trsc.add(t3)
-	result = trsc.find_tasks.which_fullfills(model, :id => 3).to_a
-	assert_equal([t3], result)
-
-	# Commit the transaction and check that the tasks are added to the plan
-	# index
-	trsc.commit_transaction
-	result = plan.find_tasks.which_fullfills(model, :id => 3).to_a
-	assert_equal([t3], result)
-    end
-end
-
-
-

data/test/test_relations.rb

@@ -1,260 +0,0 @@
-$LOAD_PATH.unshift File.expand_path(File.join('..', 'lib'), File.dirname(__FILE__))
-require 'roby/test/common'
-require 'flexmock'
-
-class TC_Relations < Test::Unit::TestCase
-    include Roby::Test
-
-    def test_definition
-	klass = Class.new
-
-	r1, r2 = nil
-	space = Roby::RelationSpace(klass)
-        r1 = space.relation :R1
-        r2 = space.relation :R2s, :child_name => :child, :parent_name => :parent
-	assert(Module === space)
-
-	n = klass.new
-	assert_equal(r2, space.constant('R2s'))
-        assert(r2.embeds_info?)
-	assert( n.respond_to?(:each_child) )
-	assert( n.respond_to?(:add_child) )
-	assert( n.respond_to?(:remove_child) )
-	assert( n.respond_to?(:each_parent) )
-	assert( n.respond_to?(:add_r1) )
-	assert( n.respond_to?(:add_child) )
-    end
-
-    def test_relation_info
-	klass = Class.new { include DirectedRelationSupport }
-
-	space = Roby::RelationSpace(klass)
-        r2 = space.relation :R2
-        r1 = space.relation :R1, :subsets => [r2]
-        assert(r1.embeds_info?)
-        assert(r2.embeds_info?)
-
-        r3 = space.relation :R3, :noinfo => true
-        r1.superset_of r3
-        assert(!r3.embeds_info?)
-
-	n1, n2 = 2.enum_for(:times).map { klass.new }
-	n1.add_child_object(n2, r2)
-        assert_equal(nil, n1[n2, r2])
-        # Updating from nil to non-nil is allowed
-	n1.add_child_object(n2, r2, false)
-        assert_equal(false, n1[n2, r2])
-        # But changing a non-nil value is not allowed
-        assert_raises(ArgumentError) { n1.add_child_object(n2, r2, true) }
-
-        def r2.merge_info(from, to, old, new)
-            2
-        end
-        # Changing a non-nil value should yield the return value of merge_info
-        n1.add_child_object(n2, r2, true)
-        assert_equal 2, n1[n2, r2]
-    end
-
-    def test_relation_info_in_subgraphs
-	klass = Class.new { include DirectedRelationSupport }
-	space = Roby::RelationSpace(klass)
-        r2 = space.relation :R2
-        r1 = space.relation :R1, :subsets => [r2]
-
-	n1, n2 = 2.enum_for(:times).map { klass.new }
-        n1.add_child_object(n2, r2, obj = Hash.new)
-        assert_equal(obj, n1[n2, r2])
-        assert_equal(nil, n1[n2, r1])
-        n1.add_child_object(n2, r1, other_obj = Hash.new)
-        assert_equal(obj, n1[n2, r2])
-        assert_equal(other_obj, n1[n2, r1])
-
-        n1.remove_child_object(n2, r2)
-
-        # Check that it works as well if we are updating a nil value
-        n1.add_child_object(n2, r2, nil)
-        n1.add_child_object(n2, r2, obj = Hash.new)
-        assert_equal(obj, n1[n2, r2])
-        assert_equal(nil, n1[n2, r1])
-        n1.add_child_object(n2, r1, other_obj = Hash.new)
-        assert_equal(obj, n1[n2, r2])
-        assert_equal(other_obj, n1[n2, r1])
-    end
-
-    def test_add_remove_relations
-	klass = Class.new { include DirectedRelationSupport }
-
-	r1, r2 = nil
-	space = Roby::RelationSpace(klass)
-        r1 = space.relation :R1
-        r2 = space.relation :Child, :parent_name => :parent
-
-	n1, n2, n3, n4 = 4.enum_for(:times).map { klass.new }
-	n1.add_child_object(n2, r1, true)
-	assert_equal([n2], n1.child_objects(r1).to_a)
-	assert_equal([n1], n2.parent_objects(r1).to_a)
-
-	assert( n1.child_object?(n2) )
-	assert( n1.child_object?(n2, r1) )
-	assert( !n1.child_object?(n2, r2) )
-	assert( n2.parent_object?(n1) )
-	assert( n2.parent_object?(n1, r1) )
-	assert( !n2.parent_object?(n1, r2) )
-	assert_equal( [n1], n2.enum_for(:each_parent_object).to_a )
-
-	n1.add_r1(n3)
-	n2.add_child(n4)
-	
-	assert( n1.child_object?(n2) )
-	assert( n1.child_object?(n2, r1) )
-	assert( !n1.child_object?(n2, r2) )
-	assert( n2.parent_object?(n1) )
-	assert( n2.parent_object?(n1, r1) )
-	assert( !n2.parent_object?(n1, r2) )
-	assert_equal( [], n1.enum_for(:each_parent_object).to_a )
-	assert_equal( [], n3.enum_for(:each_child_object).to_a )
-	assert_equal( [n2, n3].to_set, n1.enum_for(:each_child_object).to_set )
-
-	assert( n2.related_object?(n1) )
-	assert( n2.related_object?(n4) )
-
-	n2.remove_child_object(n4, r2)
-	assert(! n2.child_object?(n4) )
-	assert(! n4.parent_object?(n2) )
-
-	n1.remove_children(r2)
-	assert( n1.child_object?(n2) )
-	assert( !n1.child_object?(n4) )
-	assert( !n4.parent_object?(n1) )
-
-	n1.remove_child_object(n2)
-	assert( !n1.child_object?(n2) )
-	assert( !n2.parent_object?(n1) )
-
-    end
-
-    def test_hooks
-	FlexMock.use do |mock|
-	    hooks = Module.new do
-		define_method(:added_child_object) { |to, relations, info| mock.add(to, relations, info) }
-		define_method(:removed_child_object) { |to, relations| mock.remove(to, relations) }
-	    end
-
-	    klass = Class.new do
-		include DirectedRelationSupport 
-		include hooks
-	    end
-		
-	    r1 = nil
-	    space = Roby::RelationSpace(klass)
-            r1 = space.relation :R1
-
-	    v1, v2 = klass.new, klass.new
-	    mock.should_receive(:add).with(v2, [r1], 1).once
-	    mock.should_receive(:remove).with(v2, [r1]).once
-	    v1.add_r1(v2, 1)
-	    v1.remove_r1(v2)
-	end
-    end
-
-    def test_subsets
-	FlexMock.use do |mock|
-	    klass = Class.new do
-		def initialize(index); @index = index end
-		def to_s; "v#{@index.to_s}" end
-		include DirectedRelationSupport
-		define_method(:added_child_object) do |child, relations, info|
-		    super if defined? super
-		    mock.hooked_addition(child, relations)
-		end
-		define_method(:removed_child_object) do |child, relations|
-		    super if defined? super
-		    mock.hooked_removal(child, relations)
-		end
-	    end
-
-	    r1, r2 = nil
-	    space = Roby::RelationSpace(klass)
-            r1 = space.relation :R1
-            r2 = space.relation :R2, :subsets => [r1]
-	    assert_equal(r2, r1.parent)
-	    assert(! r1.subset?(r2))
-	    assert(r2.subset?(r1))
-	    assert(!r1.root_relation?)
-	    assert(r2.root_relation?)
-
-	    n1, n2, n3 = (1..3).map do |i|
-		klass.new(i)
-	    end
-
-	    mock.should_receive(:hooked_addition).with(n2, [r1, r2]).once
-	    n1.add_child_object(n2, r1)
-	    assert(n1.child_object?(n2, r2))
-
-	    mock.should_receive(:hooked_addition).with(n3, [r2]).once
-	    n1.add_child_object(n3, r2)
-	    assert_equal([n2], n1.enum_for(:each_child_object, r1).to_a)
-	    assert_equal([n3, n2].to_set, n1.enum_for(:each_child_object, r2).to_set)
-
-	    mock.should_receive(:hooked_removal).with(n2, [r1, r2]).once
-	    n1.remove_child_object(n2, r1)
-
-	    mock.should_receive(:hooked_removal).with(n3, [r2]).once
-	    n1.remove_child_object(n3, r2)
-	end
-    end
-
-    def test_dag_checking
-	klass = Class.new { include DirectedRelationSupport }
-	graph = RelationGraph.new("test", :dag => true)
-
-	v1, v2, v3 = (1..3).map { v = klass.new; graph.insert(v); v }
-	graph.add_relation(v1, v2, nil)
-	graph.add_relation(v2, v3, nil)
-	assert_raises(CycleFoundError) { graph.add_relation(v3, v1, nil) }
-    end
-
-    def test_single_child
-	klass = Class.new { include DirectedRelationSupport }
-
-	r1 = nil
-	space = Roby::RelationSpace(klass)
-        r1 = space.relation :R1, :single_child => true
-	parent = klass.new 
-	child  = klass.new
-	assert_equal(nil, parent.r1)
-	parent.add_r1(child)
-	assert_equal(child, parent.r1)
-	parent.remove_r1(child)
-	assert_equal(nil, parent.r1)
-    end
-
-    def test_relations
-	klass = Class.new { include DirectedRelationSupport }
-	space = Roby::RelationSpace(klass)
-        r1 = space.relation :R1
-        assert_equal [r1], space.relations
-    end
-
-    def test_child_enumeration_without_info
-	klass = Class.new { include DirectedRelationSupport }
-	space = Roby::RelationSpace(klass)
-        r1 = space.relation :R1, :child_name => 'child', :noinfo => true
-
-        v1, v2 = klass.new, klass.new
-        v1.add_child(v2, :test => true)
-
-        assert_equal([v2], v1.each_child.to_a)
-    end
-    def test_child_enumeration_with_info
-	klass = Class.new { include DirectedRelationSupport }
-	space = Roby::RelationSpace(klass)
-        r1 = space.relation :R1, :child_name => 'child'
-
-        v1, v2 = klass.new, klass.new
-        v1.add_child(v2, :test => true)
-
-        assert_equal([[v2, {:test => true}]], v1.each_child.to_a)
-    end
-end
-