roby 0.8.0 → 3.0.0

data/test/relations/test_planned_by.rb

@@ -1,56 +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_PlannedBy < Test::Unit::TestCase
-    include Roby::Test
-
-    PlannedBy = Roby::TaskStructure::PlannedBy
-    SimpleTask = Roby::Test::SimpleTask
-    def test_replace
-	task, p1, p2 = prepare_plan :add => 3
-	task.planned_by p1
-
-	assert_raises(ArgumentError) { task.planned_by p2 }
-	assert(task.child_object?(p1, PlannedBy))
-	assert(!task.child_object?(p2, PlannedBy))
-
-	assert_nothing_raised { task.planned_by p2, :replace => true }
-	assert(!task.child_object?(p1, PlannedBy))
-	assert(task.child_object?(p2, PlannedBy))
-    end
-
-    def test_check
-	task = Roby::Task.new
-	planner = Roby::Test::SimpleTask.new
-	task.planned_by planner
-	plan.add_permanent(task)
-
-	assert_equal([], plan.check_structure.to_a)
-	planner.start!
-	assert_equal([], plan.check_structure.to_a)
-	planner.success!
-	assert_equal([], plan.check_structure.to_a)
-
-	task.remove_planning_task planner
-	planner = Roby::Test::SimpleTask.new
-	task.planned_by planner
-
-	assert_equal([], plan.check_structure.to_a)
-	planner.start!
-	assert_equal([], plan.check_structure.to_a)
-	planner.failed!
-
-	errors = plan.check_structure.to_a
-        assert_equal 1, errors.size
-        error = errors.first.first.exception
-	assert_kind_of(Roby::PlanningFailedError, error)
-	assert_equal(planner, error.failed_task)
-	assert_equal(task, error.planned_task)
-	assert_equal(planner.terminal_event, error.failed_event)
-
-	# Clear the planned task to make test teardown happy
-	plan.remove_object(task)
-    end
-end
-

data/test/suite_core.rb

@@ -1,29 +0,0 @@
-$LOAD_PATH.unshift File.expand_path(File.join('..', 'lib'), File.dirname(__FILE__))
-require 'test_support'
-
-require 'test_bgl'
-require 'test_relations'
-require 'test_event'
-require 'test_task'
-require 'test_state'
-
-require 'test_execution_engine'
-require 'test_exceptions'
-
-require 'test_plan'
-require 'test_query'
-require 'test_transactions'
-require 'test_transactions_proxy'
-
-require 'tasks/test_thread_task'
-
-require 'test_testcase'
-
-require 'suite_planning'
-require 'suite_relations'
-
-require 'test_interface'
-require 'test_log'
-
-require 'test_gui'
-

data/test/suite_distributed.rb

@@ -1,10 +0,0 @@
-$LOAD_PATH.unshift File.expand_path(File.join('..', 'lib'), File.dirname(__FILE__))
-require 'distributed/test_communication'
-require 'distributed/test_connection'
-require 'distributed/test_execution'
-require 'distributed/test_mixed_plan'
-require 'distributed/test_plan_notifications'
-require 'distributed/test_protocol'
-require 'distributed/test_query'
-require 'distributed/test_remote_plan'
-require 'distributed/test_transaction'

data/test/suite_planning.rb

@@ -1,4 +0,0 @@
-$LOAD_PATH.unshift File.expand_path(File.join('..', 'lib'), File.dirname(__FILE__))
-require 'planning/test_model'
-require 'planning/test_task'
-require 'planning/test_loops'

data/test/suite_relations.rb

@@ -1,8 +0,0 @@
-$LOAD_PATH.unshift File.expand_path(File.join('..', 'lib'), File.dirname(__FILE__))
-require 'test_relations'
-require 'relations/test_dependency'
-require 'relations/test_executed_by'
-require 'relations/test_planned_by'
-require 'relations/test_conflicts'
-require 'relations/test_ensured'
-

