roby 0.7.3 → 0.8.0

data/test/test_query.rb

@@ -1,6 +1,7 @@
-$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/test/tasks/simple_task'
+require 'roby/state/information'
 require 'flexmock'
 
 class TC_Query < Test::Unit::TestCase
@@ -43,13 +44,30 @@ class TC_Query < Test::Unit::TestCase
 	t1 = task_model.new(:value => 1)
 	t2 = task_model.new(:value => 2)
 
-	plan.insert(t0)
-	plan.insert(t1)
-	plan.insert(t2)
+	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
@@ -59,9 +77,9 @@ class TC_Query < Test::Unit::TestCase
 	t1 = task_model.new(:value => 1)
 	t2 = task_model.new(:value => 2)
 
-	plan.insert(t0)
-	plan.insert(t1)
-	plan.insert(t2)
+	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])
@@ -77,7 +95,7 @@ class TC_Query < Test::Unit::TestCase
 	    improves :yet_another_info
 	end.new
 
-	plan.discover [t1, t2]
+	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
@@ -104,7 +122,7 @@ class TC_Query < Test::Unit::TestCase
     def test_query_predicates
 	t1 = Class.new(SimpleTask) { argument :fake }.new
 	t2 = Roby::Task.new
-	plan.discover [t1, t2]
+	plan.add [t1, t2]
 
 	assert_finds_tasks([]) { TaskMatcher.executable }
 	assert_finds_tasks([t1,t2]) { TaskMatcher.not_executable }
@@ -132,7 +150,7 @@ class TC_Query < Test::Unit::TestCase
 	plan.remove_object(t1)
 
 	t1 = SimpleTask.new
-	plan.discover(t1)
+	plan.add(t1)
 	t1.start!
 	t1.failed!
 	assert_finds_tasks([t1]) { TaskMatcher.failed }
@@ -141,8 +159,8 @@ class TC_Query < Test::Unit::TestCase
     end
 
     def test_query_plan_predicates
-	t1, t2, t3 = prepare_plan :missions => 1, :discover => 1, :tasks => 1
-	plan.permanent(t3)
+	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 }
@@ -153,7 +171,7 @@ class TC_Query < Test::Unit::TestCase
 	t1 = Class.new(SimpleTask) { argument :id }.new(:id => 1)
 	t2 = Class.new(SimpleTask) { argument :id }.new(:id => 2)
 	t3 = Roby::Task.new
-	plan.discover [t1, t2, t3]
+	plan.add [t1, t2, t3]
 
 	assert_finds_tasks([t3]) { (TaskMatcher.with_arguments(:id => 1) | TaskMatcher.with_arguments(:id => 2)).negate }
     end
@@ -162,7 +180,7 @@ class TC_Query < Test::Unit::TestCase
 	t1 = Class.new(SimpleTask) { argument :id }.new(:id => 1)
 	t2 = Class.new(SimpleTask) { argument :id }.new(:id => 2)
 	t3 = Roby::Task.new
-	plan.discover [t1, t2, t3]
+	plan.add [t1, t2, t3]
 
 	assert_finds_tasks([t1, t2]) { TaskMatcher.with_arguments(:id => 1) | TaskMatcher.with_arguments(:id => 2) }
     end
@@ -171,7 +189,7 @@ class TC_Query < Test::Unit::TestCase
 	t1 = Class.new(SimpleTask) { argument :id }.new(:id => 1)
 	t2 = Class.new(SimpleTask) { argument :id }.new(:id => 2)
 	t3 = Roby::Task.new
-	plan.discover [t1, t2, t3]
+	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) }
@@ -179,19 +197,19 @@ class TC_Query < Test::Unit::TestCase
     end
 
     def test_merged_generated_subgraphs
-	(d1, d2, d3, d4, d5, d6), t1 = prepare_plan :discover => 6, :tasks => 1
+	(d1, d2, d3, d4, d5, d6), t1 = prepare_plan :add => 6, :tasks => 1
 
 	trsc = Transaction.new(plan)
-	d1.realized_by d2
-	d2.realized_by d3
-	d4.realized_by d5
-	d5.realized_by d6
+	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].realized_by t1
-	t1.realized_by trsc[d4]
+	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)
@@ -213,44 +231,184 @@ class TC_Query < Test::Unit::TestCase
     end
 
     def test_roots
-	(t1, t2, t3), (tr1, tr2, tr3) = prepare_plan :discover => 3, :tasks => 3
+	(t1, t2, t3), (tr1, tr2, tr3) = prepare_plan :add => 3, :tasks => 3
 	trsc = Transaction.new(plan)
-	[tr1, tr2, tr3].each { |t| trsc.discover(t) }
+	[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.realized_by t2
+	t1.depends_on t2
 	assert_equal([t1, t3].to_value_set, plan.find_tasks.roots(TaskStructure::Hierarchy).to_value_set)
 
-	tr1.realized_by tr2
-	trsc[t3].realized_by tr3
+	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.realized_by t2
-	plan.discover(t1)
+	t1.depends_on t2
+	plan.add(t1)
 
 	trsc = Transaction.new(plan)
 	assert(trsc.find_tasks.which_fullfills(SimpleTask).to_a.empty?)
-	assert(!trsc[t1, false])
-	assert(!trsc[t2, false])
-	assert(!trsc[t3, false])
+	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[t2, false])
-	assert(!trsc[t3, false])
+	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.discover(t3)
+	trsc.add(t3)
 	result = trsc.find_tasks.which_fullfills(model, :id => 3).to_a
 	assert_equal([t3], result)
 

data/test/test_relations.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 'flexmock'
 
@@ -16,6 +16,7 @@ class TC_Relations < Test::Unit::TestCase
 
 	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) )
@@ -24,7 +25,63 @@ class TC_Relations < Test::Unit::TestCase
 	assert( n.respond_to?(:add_child) )
     end
 
-    def test_directed_relation
+    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
@@ -33,12 +90,7 @@ class TC_Relations < Test::Unit::TestCase
         r2 = space.relation :Child, :parent_name => :parent
 
 	n1, n2, n3, n4 = 4.enum_for(:times).map { klass.new }
-	n1.add_child_object(n2, r1)
-	assert_nothing_raised { n1.add_child_object(n2, r1, false) }
-	assert_raises(ArgumentError) { n1.add_child_object(n2, r1, true) }
-	n1.remove_child_object n2, r1
-	assert_nothing_raised { n1.add_child_object(n2, r1) }
-	assert_nothing_raised { n1.add_child_object(n2, r1, true) }
+	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)
 
@@ -176,5 +228,33 @@ class TC_Relations < Test::Unit::TestCase
 	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