rgl 0.2.3 → 0.3.0

data/rakelib/dep_graph.rake

@@ -0,0 +1,30 @@
+# -*- ruby -*-
+
+begin
+  require 'rgl/dot'
+  require 'rgl/implicit'
+rescue Exception
+  nil
+end
+
+# Example usage:
+#
+#  rake -R/home/hd/src/rgl/rakelib -f /usr/lib/ruby/gems/1.8/gems/rails-1.0.0/Rakefile dep_graph
+desc "Generate dependency graph of rake tasks"
+task :dep_graph do |task|
+  this_task = task.name
+  dep = RGL::ImplicitGraph.new { |g|
+    # vertices of the graph are all defined tasks without this task
+	g.vertex_iterator do |b|
+      Rake::Task.tasks.each do |t|
+        b.call(t) unless t.name == this_task
+      end
+    end
+    # neighbors of task t are its prerequisites
+    g.adjacent_iterator { |t, b| t.prerequisites.each(&b) }
+    g.directed = true
+  }
+
+  dep.write_to_graphic_file('png', this_task)
+  puts "Wrote dependency graph to #{this_task}.png."
+end

data/tests/TestComponents.rb

@@ -1,11 +1,9 @@
 require 'test/unit'
 
+require 'rgl/traversal'
 require 'rgl/connected_components'
 require 'rgl/adjacency'
-
-class Array
-  alias add push
-end
+require 'test_helper'
 
 include RGL
 

data/tests/TestCycles.rb

@@ -0,0 +1,61 @@
+$LOAD_PATH << "../lib"
+require 'test/unit'
+require 'rgl/adjacency'
+require 'test_helper'
+
+include RGL
+
+class TestCycles < Test::Unit::TestCase
+
+  def setup
+    @dg = DirectedAdjacencyGraph.new(Array)
+    edges = [[1,2],[2,2],[2,3],[3,4],[4,5],[5,1],[6,4],[6,6],[1,4],[7,7],[7,7]]
+    edges.each do |(src,target)| 
+      @dg.add_edge(src, target)
+    end
+
+    @ug = AdjacencyGraph.new(Array)
+    @ug.add_edges(*edges)
+  end
+
+  # Helper for testing for different permutations of a cycle
+  def contains_cycle?(cycles,cycle)
+    cycle.size.times do |i|
+      return true if cycles.include?(cycle)
+      cycle = cycle[1..-1] + [cycle[0]]
+    end
+  end
+
+  def test_cycles
+    d_cycles = @dg.cycles
+    assert_equal 6, d_cycles.size
+    assert d_cycles.include?([6])
+    assert d_cycles.include?([7])
+    assert d_cycles.include?([2])
+    assert contains_cycle?(d_cycles, [1,4,5])
+    assert contains_cycle?(d_cycles, [1,2,3,4,5])
+  
+    assert_equal 5, DirectedAdjacencyGraph.new(Set, @dg).cycles.size
+
+    u_cycles = AdjacencyGraph.new(Set, @dg).cycles.sort
+
+    assert u_cycles.include?([2])
+    assert u_cycles.include?([6])
+    assert u_cycles.include?([7])
+    assert contains_cycle?(u_cycles, [1,2,3,4,5])
+    assert contains_cycle?(u_cycles, [1,5,4,3,2])
+    assert contains_cycle?(u_cycles, [1,4,3,2])
+    assert contains_cycle?(u_cycles, [1,4,5])
+    assert contains_cycle?(u_cycles, [1,5,4])
+    assert contains_cycle?(u_cycles, [1,5])
+    assert contains_cycle?(u_cycles, [1,2])
+    assert contains_cycle?(u_cycles, [1,2,3,4])
+    assert contains_cycle?(u_cycles, [2,3])
+    assert contains_cycle?(u_cycles, [1,4])
+    assert contains_cycle?(u_cycles, [3,4])
+    assert contains_cycle?(u_cycles, [4,5])
+    assert contains_cycle?(u_cycles, [4,6])
+    assert_equal 16, u_cycles.size
+  end
+
+end

data/tests/TestDirectedGraph.rb

@@ -11,56 +11,56 @@ class TestDirectedGraph < Test::Unit::TestCase
       @dg.add_edge(src, target)
     end
   end
-
+  
   def test_empty_graph
-	dg = DirectedAdjacencyGraph.new
-	assert dg.empty?
+    dg = DirectedAdjacencyGraph.new
+    assert dg.empty?
     assert dg.directed?
-	assert(!dg.has_edge?(2,1))
-	assert(!dg.has_vertex?(3))
-	# Non existend vertex result in a Name Error because each_key is
-	# called for nil
-	assert_raises(NoVertexError) {dg.out_degree(3)}
-	assert_equal([],dg.vertices)
-	assert_equal(0,dg.size)
-	assert_equal(0,dg.num_vertices)
-	assert_equal(0,dg.num_edges)
-	assert_equal(DirectedEdge,dg.edge_class)
-	assert([].eql?(dg.edges))
+    assert(!dg.has_edge?(2,1))
+    assert(!dg.has_vertex?(3))
+    # Non existend vertex result in a Name Error because each_key is
+    # called for nil
+    assert_raises(NoVertexError) {dg.out_degree(3)}
+    assert_equal([],dg.vertices)
+    assert_equal(0,dg.size)
+    assert_equal(0,dg.num_vertices)
+    assert_equal(0,dg.num_edges)
+    assert_equal(DirectedEdge,dg.edge_class)
+    assert([].eql?(dg.edges))
   end
-
+  
   def test_add