data/test/tasks/test_external_process.rb

@@ -1,126 +0,0 @@
-$LOAD_PATH.unshift File.expand_path(File.join('..', '..', 'lib'), File.dirname(__FILE__))
-require 'roby/test/common'
-require 'roby/external_process_task'
-require 'roby/test/tasks/simple_task'
-require 'roby/test/tasks/empty_task'
-
-class TC_ThreadTask < Test::Unit::TestCase 
-    include Roby::Test
-
-    MOCKUP = File.expand_path(
-        File.join("..", "mockups", "external_process"),
-        File.dirname(__FILE__))
-
-    class MockupTask < Roby::ExternalProcessTask
-        event :stop do
-            FileUtils.touch "/tmp/external_process_mockup_stop"
-        end
-    end
-
-    def assert_polling_successful(timeout, sleep = 0.05)
-        now = Time.now
-        while (Time.now - now) < timeout
-            if yield
-                return
-            end
-        end
-        flunk "reached timeout"
-    end
-
-    def test_nominal
-        plan.add_permanent(task = ExternalProcessTask.new(:command_line => [MOCKUP, "--no-output"]))
-        engine.run
-        engine.once { task.start! }
-
-        assert_polling_successful(5) { task.success? }
-    end
-
-    def test_nominal_array_with_one_element
-        plan.add_permanent(task = ExternalProcessTask.new(:command_line => [MOCKUP]))
-        engine.run
-        engine.once { task.start! }
-
-        assert_polling_successful(5) { task.success? }
-    end
-
-    def test_nominal_no_array
-        plan.add_permanent(task = ExternalProcessTask.new(:command_line => MOCKUP))
-        engine.run
-        engine.once { task.start! }
-
-        assert_polling_successful(5) { task.success? }
-    end
-
-    def test_inexistent_program
-        plan.add_permanent(task = ExternalProcessTask.new(:command_line => ['does_not_exist', "--error"]))
-        engine.run
-        engine.once { task.start! }
-
-        assert_polling_successful(5) { task.failed? }
-        assert_equal 1, task.event(:failed).last.context.first.exitstatus
-    end
-
-    def test_failure
-        plan.add_permanent(task = ExternalProcessTask.new(:command_line => [MOCKUP, "--error"]))
-        engine.run
-        engine.once { task.start! }
-
-        assert_polling_successful(5) { task.failed? }
-        assert_equal 1, task.event(:failed).last.context.first.exitstatus
-    end
-
-    def test_signaling
-        plan.add_permanent(task = ExternalProcessTask.new(:command_line => [MOCKUP, "--block"]))
-        engine.run
-        engine.once { task.start! }
-        assert_polling_successful(5) { task.running? }
-
-        Process.kill 'KILL', task.pid
-        assert_polling_successful(5) { task.failed? }
-        assert task.event(:signaled).happened?
-
-        ev = task.event(:signaled).last
-        assert_equal 9, ev.context.first.termsig
-    end
-
-    def do_redirection(expected)
-        plan.add_permanent(task = ExternalProcessTask.new(:command_line => [MOCKUP]))
-        yield(task)
-        engine.run
-        engine.once { task.start! }
-
-        assert_polling_successful(5) { task.success? }
-
-        assert File.exists?("mockup-#{task.pid}.log")
-        File.read("mockup-#{task.pid}.log")
-
-    ensure
-        FileUtils.rm_f "mockup-#{task.pid}.log"
-    end
-
-    def test_stdout_redirection
-        do_redirection `#{MOCKUP}` do |task|
-            task.redirect_output :stdout => 'mockup-%p.log'
-        end
-    end
-
-    def test_stderr_redirection
-        do_redirection `#{MOCKUP}` do |task|
-            task.command_line << "--stderr"
-            task.redirect_output :stderr => 'mockup-%p.log'
-        end
-    end
-
-    def test_common_redirection
-        output = do_redirection(nil) do |task|
-            task.command_line << "--common"
-            task.redirect_output 'mockup-%p.log'
-        end
-
-
-        expected = `#{MOCKUP} --common 2>&1`
-        assert_equal expected, output
-    end
-end
-
-