-	dg = DirectedAdjacencyGraph.new
-	dg.add_edge(1,2)
-	assert(!dg.empty?)
-	assert(dg.has_edge?(1,2))
-	assert(!dg.has_edge?(2,1))
-	assert(dg.has_vertex?(1) && dg.has_vertex?(2))
-	assert(!dg.has_vertex?(3))
-
-	assert_equal([1,2],dg.vertices.sort)
-	assert([DirectedEdge.new(1,2)].eql?(dg.edges))
-	assert_equal("(1-2)",dg.edges.to_s)
-
-	assert_equal([2],dg.adjacent_vertices(1))
-	assert_equal([],dg.adjacent_vertices(2))
-
-	assert_equal(1,dg.out_degree(1))
-	assert_equal(0,dg.out_degree(2))
+    dg = DirectedAdjacencyGraph.new
+    dg.add_edge(1,2)
+    assert(!dg.empty?)
+    assert(dg.has_edge?(1,2))
+    assert(!dg.has_edge?(2,1))
+    assert(dg.has_vertex?(1) && dg.has_vertex?(2))
+    assert(!dg.has_vertex?(3))
+    
+    assert_equal([1,2],dg.vertices.sort)
+    assert([DirectedEdge.new(1,2)].eql?(dg.edges))
+    assert_equal("(1-2)",dg.edges.to_s)
+    
+    assert_equal([2],dg.adjacent_vertices(1))
+    assert_equal([],dg.adjacent_vertices(2))
+    
+    assert_equal(1,dg.out_degree(1))
+    assert_equal(0,dg.out_degree(2))
   end
-
+  
   def test_edges
     assert_equal(4, @dg.edges.length)
     assert_equal([1,2,2,3], @dg.edges.map {|l| l.source}.sort)
     assert_equal([2,2,3,4], @dg.edges.map {|l| l.target}.sort)
     assert_equal("(1-2)(2-3)(2-4)(3-2)", @dg.edges.map {|l| l.to_s}.sort.join)
-#    assert_equal([0,1,2,3], @dg.edges.map {|l| l.info}.sort)
+    #    assert_equal([0,1,2,3], @dg.edges.map {|l| l.info}.sort)
   end
-
+  
   def test_vertices
     assert_equal([1,2,3,4], @dg.vertices.sort)
   end
-
+  
   def test_edges_from_to?
     assert @dg.has_edge?(1,2)
     assert @dg.has_edge?(2,3)
@@ -71,40 +71,40 @@ class TestDirectedGraph < Test::Unit::TestCase
     assert !@dg.has_edge?(4,1)
     assert !@dg.has_edge?(4,2)
   end
-
+  
   def test_remove_edges
-	@dg.remove_edge 1,2
-	assert !@dg.has_edge?(1,2)
-	@dg.remove_edge 1,2
-	assert !@dg.has_edge?(1,2)
-	@dg.remove_vertex 3
-	assert !@dg.has_vertex?(3)
-	assert !@dg.has_edge?(2,3)
-	assert_equal("(2-4)",@dg.to_s)
+    @dg.remove_edge 1,2
+    assert !@dg.has_edge?(1,2)
+    @dg.remove_edge 1,2
+    assert !@dg.has_edge?(1,2)
+    @dg.remove_vertex 3
+    assert !@dg.has_vertex?(3)
+    assert !@dg.has_edge?(2,3)
+    assert_equal("(2-4)",@dg.to_s)
   end
-
+  
   def test_add_vertices
-	dg = DirectedAdjacencyGraph.new
-	dg.add_vertices 1,3,2,4
-	assert_equal dg.vertices.sort, [1,2,3,4]
-
-	dg.remove_vertices 1,3
-	assert_equal dg.vertices.sort, [2,4]
+    dg = DirectedAdjacencyGraph.new
+    dg.add_vertices 1,3,2,4
+    assert_equal dg.vertices.sort, [1,2,3,4]
+    
+    dg.remove_vertices 1,3
+    assert_equal dg.vertices.sort, [2,4]
   end
-
+  
   def test_creating_from_array
-	dg = DirectedAdjacencyGraph[1, 2, 3, 4]
-	assert_equal(dg.vertices.sort, [1,2,3,4])
-	assert_equal(dg.edges.to_s, "(1-2)(3-4)")
+    dg = DirectedAdjacencyGraph[1, 2, 3, 4]
+    assert_equal(dg.vertices.sort, [1,2,3,4])
+    assert_equal(dg.edges.to_s, "(1-2)(3-4)")
   end
-
+  
   def test_reverse
     reverted = @dg.reverse
     @dg.each_edge do |u,v|
       assert(reverted.has_edge?(v,u))
     end
   end
-
+  
   def test_reverse
     # Add isolated vertex
     @dg.add_vertex(42)
@@ -113,8 +113,13 @@ class TestDirectedGraph < Test::Unit::TestCase
     @dg.each_edge do |u,v|
       assert(reverted.has_edge?(v,u))
     end
-
+    
     assert(reverted.has_vertex?(42),
            "Reverted graph should contain isolated Vertex 42")
   end
+  
+  def test_to_undirected
+    undirected = @dg.to_undirected
+    assert_equal undirected.edges.sort.to_s, "(1=2)(2=3)(2=4)"
+  end
 end

data/tests/TestDot.rb

@@ -0,0 +1,18 @@
+require 'test/unit'
+require 'rgl/dot'
+
+class TestDot < Test::Unit::TestCase
+
+  def test_to_dot_graph
+    graph = RGL::DirectedAdjacencyGraph[1,2]
+    dot = graph.to_dot_graph.to_s
+    assert_match(dot, /\{[^}]*\}/) # {...}
+    assert_match(dot, /1\s*\[/) # node 1
+    assert_match(dot, /2\s*\[/) # node 2
+    assert_match(dot, /1\s*->\s*2/) # edge
+  end
+
+  def assert_match(dot, pattern)
+    assert(!(dot =~ pattern).nil?, "#{dot} doesn't match #{pattern}")
+  end
+end

data/tests/TestEdge.rb

@@ -4,30 +4,31 @@ require 'rgl/base'
 include RGL::Edge
 
 class TestEdge < Test::Unit::TestCase
-
+  
   def test_directed_edge
-	assert_raises(ArgumentError) {DirectedEdge.new}
-	e = DirectedEdge.new 1,2
-	assert_equal(1,e.source)
-	assert_equal(2,e.target)
-	assert_equal([1,2],e.to_a)
-	assert_equal("(1-2)",e.to_s)
-	assert_equal([1,2],[e[0],e[1]])
-	assert(DirectedEdge.new(1,2).eql?(DirectedEdge.new(1,2)))
-	assert(!DirectedEdge.new(1,2).eql?(DirectedEdge.new(1,3)))
-	assert(!DirectedEdge.new(2,1).eql?(DirectedEdge.new(1,2)))
+    assert_raises(ArgumentError) {DirectedEdge.new}
+    e = DirectedEdge.new 1,2
+    assert_equal(1,e.source)
+    assert_equal(2,e.target)
+    assert_equal([1,2],e.to_a)
+    assert_equal("(1-2)",e.to_s)
+    assert_equal("(2-1)",e.reverse.to_s)
+    assert_equal([1,2],[e[0],e[1]])
+    assert(DirectedEdge[1,2].eql?(DirectedEdge.new(1,2)))
+    assert(!DirectedEdge[1,2].eql?(DirectedEdge.new(1,3)))
+    assert(!DirectedEdge[2,1].eql?(DirectedEdge.new(1,2)))
   end
-
+  
   def test_undirected_edge
-	assert_raises(ArgumentError) {UnDirectedEdge.new}
-	e = UnDirectedEdge.new 1,2
-	assert_equal(1,e.source)
-	assert_equal(2,e.target)
-	assert_equal([1,2],e.to_a)
-	assert_equal("(1=2)",e.to_s)
-	assert(UnDirectedEdge.new(1,2).eql?(UnDirectedEdge.new(2,1)))
-	assert(!UnDirectedEdge.new(1,3).eql?(UnDirectedEdge.new(2,1)))
-	assert_equal(UnDirectedEdge.new(1,2).hash,UnDirectedEdge.new(1,2).hash)
+    assert_raises(ArgumentError) {UnDirectedEdge.new}
+    e = UnDirectedEdge.new 1,2
+    assert_equal(1,e.source)
+    assert_equal(2,e.target)
+    assert_equal([1,2],e.to_a)
+    assert_equal("(1=2)",e.to_s)
+    assert(UnDirectedEdge.new(1,2).eql?(UnDirectedEdge.new(2,1)))
+    assert(!UnDirectedEdge.new(1,3).eql?(UnDirectedEdge.new(2,1)))
+    assert_equal(UnDirectedEdge.new(1,2).hash,UnDirectedEdge.new(1,2).hash)
   end
-
+  
 end

data/tests/TestGraph.rb

@@ -0,0 +1,55 @@
+require 'test/unit'
+require 'rgl/adjacency'
+require 'test_helper'
+
+include RGL
+
+class TestGraph < Test::Unit::TestCase
+
+  class NotImplementedGraph
+    include Graph
+  end
+
+  def setup
+    @dg = DirectedAdjacencyGraph.new
+    @edges = [[1,2],[2,3],[2,4],[4,5],[1,6],[6,4]]
+    @edges.each do |(src,target)| 
+      @dg.add_edge(src, target)
+    end
+
+    @ug = AdjacencyGraph.new(Array)
+    @ug.add_edges(*@edges)
+  end
+
+  def test_equality
+    assert @dg == @dg
+    assert @dg == @dg.dup
+    assert @ug == @ug.dup
+    assert @ug != @dg
+    assert @dg != @ug
+    assert @dg != 42
+    dup = DirectedAdjacencyGraph[*@edges.flatten]
+    assert @dg == dup
+    @dg.add_vertex 42
+    assert @dg != dup
+  end
+
+  def test_merge
+    merge = DirectedAdjacencyGraph.new(Array, @dg, @ug)
+    assert merge.num_edges == 12
+    merge = DirectedAdjacencyGraph.new(Set, @dg, @dg)
+    assert merge.num_edges == 6
+  end
+
+  def test_set_edgelist_class
+    edges = @dg.edges
+    @dg.edgelist_class=Array
+    assert_equal edges, @dg.edges
+  end
+
+  def test_not_implemented
+    graph = NotImplementedGraph.new
+    assert_raise(NotImplementedError) { graph.each_vertex }
+    assert_raise(NotImplementedError) { graph.each_adjacent(nil) }
+  end
+end

data/tests/TestGraphXML.rb

@@ -19,7 +19,7 @@ class TestGraphXML < Test::Unit::TestCase
   end
 
   def test_graphxml
-	@dg = DirectedAdjacencyGraph.from_graphxml(@stream).to_s
+	@dg = DirectedAdjacencyGraph.new.from_graphxml(@stream).to_s
 	assert_equal("(n0-n1)(n0-n2)(n0-n9)(n3-n4)(n4-n5)(n5-n7)(n8-n0)(n8-n3)(n8-n4)(n8-n5)(n8-n6)",@dg.to_s)
   end
 
@@ -35,7 +35,7 @@ class TestGraphXML < Test::Unit::TestCase
 		File.open(NORTH_DIR + name + '.graphml') {
 		  |file|
 		  print '.'; $stdout.flush
-		  graph = (directed == 'true' ? DirectedAdjacencyGraph : AdjacencyGraph).from_graphxml(file)
+		  graph = (directed == 'true' ? DirectedAdjacencyGraph : AdjacencyGraph).new.from_graphxml(file)
 		  #graph.write_to_graphic_file
 		  assert_equal(nnodes,graph.num_vertices)
 		  assert_equal(nedges,graph.num_edges)

data/tests/TestRdot.rb

@@ -0,0 +1,815 @@
+require 'test/unit'
+require 'rgl/rdot'
+
+include DOT
+
+# Add some helper methods to TestCase
+class Test::Unit::TestCase
+
+  # assert string matches regular expression
+  def assert_match(dot, pattern)
+    assert(!(dot =~ pattern).nil?, "#{dot} doesn't match #{pattern}")
+  end
+
+  # assert string doesn't match regular expression
+  def assert_no_match(dot, pattern)
+    assert((dot =~ pattern).nil?, "#{dot} shouldn't match #{pattern}")
+  end
+
+end
+
+# Tests for DOTPort
+class TestDotPort < Test::Unit::TestCase
+  def test_name
+    port = DOTPort.new()
+    assert_equal('', port.to_s)
+
+    port = DOTPort.new('test_name')
+    assert_equal('<test_name>', port.to_s)
+  end
+
+  def test_label
+    port = DOTPort.new(nil, 'test_label')
+    assert_equal('test_label', port.to_s)
+  end
+
+  def test_name_and_label
+    port = DOTPort.new('test_name', 'test_label')
+    assert_equal('<test_name> test_label', port.to_s)
+  end
+
+  def test_nested_ports
+    port = DOTPort.new([DOTPort.new(nil, 'a'), DOTPort.new(nil, 'b')])
+    assert_equal('{a | b}', port.to_s)
+  end
+
+  def test_name_label_and_nested_ports
+    port = DOTPort.new('test_name', 'test_label')
+    port.ports = [DOTPort.new(nil, 'a'), DOTPort.new(nil, 'b')]
+    assert_equal('{a | b}', port.to_s)
+  end
+end
+
+# Tests for DOTNode
+class TestDotNode < Test::Unit::TestCase
+
+  def test_no_name
+    node = DOTNode.new()
+    dot = node.to_s
+    assert_nil(dot)
+  end
+
+  # bug 16125
+  def test_1prop_0comma
+    node = DOTNode.new({"label"=>"the_label"})
+    dot = node.to_s
+    assert_no_match(dot, /,/)
+  end
+
+  def test_2prop_1comma
+    node = DOTNode.new({"label"=>"the_label", "shape"=>"ellipse"})
+    dot = node.to_s
+    assert_match(dot, /\[[^,]*,[^,]*\]/)
+  end
+
+  def test_name_without_label
+    node = DOTNode.new({"name"=>"test_name"})
+    dot = node.to_s
+    assert_no_match(dot, /label/)
+  end
+
+  def test_no_label
+    node = DOTNode.new({"shape"=>"ellipse"})
+    dot = node.to_s
+    assert_no_match(dot, /label/)
+  end
+
+  def test_Mrecord_no_label_no_ports
+    node = DOTNode.new({"name" => "test_name", "shape"=>"Mrecord"})
+    dot = node.to_s
+    assert_match(dot, /shape\s*=\s*Mrecord/)
+    assert_no_match(dot, /label/)
+  end
+
+  def test_Mrecord_label_no_ports
+    node = DOTNode.new({"name" => "test_name", "label" => "test_label", "shape"=>"Mrecord"})
+    dot = node.to_s
+    assert_match(dot, /shape\s*=\s*Mrecord/)
+    assert_match(dot, /label\s*=\s*test_label/)
+  end
+
+  def test_Mrecord_label_with_ports
+    node = DOTNode.new({"name" => "test_name", "label" => "test_label", "shape"=>"Mrecord"})
+    node.ports << DOTPort.new(nil, "a")
+    node.ports << DOTPort.new(nil, "b")
+    dot = node.to_s
+    assert_match(dot, /shape\s*=\s*Mrecord/)
+    assert_match(dot, /label\s*=\s*"a\s*|\s*b"/)
+  end
+
+  def test_Mrecord_no_label_with_ports
+    node = DOTNode.new({"name" => "test_name", "shape"=>"Mrecord"})
+    node.ports << DOTPort.new(nil, "a")
+    node.ports << DOTPort.new(nil, "b")
+    dot = node.to_s
+    assert_match(dot, /shape\s*=\s*Mrecord/)
+    assert_match(dot, /label\s*=\s*"a\s*|\s*b"/)
+  end
+
+  def test_record_no_label_no_ports
+    node = DOTNode.new({"name" => "test_name", "shape"=>"record"})
+    dot = node.to_s
+    assert_match(dot, /shape\s*=\s*record/)
+    assert_no_match(dot, /label/)
+  end
+
+  def test_record_label_no_ports
+    node = DOTNode.new({"name" => "test_name", "label" => "test_label", "shape"=>"record"})
+    dot = node.to_s
+    assert_match(dot, /shape\s*=\s*record/)
+    assert_match(dot, /label\s*=\s*test_label/)
+  end
+
+  def test_record_label_with_ports
+    node = DOTNode.new({"name" => "test_name", "label" => "test_label", "shape"=>"record"})
+    node.ports << DOTPort.new(nil, "a")
+    node.ports << DOTPort.new(nil, "b")
+    dot = node.to_s
+    assert_match(dot, /shape\s*=\s*record/)
+    assert_match(dot, /label\s*=\s*"a\s*|\s*b"/)
+  end
+
+  def test_record_no_label_with_ports
+    node = DOTNode.new({"name" => "test_name", "shape"=>"record"})
+    node.ports << DOTPort.new(nil, "a")
+    node.ports << DOTPort.new(nil, "b")
+    dot = node.to_s
+    assert_match(dot, /shape\s*=\s*record/)
+    assert_match(dot, /label\s*=\s*"a\s*|\s*b"/)
+  end
+
+  def test_no_shape_no_label_no_ports
+    node = DOTNode.new({"name" => "test_name"})
+    node.ports << DOTPort.new(nil, "a")
+    node.ports << DOTPort.new(nil, "b")
+    dot = node.to_s
+    assert_no_match(dot, /shape\s*=\s/)
+    assert_no_match(dot, /label\s*=\s*/)
+  end
+
+  def test_no_shape_no_label_with_ports
+    node = DOTNode.new({"name" => "test_name"})
+    node.ports << DOTPort.new(nil, "a")
+    node.ports << DOTPort.new(nil, "b")
+    dot = node.to_s
+    assert_no_match(dot, /shape\s*=\s*record/)
+    assert_no_match(dot, /label\s*=\s*/)
+  end
+
+  def test_name_quoting
+    node = DOTNode.new({"name" => "Name with spaces"})
+    dot = node.to_s
+    assert_match(dot, /^"Name with spaces"$/)
+
+    node = DOTNode.new({"name" => "Name with \"quotes\""})
+    dot = node.to_s
+    assert_match(dot, /^"Name with \\"quotes\\""$/)
+
+    node = DOTNode.new({"name" => "Name with \\backslashes\\"})
+    dot = node.to_s
+    assert_match(dot, /^"Name with \\\\backslashes\\\\"$/)
+
+    node = DOTNode.new({"name" => "123.456"})
+    dot = node.to_s
+    assert_match(dot, /^123.456$/)
+
+    node = DOTNode.new({"name" => ".456"})
+    dot = node.to_s
+    assert_match(dot, /^.456$/)
+
+    node = DOTNode.new({"name" => "-.456"})
+    dot = node.to_s
+    assert_match(dot, /^-.456$/)
+
+    node = DOTNode.new({"name" => "-456"})
+    dot = node.to_s
+    assert_match(dot, /^-456$/)
+
+    node = DOTNode.new({"name" => "-123.456"})
+    dot = node.to_s
+    assert_match(dot, /^-123.456$/)
+
+    node = DOTNode.new({"name" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
+    dot = node.to_s
+    assert_match(dot, /^<html><head><title>test<\/title><\/head>\n<body>text<\/body><\/html>$/)
+  end
+
+  def test_label_quoting
+    node = DOTNode.new({"name" => "test_name", "label" => "Label with spaces"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with spaces"/)
+
+    node = DOTNode.new({"name" => "test_name", "label" => "Label with \"quotes\""})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with \\"quotes\\""/)
+
+    node = DOTNode.new({"name" => "test_name", "label" => "Label with \\backslashes\\"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with \\\\backslashes\\\\"/)
+
+    node = DOTNode.new({"name" => "test_name", "label" => "Label with\nembedded newline"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with\\nembedded newline"/)
+
+    node = DOTNode.new({"name" => "test_name", "label" => "Left justified label\\l"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Left justified label\\l"/)
+
+    node = DOTNode.new({"name" => "test_name", "label" => "Right justified label\\r"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Right justified label\\r"/)
+
+    node = DOTNode.new({"name" => "test_name", "label" => "123.456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*123.456/)
+
+    node = DOTNode.new({"name" => "test_name", "label" => ".456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*.456/)
+
+    node = DOTNode.new({"name" => "test_name", "label" => "-.456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*-.456/)
+
+    node = DOTNode.new({"name" => "test_name", "label" => "-456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*-456/)
+
+    node = DOTNode.new({"name" => "test_name", "label" => "-123.456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*-123.456/)
+
+    node = DOTNode.new({"name" => "test_name", "label" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*<html><head><title>test<\/title><\/head>\n<body>text<\/body><\/html>/)
+  end
+
+  def test_option_quoting
+    node = DOTNode.new({"name" => "test_name", "comment" => "Comment with spaces"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*"Comment with spaces"/)
+
+    node = DOTNode.new({"name" => "test_name", "comment" => "Comment with \"quotes\""})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*"Comment with \\"quotes\\""/)
+
+    node = DOTNode.new({"name" => "test_name", "comment" => "Comment with \\backslashes\\"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*"Comment with \\\\backslashes\\\\"/)
+
+    node = DOTNode.new({"name" => "test_name", "comment" => "123.456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*123.456/)
+
+    node = DOTNode.new({"name" => "test_name", "comment" => ".456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*.456/)
+
+    node = DOTNode.new({"name" => "test_name", "comment" => "-.456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*-.456/)
+
+    node = DOTNode.new({"name" => "test_name", "comment" => "-456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*-456/)
+
+    node = DOTNode.new({"name" => "test_name", "comment" => "-123.456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*-123.456/)
+
+    node = DOTNode.new({"name" => "test_name", "comment" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*<html><head><title>test<\/title><\/head>\n<body>text<\/body><\/html>/)
+  end
+end
+
+# Tests for DOTEdge
+class TestDotEdge < Test::Unit::TestCase
+
+  def test_0prop
+    edge = DOTEdge.new({'from' => 'a', 'to' => 'b'})
+    dot = edge.to_s
+    assert_equal('a -- b', dot)
+  end
+
+  def test_1prop_0comma
+    edge = DOTEdge.new({"label"=>"the_label"})
+    dot = edge.to_s
+    assert_no_match(dot, /,/)
+  end
+
+  def test_2prop_1comma
+    edge = DOTEdge.new({"label"=>"the_label", "weight"=>"2"})
+    dot = edge.to_s
+    assert_match(dot, /\[[^,]*,[^,]*\]/)
+  end
+
+  def test_no_label
+    edge = DOTEdge.new({"weight"=>"2"})
+    dot = edge.to_s
+    assert_no_match(dot, /label/)
+  end
+end
+
+# Tests for DOTDirectedEdge
+class TestDotDirectedEdge < Test::Unit::TestCase
+
+  def test_0prop
+    edge = DOTDirectedEdge.new({'from' => 'a', 'to' => 'b'})
+    dot = edge.to_s
+    assert_equal('a -> b', dot)
+  end
+
+  def test_1prop_0comma
+    edge = DOTDirectedEdge.new({"label"=>"the_label"})
+    dot = edge.to_s
+    assert_no_match(dot, /,/)
+  end
+
+  def test_2prop_1comma
+    edge = DOTDirectedEdge.new({"label"=>"the_label", "weight"=>"2"})
+    dot = edge.to_s
+    assert_match(dot, /\[[^,]*,[^,]*\]/)
+  end
+
+  def test_no_label
+    edge = DOTDirectedEdge.new({"weight"=>"2"})
+    dot = edge.to_s
+    assert_no_match(dot, /label/)
+  end
+end
+
+# Tests for DOTGraph
+class TestDotGraph < Test::Unit::TestCase
+  def test_graph_statement
+    graph = DOTGraph.new()
+    dot = graph.to_s
+    assert_match(dot, /^\s*graph /)
+  end
+
+  def test_name_quoting
+    node = DOTGraph.new({"name" => "Name with spaces"})
+    dot = node.to_s
+    assert_match(dot, /^graph "Name with spaces" \{$/)
+
+    node = DOTGraph.new({"name" => "Name with \"quotes\""})
+    dot = node.to_s
+    assert_match(dot, /^graph "Name with \\"quotes\\"" \{$/)
+
+    node = DOTGraph.new({"name" => "Name with \\backslashes\\"})
+    dot = node.to_s
+    assert_match(dot, /^graph "Name with \\\\backslashes\\\\" \{$/)
+
+    node = DOTGraph.new({"name" => "123.456"})
+    dot = node.to_s
+    assert_match(dot, /^graph 123.456 \{$/)
+
+    node = DOTGraph.new({"name" => ".456"})
+    dot = node.to_s
+    assert_match(dot, /^graph .456 \{$/)
+
+    node = DOTGraph.new({"name" => "-.456"})
+    dot = node.to_s
+    assert_match(dot, /^graph -.456 \{$/)
+
+    node = DOTGraph.new({"name" => "-456"})
+    dot = node.to_s
+    assert_match(dot, /^graph -456 \{$/)
+
+    node = DOTGraph.new({"name" => "-123.456"})
+    dot = node.to_s
+    assert_match(dot, /^graph -123.456 \{$/)
+
+    node = DOTGraph.new({"name" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
+    dot = node.to_s
+    assert_match(dot, /^graph <html><head><title>test<\/title><\/head>\n<body>text<\/body><\/html> \{$/)
+  end
+
+  def test_label_quoting
+    node = DOTGraph.new({"name" => "test_name", "label" => "Label with spaces"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with spaces"/)
+
+    node = DOTGraph.new({"name" => "test_name", "label" => "Label with \"quotes\""})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with \\"quotes\\""/)
+
+    node = DOTGraph.new({"name" => "test_name", "label" => "Label with \\backslashes\\"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with \\\\backslashes\\\\"/)
+
+    node = DOTGraph.new({"name" => "test_name", "label" => "Label with\nembedded newline"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with\\nembedded newline"/)
+
+    node = DOTGraph.new({"name" => "test_name", "label" => "Left justified label\\l"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Left justified label\\l"/)
+
+    node = DOTGraph.new({"name" => "test_name", "label" => "Right justified label\\r"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Right justified label\\r"/)
+
+    node = DOTGraph.new({"name" => "test_name", "label" => "123.456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*123.456/)
+
+    node = DOTGraph.new({"name" => "test_name", "label" => ".456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*.456/)
+
+    node = DOTGraph.new({"name" => "test_name", "label" => "-.456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*-.456/)
+
+    node = DOTGraph.new({"name" => "test_name", "label" => "-456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*-456/)
+
+    node = DOTGraph.new({"name" => "test_name", "label" => "-123.456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*-123.456/)
+
+    node = DOTGraph.new({"name" => "test_name", "label" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*<html><head><title>test<\/title><\/head>\n<body>text<\/body><\/html>/)
+  end
+
+  def test_option_quoting
+    node = DOTGraph.new({"name" => "test_name", "comment" => "Comment with spaces"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*"Comment with spaces"/)
+
+    node = DOTGraph.new({"name" => "test_name", "comment" => "Comment with \"quotes\""})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*"Comment with \\"quotes\\""/)
+
+    node = DOTGraph.new({"name" => "test_name", "comment" => "Comment with \\backslashes\\"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*"Comment with \\\\backslashes\\\\"/)
+
+    node = DOTGraph.new({"name" => "test_name", "comment" => "123.456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*123.456/)
+
+    node = DOTGraph.new({"name" => "test_name", "comment" => ".456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*.456/)
+
+    node = DOTGraph.new({"name" => "test_name", "comment" => "-.456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*-.456/)
+
+    node = DOTGraph.new({"name" => "test_name", "comment" => "-456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*-456/)
+
+    node = DOTGraph.new({"name" => "test_name", "comment" => "-123.456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*-123.456/)
+
+    node = DOTGraph.new({"name" => "test_name", "comment" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*<html><head><title>test<\/title><\/head>\n<body>text<\/body><\/html>/)
+  end
+
+  def test_element_containment
+    node1 = DOTNode.new('name' => 'test_node1')
+    node2 = DOTNode.new('name' => 'test_node2')
+
+    graph = DOTGraph.new('name' => 'test_graph')
+    assert_nil(graph.pop)
+    assert_equal(graph, graph.push(node1))
+    assert_equal(graph, graph << node2)
+    graph.each_element do |element|
+      assert([node1, node2].include?(element))
+    end
+    assert_equal(node2, graph.pop)
+    assert_equal(node1, graph.pop)
+    assert_nil(graph.pop)
+
+    graph = DOTGraph.new('name' => 'test_graph', 'elements' => [node1])
+    assert_equal(node1, graph.pop)
+    assert_nil(graph.pop)
+  end
+end
+
+# Tests for DOTDigraph
+class TestDotDigraph < Test::Unit::TestCase
+  def test_digraph_statement
+    digraph = DOTDigraph.new()
+    dot = digraph.to_s
+    assert_match(dot, /^\s*digraph /)
+  end
+
+  def test_name_quoting
+    node = DOTDigraph.new({"name" => "Name with spaces"})
+    dot = node.to_s
+    assert_match(dot, /^digraph "Name with spaces" \{$/)
+
+    node = DOTDigraph.new({"name" => "Name with \"quotes\""})
+    dot = node.to_s
+    assert_match(dot, /^digraph "Name with \\"quotes\\"" \{$/)
+
+    node = DOTDigraph.new({"name" => "Name with \\backslashes\\"})
+    dot = node.to_s
+    assert_match(dot, /^digraph "Name with \\\\backslashes\\\\" \{$/)
+
+    node = DOTDigraph.new({"name" => "123.456"})
+    dot = node.to_s
+    assert_match(dot, /^digraph 123.456 \{$/)
+
+    node = DOTDigraph.new({"name" => ".456"})
+    dot = node.to_s
+    assert_match(dot, /^digraph .456 \{$/)
+
+    node = DOTDigraph.new({"name" => "-.456"})
+    dot = node.to_s
+    assert_match(dot, /^digraph -.456 \{$/)
+
+    node = DOTDigraph.new({"name" => "-456"})
+    dot = node.to_s
+    assert_match(dot, /^digraph -456 \{$/)
+
+    node = DOTDigraph.new({"name" => "-123.456"})
+    dot = node.to_s
+    assert_match(dot, /^digraph -123.456 \{$/)
+
+    node = DOTDigraph.new({"name" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
+    dot = node.to_s
+    assert_match(dot, /^digraph <html><head><title>test<\/title><\/head>\n<body>text<\/body><\/html> \{$/)
+  end
+
+  def test_label_quoting
+    node = DOTDigraph.new({"name" => "test_name", "label" => "Label with spaces"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with spaces"/)
+
+    node = DOTDigraph.new({"name" => "test_name", "label" => "Label with \"quotes\""})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with \\"quotes\\""/)
+
+    node = DOTDigraph.new({"name" => "test_name", "label" => "Label with \\backslashes\\"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with \\\\backslashes\\\\"/)
+
+    node = DOTDigraph.new({"name" => "test_name", "label" => "Label with\nembedded newline"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with\\nembedded newline"/)
+
+    node = DOTDigraph.new({"name" => "test_name", "label" => "Left justified label\\l"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Left justified label\\l"/)
+
+    node = DOTDigraph.new({"name" => "test_name", "label" => "Right justified label\\r"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Right justified label\\r"/)
+
+    node = DOTDigraph.new({"name" => "test_name", "label" => "123.456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*123.456/)
+
+    node = DOTDigraph.new({"name" => "test_name", "label" => ".456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*.456/)
+
+    node = DOTDigraph.new({"name" => "test_name", "label" => "-.456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*-.456/)
+
+    node = DOTDigraph.new({"name" => "test_name", "label" => "-456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*-456/)
+
+    node = DOTDigraph.new({"name" => "test_name", "label" => "-123.456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*-123.456/)
+
+    node = DOTDigraph.new({"name" => "test_name", "label" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*<html><head><title>test<\/title><\/head>\n<body>text<\/body><\/html>/)
+  end
+
+  def test_option_quoting
+    node = DOTDigraph.new({"name" => "test_name", "comment" => "Comment with spaces"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*"Comment with spaces"/)
+
+    node = DOTDigraph.new({"name" => "test_name", "comment" => "Comment with \"quotes\""})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*"Comment with \\"quotes\\""/)
+
+    node = DOTDigraph.new({"name" => "test_name", "comment" => "Comment with \\backslashes\\"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*"Comment with \\\\backslashes\\\\"/)
+
+    node = DOTDigraph.new({"name" => "test_name", "comment" => "123.456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*123.456/)
+
+    node = DOTDigraph.new({"name" => "test_name", "comment" => ".456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*.456/)
+
+    node = DOTDigraph.new({"name" => "test_name", "comment" => "-.456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*-.456/)
+
+    node = DOTDigraph.new({"name" => "test_name", "comment" => "-456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*-456/)
+
+    node = DOTDigraph.new({"name" => "test_name", "comment" => "-123.456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*-123.456/)
+
+    node = DOTDigraph.new({"name" => "test_name", "comment" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*<html><head><title>test<\/title><\/head>\n<body>text<\/body><\/html>/)
+  end
+
+  def test_element_containment
+    node1 = DOTNode.new('name' => 'test_node1')
+    node2 = DOTNode.new('name' => 'test_node2')
+
+    graph = DOTDigraph.new('name' => 'test_graph')
+    assert_nil(graph.pop)
+    assert_equal(graph, graph.push(node1))
+    assert_equal(graph, graph << node2)
+    graph.each_element do |element|
+      assert([node1, node2].include?(element))
+    end
+    assert_equal(node2, graph.pop)
+    assert_equal(node1, graph.pop)
+    assert_nil(graph.pop)
+
+    graph = DOTDigraph.new('name' => 'test_graph', 'elements' => [node1])
+    assert_equal(node1, graph.pop)
+    assert_nil(graph.pop)
+  end
+end
+
+# Tests for DOTSubgraph
+class TestDotSubgraph < Test::Unit::TestCase
+  def test_subgraph_statement
+    subgraph = DOTSubgraph.new()
+    dot = subgraph.to_s
+    assert_match(dot, /^\s*subgraph /)
+  end
+
+  def test_name_quoting
+    node = DOTSubgraph.new({"name" => "Name with spaces"})
+    dot = node.to_s
+    assert_match(dot, /^subgraph "Name with spaces" \{$/)
+
+    node = DOTSubgraph.new({"name" => "Name with \"quotes\""})
+    dot = node.to_s
+    assert_match(dot, /^subgraph "Name with \\"quotes\\"" \{$/)
+
+    node = DOTSubgraph.new({"name" => "Name with \\backslashes\\"})
+    dot = node.to_s
+    assert_match(dot, /^subgraph "Name with \\\\backslashes\\\\" \{$/)
+
+    node = DOTSubgraph.new({"name" => "123.456"})
+    dot = node.to_s
+    assert_match(dot, /^subgraph 123.456 \{$/)
+
+    node = DOTSubgraph.new({"name" => ".456"})
+    dot = node.to_s
+    assert_match(dot, /^subgraph .456 \{$/)
+
+    node = DOTSubgraph.new({"name" => "-.456"})
+    dot = node.to_s
+    assert_match(dot, /^subgraph -.456 \{$/)
+
+    node = DOTSubgraph.new({"name" => "-456"})
+    dot = node.to_s
+    assert_match(dot, /^subgraph -456 \{$/)
+
+    node = DOTSubgraph.new({"name" => "-123.456"})
+    dot = node.to_s
+    assert_match(dot, /^subgraph -123.456 \{$/)
+
+    node = DOTSubgraph.new({"name" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
+    dot = node.to_s
+    assert_match(dot, /^subgraph <html><head><title>test<\/title><\/head>\n<body>text<\/body><\/html> \{$/)
+  end
+
+  def test_label_quoting
+    node = DOTSubgraph.new({"name" => "test_name", "label" => "Label with spaces"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with spaces"/)
+
+    node = DOTSubgraph.new({"name" => "test_name", "label" => "Label with \"quotes\""})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with \\"quotes\\""/)
+
+    node = DOTSubgraph.new({"name" => "test_name", "label" => "Label with \\backslashes\\"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with \\\\backslashes\\\\"/)
+
+    node = DOTSubgraph.new({"name" => "test_name", "label" => "Label with\nembedded newline"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with\\nembedded newline"/)
+
+    node = DOTSubgraph.new({"name" => "test_name", "label" => "Left justified label\\l"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Left justified label\\l"/)
+
+    node = DOTSubgraph.new({"name" => "test_name", "label" => "Right justified label\\r"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Right justified label\\r"/)
+
+    node = DOTSubgraph.new({"name" => "test_name", "label" => "123.456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*123.456/)
+
+    node = DOTSubgraph.new({"name" => "test_name", "label" => ".456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*.456/)
+
+    node = DOTSubgraph.new({"name" => "test_name", "label" => "-.456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*-.456/)
+
+    node = DOTSubgraph.new({"name" => "test_name", "label" => "-456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*-456/)
+
+    node = DOTSubgraph.new({"name" => "test_name", "label" => "-123.456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*-123.456/)
+
+    node = DOTSubgraph.new({"name" => "test_name", "label" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*<html><head><title>test<\/title><\/head>\n<body>text<\/body><\/html>/)
+  end
+
+  def test_option_quoting
+    node = DOTSubgraph.new({"name" => "test_name", "comment" => "Comment with spaces"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*"Comment with spaces"/)
+
+    node = DOTSubgraph.new({"name" => "test_name", "comment" => "Comment with \"quotes\""})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*"Comment with \\"quotes\\""/)
+
+    node = DOTSubgraph.new({"name" => "test_name", "comment" => "Comment with \\backslashes\\"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*"Comment with \\\\backslashes\\\\"/)
+
+    node = DOTSubgraph.new({"name" => "test_name", "comment" => "123.456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*123.456/)
+
+    node = DOTSubgraph.new({"name" => "test_name", "comment" => ".456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*.456/)
+
+    node = DOTSubgraph.new({"name" => "test_name", "comment" => "-.456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*-.456/)
+
+    node = DOTSubgraph.new({"name" => "test_name", "comment" => "-456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*-456/)
+
+    node = DOTSubgraph.new({"name" => "test_name", "comment" => "-123.456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*-123.456/)
+
+    node = DOTSubgraph.new({"name" => "test_name", "comment" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*<html><head><title>test<\/title><\/head>\n<body>text<\/body><\/html>/)
+  end
+
+  def test_element_containment
+    node1 = DOTNode.new('name' => 'test_node1')
+    node2 = DOTNode.new('name' => 'test_node2')
+
+    graph = DOTSubgraph.new('name' => 'test_graph')
+    assert_nil(graph.pop)
+    assert_equal(graph, graph.push(node1))
+    assert_equal(graph, graph << node2)
+    graph.each_element do |element|
+      assert([node1, node2].include?(element))
+    end
+    assert_equal(node2, graph.pop)
+    assert_equal(node1, graph.pop)
+    assert_nil(graph.pop)
+
+    graph = DOTSubgraph.new('name' => 'test_graph', 'elements' => [node1])
+    assert_equal(node1, graph.pop)
+    assert_nil(graph.pop)
+  end
+end