data/test/tasks/test_thread_task.rb

@@ -1,70 +0,0 @@
-$LOAD_PATH.unshift File.expand_path(File.join('..', '..', 'lib'), File.dirname(__FILE__))
-require 'roby/test/common'
-require 'roby/thread_task'
-require 'roby/test/tasks/simple_task'
-require 'roby/test/tasks/empty_task'
-
-class TC_ThreadTask < Test::Unit::TestCase 
-    include Roby::Test
-
-    # Starts +task+ and waits for the thread to end
-    def wait_thread_end(task)
-        task.start!
-        while task.thread
-            process_events
-            sleep 0.1
-        end
-    end
-
-    def test_normal
-        model = Class.new(Roby::ThreadTask) do
-            implementation do
-                1
-            end
-        end
-
-        plan.add_mission(task = model.new)
-	wait_thread_end(task)
-
-        assert task.success?
-        assert_equal 1, task.result
-    end
-
-    def test_implementation_fails
-        Thread.abort_on_exception = false
-        Roby.app.abort_on_exception = false
-        model = Class.new(Roby::ThreadTask) do
-            implementation do
-                raise ArgumentError, "blaaaaaaaaah"
-            end
-        end
-
-        plan.add_permanent(task = model.new)
-	wait_thread_end(task)
-
-        assert task.failed?
-        assert_kind_of ArgumentError, task.event(:failed).last.context.first
-        assert_equal nil, task.result
-    end
-
-    def test_interruptible
-        Thread.abort_on_exception = false
-        model = Class.new(Roby::ThreadTask) do
-            interruptible
-            implementation do
-                loop do
-                    interruption_point
-                    sleep 0.1
-                end
-            end
-        end
-
-        plan.add(task = model.new)
-	wait_thread_end(task)
-
-        assert task.failed?
-        assert_kind_of Interrupt, task.event(:failed).last.context.first
-        assert_equal nil, task.result
-    end
-end
-

data/test/test_bgl.rb

@@ -1,528 +0,0 @@
-$LOAD_PATH.unshift File.expand_path(File.join('..', 'lib'), File.dirname(__FILE__))
-require 'roby/test/common'
-require 'enumerator'
-require 'flexmock'
-
-class TC_BGL < Test::Unit::TestCase
-    include Roby::Test
-    class Vertex
-	include BGL::Vertex
-    end
-    Graph = BGL::Graph
-
-    def test_vertex_graph_list
-	graph = Graph.new
-	v = Vertex.new
-	graph.insert v
-	assert_equal([graph], v.enum_for(:each_graph).to_a)
-
-	graph.remove v
-	assert_equal([], v.enum_for(:each_graph).to_a)
-    end
-
-    def setup_graph(vertex_count)
-	graph = Graph.new
-	vertices = (1..vertex_count).map do
-	    graph.insert(v = Vertex.new)
-	    v
-	end
-	[graph, vertices]
-    end
-
-    def test_graph_views
-	g = Graph.new
-	r = g.reverse
-	assert_kind_of(Graph::Reverse, r)
-	assert_equal(r.object_id, g.reverse.object_id)
-
-	u = g.undirected
-	assert_kind_of(Graph::Undirected, u)
-	assert_equal(u.object_id, g.undirected.object_id)
-    end
-
-    def test_vertex_objects
-	graph = Graph.new
-
-	v1 = Vertex.new
-	graph.insert v1
-	assert(graph.include?(v1))
-	assert_equal([v1], graph.enum_for(:each_vertex).to_a)
-
-	graph.remove v1
-	assert(!graph.include?(v1))
-	assert_equal([], graph.enum_for(:each_vertex).to_a)
-
-	g1, g2 = Graph.new, Graph.new
-	g1.insert(v1)
-	g2.insert(v1)
-	v1.clear_vertex
-	assert(!g1.include?(v1))
-	assert(!g2.include?(v1))
-    end
-
-    def test_replace
-	graph = Graph.new
-
-	v1, v2, v3 = (1..3).map { Vertex.new }
-	graph.link(v1, v2, 1)
-	graph.link(v2, v3, 2)
-
-	v4 = Vertex.new
-	graph.replace_vertex(v2, v4)
-	assert(! graph.linked?(v1, v2))
-	assert(! graph.linked?(v2, v3))
-	assert_equal(1, v1[v4, graph])
-	assert_equal(2, v4[v3, graph])
-    end
-
-    def test_clear
-	g1, g2 = Graph.new, Graph.new
-
-	vertices = (1..3).map do
-            g1.insert(v = Vertex.new)
-            g2.insert(v)
-
-            assert g1.include?(v)
-            assert g2.include?(v)
-            v
-        end
-
-        g1.clear
-        vertices.each do |v|
-            assert !g1.include?(v)
-            assert g2.include?(v)
-            assert_equal [g2], v.enum_for(:each_graph).to_a
-        end
-    end
-
-    def test_edge_objects
-	g1, g2 = Graph.new, Graph.new
-
-	v1, v2, v3 = Vertex.new, Vertex.new, Vertex.new
-	g1.link v1, v2, 1
-	assert(g1.include?(v1))
-	assert(g1.include?(v2))
-	assert(g1.linked?(v1, v2))
-	assert(!g1.linked?(v2, v1))
-
-	g2.link v3, v2, 2
-	assert_raises(ArgumentError) { g2.link v3, v2, 2 }
-	assert_equal(2, v3[v2, g2])
-	v3[v2, g2] = 3
-	assert_equal(3, v3[v2, g2])
-
-	g2.link v1, v2, 3
-	assert(g1.linked?(v1, v2))
-	assert_equal(3, v1[v2, g2])
-
-	assert_raises(ArgumentError) { v2[v1, g1] }
-	assert_raises(ArgumentError) { v3[v1, g1] }
-	assert_raises(ArgumentError) { v1[v3, g1] }
-
-	# Test enumerators
-	assert_equal([[v1, v2, 1]], g1.enum_for(:each_edge).to_a)
-	assert_equal([v2], v1.enum_for(:each_child_vertex).to_a)
-
-	assert_equal([v1, v3].to_set, v2.enum_for(:each_parent_vertex).to_set)
-	assert_equal([v1, v3].to_set, v2.enum_for(:each_parent_vertex, g2).to_set)
-	assert_equal([v1].to_set, v2.enum_for(:each_parent_vertex, g1).to_set)
-
-	assert_equal([v2], v3.enum_for(:each_child_vertex).to_a)
-	assert_equal([v2], v3.enum_for(:each_child_vertex, g2).to_a)
-	assert_equal([], v3.enum_for(:each_child_vertex, g1).to_a)
-
-	# Test predicates
-	#   .... on all graphs
-	assert(!v1.parent_vertex?(v2))
-	assert(v2.parent_vertex?(v1))
-	assert(!v2.child_vertex?(v1))
-	assert(v1.child_vertex?(v2))
-	assert(v1.related_vertex?(v2))
-	assert(v2.related_vertex?(v1))
-	assert(v3.child_vertex?(v2))
-	assert(v2.parent_vertex?(v3))
-
-	#   .... on a specific subgraph
-	assert(!v2.parent_vertex?(v3, g1))
-	assert(v2.parent_vertex?(v3, g2))
-    end
-
-    def test_end_predicates
-	g1, g2 = Graph.new, Graph.new
-
-	v1, v2, v3, v4 = Vertex.new, Vertex.new, Vertex.new, Vertex.new
-	g1.link v1, v2, nil
-	g2.link v2, v1, nil
-	assert( !v1.root? )
-	assert( !v1.leaf? )
-	assert( v1.root?(g1) )
-	assert( v2.leaf?(g1) )
-
-	g1.link(v3, v1, nil)
-	assert(v3.root?)
-	g2.link(v3, v2, nil)
-	assert(v3.root?)
-
-	g1.link(v1, v4, nil)
-	assert(v4.leaf?)
-	g2.link(v2, v4, nil)
-	assert(v4.leaf?)
-    end
-
-    def assert_components(expected, found)
-	# Equality of set-of-set does not work, don't know why
-	assert_equal(expected.map { |c| c.sort_by { |e| e.object_id } }.to_set, 
-		     found.map { |c| c.sort_by { |e| e.object_id } }.to_set)
-    end
-
-    def test_graph_components
-	graph = Graph.new
-
-	vertices = (1..5).map { Vertex.new }
-	v5 = vertices.pop
-	v1, v2, v3, v4 = *vertices
-	vertices.each { |v| graph.insert(v) }
-
-	graph.link v1, v2, nil
-	assert_components([[v1, v2], [v3], [v4]], graph.components)
-	assert_raises(ArgumentError) { graph.components(nil, false) }
-	assert_components([[v1, v2]], graph.components([v1].to_value_set))
-	assert_components([[v5]], graph.components([v5].to_value_set))
-	assert_components([], graph.components([v5].to_value_set, false))
-	assert_components([[v2, v1]], graph.generated_subgraphs([v1].to_value_set))
-	assert_components([[v2, v1]], graph.generated_subgraphs([v1].to_value_set, false))
-	assert_components([[v2]], graph.generated_subgraphs([v2].to_value_set))
-	assert_components([], graph.generated_subgraphs([v2].to_value_set, false))
-	assert_components([[v2], [v5]], graph.generated_subgraphs([v2, v5].to_value_set))
-
-	assert_components([], graph.generated_subgraphs([v2].to_value_set, false))
-	assert_components([], graph.generated_subgraphs([v2].to_value_set, false))
-	assert_components([], graph.generated_subgraphs([v2, v5].to_value_set, false))
-	assert_components([[v1, v2]], graph.reverse.generated_subgraphs([v2].to_value_set))
-	assert_components([[v4]], graph.components([v4].to_value_set))
-	assert_components([], graph.components([v4].to_value_set, false))
-
-	graph.link v4, v3, nil
-	assert_components([[v1, v2], [v4, v3]], graph.components)
-	assert_components([[v2], [v3]], graph.generated_subgraphs([v2, v3].to_value_set))
-	assert_components([], graph.generated_subgraphs([v3, v2].to_value_set, false))
-	assert_components([[v1, v2], [v4, v3]], graph.reverse.generated_subgraphs([v2, v3].to_value_set))
-	assert_components([[v1, v2], [v4, v3]], graph.reverse.generated_subgraphs([v2, v3].to_value_set, false))
-	assert_components([[v3, v4]], graph.generated_subgraphs([v4].to_value_set))
-	assert_components([[v3, v4]], graph.generated_subgraphs([v4].to_value_set, false))
-
-	graph.link v1, v3, nil
-	assert_components([[v1, v2, v3, v4]], graph.components)
-	assert_components([[v1, v2, v3, v4]], graph.components([v1].to_value_set))
-
-	g2 = Graph.new
-	graph.unlink v4, v3
-	g2.link v4, v3, nil
-	assert_components([[v4]], graph.components([v4].to_value_set))
-	# assert_components([], graph.components([v4], false))
-	assert_components([[v4, v3]], g2.components([v3].to_value_set))
-
-	v5 = Vertex.new
-	# Check that we get a singleton component even if v5 is not in the graph
-	assert_components([[v5]], graph.components([v5].to_value_set))
-	# assert_components([], graph.components([v5], false))
-    end
-
-    def test_vertex_component
-	graph = Graph.new
-
-	vertices = (1..4).map { Vertex.new }
-	v1, v2, v3, v4 = *vertices
-	vertices.each { |v| graph.insert(v) }
-
-	graph.link v1, v2, nil
-	graph.link v3, v2, nil
-	graph.link v3, v4, nil
-	graph.link v2, v4, nil
-	assert_components([[v1, v2, v3, v4]], graph.components([v1].to_value_set))
-	assert_components([[v1, v2, v3, v4]], graph.components([v2].to_value_set))
-
-	g2 = Graph.new
-	g2.link v4, v3, nil
-	assert_components([[v4, v3]], g2.components([v4].to_value_set))
-    end
-
-    def test_dup
-	graph = Graph.new
-
-	vertices = (1..4).map { Vertex.new }
-	v1, v2, v3, v4 = *vertices
-	vertices.each { |v| graph.insert(v) }
-
-	graph.link v1, v2, nil
-	graph.link v3, v2, nil
-	graph.link v3, v4, nil
-	graph.link v2, v4, nil
-
-	copy = graph.dup
-	assert_not_same(copy, graph)
-	assert(copy.same_graph?(graph))
-
-	vertices.each do |v|
-	    assert( [graph, copy].to_set, v.enum_for(:each_graph).to_set )
-	end
-    end
-
-    def assert_bfs_trace(expected, sets, trace)
-	trace = trace.to_a
-	current_index = 0
-	sets.each do |s|
-	    s = (s..s) if Fixnum === s
-	    range_size = s.to_a.size
-	    assert_equal(expected[s].to_set, trace[current_index, range_size].to_set)
-	    current_index += range_size
-	end
-    end
-
-    def test_each_bfs
-	graph = Graph.new
-
-	vertices = (1..4).map { Vertex.new }
-	v1, v2, v3, v4 = *vertices
-	vertices.each { |v| graph.insert(v) }
-
-	graph.link v1, v2, 1
-	graph.link v1, v3, 2
-	graph.link v2, v3, 3
-	graph.link v3, v4, 4
-	graph.link v4, v2, 5
-
-	#
-	# v1 ----->v3--->v4
-	#  |-->v2--^      |
-	#       ^---------|
-
-	trace = [
-	    [v1, v2, 1, Graph::TREE], 
-	    [v1, v3, 2, Graph::TREE], 
-	    [v2, v3, 3, Graph::NON_TREE], 
-	    [v3, v4, 4, Graph::TREE],
-	    [v4, v2, 5, Graph::NON_TREE]
-	]
-	assert_bfs_trace(trace, [0..1, 2..3, 4], graph.enum_for(:each_bfs, v1, Graph::ALL))
-	assert_bfs_trace(trace, [0..1, 3], graph.enum_for(:each_bfs, v1, Graph::TREE))
-	assert_bfs_trace(trace, [2, 4], graph.enum_for(:each_bfs, v1, Graph::NON_TREE))
-	assert_raises(ArgumentError) { graph.each_bfs(v1, Graph::FORWARD_OR_CROSS) {} }
-	assert_raises(ArgumentError) { graph.each_bfs(v1, Graph::BACK) {} }
-    end
-
-    def assert_dfs_trace(branches, graph, enum, root, filter, check_kind = true)
-	branches = branches.map do |b|
-	    b.find_all { |e| e[3] & filter != 0 }
-	end
-	trace = graph.enum_for(enum, root, filter).to_a
-	if !check_kind
-	    trace.map! { |edge| edge[0..-2] }
-	end
-
-	begin
-	    assert( branches.find { |b| b == trace } ) #, trace )
-	rescue 
-	    #pp trace
-	    raise
-	end
-    end
-
-    def setup_test_graph(reverse)
-	graph = Graph.new
-
-	vertices = (1..5).map { Vertex.new }
-	v1, v2, v3, v4, v5 = *vertices
-	vertices.each { |v| graph.insert(v) }
-
-	links = [[v1, v2, 1],
-	    [v2, v3, 2],
-	    [v3, v4, 3],
-	    [v4, v2, 4],
-	    [v1, v5, 5],
-	    [v5, v2, 6]]
-
-	links.each do |edge|
-	    if reverse
-		edge[0], edge[1] = edge[1], edge[0]
-	    end
-	    graph.link(*edge)
-	end
-
-	[graph, vertices]
-    end
-
-    def test_linked_p
-	graph, vertices = setup_test_graph(false)
-	v1, v2, v3, v4, v5 = *vertices
-	assert( graph.linked?(v1, v2) )
-	assert( graph.linked?(v2, v3) )
-	assert( graph.linked?(v3, v4) )
-	assert( graph.linked?(v4, v2) )
-	assert( graph.linked?(v1, v5) )
-	assert( graph.linked?(v5, v2) )
-	assert( !graph.linked?(v2, v1) )
-	assert( !graph.linked?(v3, v2) )
-	assert( !graph.linked?(v4, v3) )
-	assert( !graph.linked?(v2, v4) )
-	assert( !graph.linked?(v5, v1) )
-	assert( !graph.linked?(v2, v5) )
-    end
-
-    def check_dfs(graph, vertices)
-	v1, v2, v3, v4, v5 = *vertices
-
-	traces = []
-	traces << [
-	    [v1, v5, 5, Graph::TREE], 
-	    [v5, v2, 6, Graph::TREE],
-	    [v2, v3, 2, Graph::TREE], 
-	    [v3, v4, 3, Graph::TREE], 
-	    [v4, v2, 4, Graph::BACK],
-	    [v1, v2, 1, Graph::FORWARD_OR_CROSS]
-	]
-	traces << [
-	    [v1, v2, 1, Graph::TREE], 
-	    [v2, v3, 2, Graph::TREE], 
-	    [v3, v4, 3, Graph::TREE], 
-	    [v4, v2, 4, Graph::BACK],
-	    [v1, v5, 5, Graph::TREE], 
-	    [v5, v2, 6, Graph::FORWARD_OR_CROSS]
-	]
-	assert_dfs_trace(traces, graph, :each_dfs, v1, Graph::ALL)
-	assert_dfs_trace(traces, graph, :each_dfs, v1, Graph::TREE)
-	assert_dfs_trace(traces, graph, :each_dfs, v1, Graph::FORWARD_OR_CROSS)
-	assert_dfs_trace(traces, graph, :each_dfs, v1, Graph::BACK)
-    end
-
-    def test_each_dfs
-	# v1---->v2-->v3-->v4
-	# |       ^---------|
-	# |-->v5--^     
-	graph, vertices = setup_test_graph(false)
-	check_dfs(graph, vertices)
-    end
-    def test_reverse_each_dfs
-	# Build a graph so that doing #each_dfs on #reverse should yield the same result
-	# than in test_each_dfs
-	graph, vertices = setup_test_graph(true)
-	check_dfs(graph.reverse, vertices)
-    end
-
-    def test_dfs_prune
-	graph = Graph.new
-	vertices = (1..5).map { Vertex.new }
-	v1, v2, v3 = *vertices
-	vertices.each { |v| graph.insert(v) }
-
-	graph.link v1, v2, 1
-	graph.link v2, v3, 2
-	graph.link v1, v3, 1
-
-	FlexMock.use do |mock|
-	    mock.should_receive(:found).with(v1, v2).once
-	    mock.should_receive(:found).with(v1, v3).once
-	    graph.each_dfs(v1, Graph::ALL) do |s, t, _, _| 
-		mock.found(s, t) 
-		graph.prune
-	    end
-	end
-    end
-
-    #def test_undirected_dfs
-    #    # v1---->v2-->v3-->v4
-    #    # |       ^---------|
-    #    # |-->v5--^     
-    #    graph, vertices = setup_test_graph(false)
-    #    v1, v2, v3, v4, v5 = *vertices
-    #    
-    #    # Do instead
-    #    # v1---->v2
-    #    # |       ^
-    #    # |-->v5--^     
-    #    graph.unlink(v2, v3)
-    #    graph.unlink(v4, v2)
-
-    #    traces = []
-    #    traces << [ [v1, v2, 1], [v2, v5, 6], [v5, v1, 5] ]
-    #    traces << [ [v1, v5, 5], [v5, v2, 6], [v2, v1, 1] ]
-    #    assert_dfs_trace(traces, graph.undirected, :each_dfs, v2, Graph::ALL, false)
-    #end
-
-    def test_topological_sort
-	graph, (v1, v2, v3, v4) = setup_graph(4)
-	graph.link v1, v2, nil
-	graph.link v2, v3, nil
-	graph.link v1, v3, nil
-	graph.link v3, v4, nil
-
-	sort = graph.topological_sort
-	assert_equal([v1, v2, v3, v4], sort)
-
-	sort = [v3, v4, v2]
-	graph.topological_sort(sort)
-	assert_equal([v1, v2, v3, v4], sort)
-
-	graph.link(v4, v1, nil)
-	assert_raises(ArgumentError) { graph.topological_sort }
-    end
-
-    def test_neighborhood
-	# v1---->v2-->v3-->v4
-	# |       ^---------|
-	# |-->v5--^     
-	graph, vertices = setup_test_graph(false)
-	v1, v2, v3, v4, v5 = *vertices
-
-	neigh1 = [[v1, v2, 1], [v1, v5, 5]]
-	assert_equal(neigh1.to_set, graph.neighborhood(v1, 1).to_set)
-	neigh2 = neigh1 + [[v4, v2, 4], [v2, v3, 2], [v5, v2, 6]]
-	assert_equal(neigh2.to_set, graph.neighborhood(v1, 2).to_set)
-	neigh3 = neigh2 + [[v3, v4, 3]]
-	assert_equal(neigh3.to_set, graph.neighborhood(v1, 3).to_set)
-    end
-
-    def test_vertex_singleton
-	v1, v2, v3 = (1..3).map { Vertex.new }
-	g1, g2 = Graph.new, Graph.new
-
-	assert(v1.singleton_vertex?)
-	assert(v2.singleton_vertex?)
-	assert(v3.singleton_vertex?)
-	g1.link(v1, v2, nil)
-	assert(!v1.singleton_vertex?)
-	assert(!v2.singleton_vertex?)
-	assert(v3.singleton_vertex?)
-	g2.link(v1, v3, nil)
-	assert(!v3.singleton_vertex?)
-
-	g1.unlink(v1, v2)
-	assert(!v1.singleton_vertex?)
-	assert(v2.singleton_vertex?)
-	g1.link(v1, v3, nil)
-	g2.unlink(v1, v3)
-	assert(!v1.singleton_vertex?)
-	assert(!v3.singleton_vertex?)
-	g1.unlink(v1, v3)
-	assert(v1.singleton_vertex?)
-	assert(v3.singleton_vertex?)
-    end
-
-    def test_graph_reachable
-	v1, v2, v3 = (1..3).map { Vertex.new }
-	g = Graph.new
-	assert(!g.reachable?(v1, v3))
-	g.link v1, v2, nil
-	assert(!g.reachable?(v1, v3))
-	g.link v2, v3, nil
-	assert(g.reachable?(v1, v2))
-	assert(g.reachable?(v1, v3))
-	assert(!g.reachable?(v3, v1))
-	assert(!g.reachable?(v2, v1))
-
-	g.link(v3, v1, nil)
-	assert(g.reachable?(v2, v1))
-	assert(g.reachable?(v3, v1))
-    end
-end
-