laser 0.7.0.pre1

data/test/third_party_tests/rgl_tests/TestDot.rb

@@ -0,0 +1,18 @@
+require 'test/unit'
+require 'laser/third_party/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/test/third_party_tests/rgl_tests/TestEdge.rb

@@ -0,0 +1,34 @@
+require 'test/unit'
+require 'laser/third_party/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("(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)
+  end
+  
+end

data/test/third_party_tests/rgl_tests/TestGraph.rb

@@ -0,0 +1,71 @@
+require 'test/unit'
+require 'laser/third_party/rgl/adjacency'
+require_relative 'test_helper'
+
+include RGL
+
+class TestGraph < Test::Unit::TestCase
+
+  class NotImplementedGraph
+    include Graph
+  end
+
+  def setup
+    @dg1 = DirectedAdjacencyGraph.new
+    @edges = [[1,2],[2,3],[2,4],[4,5],[1,6],[6,4]]
+    @edges.each do |(src,target)|
+      @dg1.add_edge(src, target)
+    end
+    @loan_vertices = [7, 8, 9]
+    @loan_vertices.each do |vertex|
+      @dg1.add_vertex(vertex)
+    end
+
+    @dg2 = DirectedAdjacencyGraph[*@edges.flatten]
+    @loan_vertices.each do |vertex|
+      @dg2.add_vertex(vertex)
+    end
+
+    @ug = AdjacencyGraph.new(Array)
+    @ug.add_edges(*@edges)
+    @ug.add_vertices(*@loan_vertices)
+  end
+
+  def test_equality
+    assert_equal @dg1, @dg1
+    assert_equal @dg1, @dg1.dup
+    assert_equal @ug, @ug.dup
+    assert_not_equal @ug, @dg1
+    assert_not_equal @dg1, @ug
+    assert_not_equal @dg1, 42
+    assert_equal @dg1, @dg2
+    @dg1.add_vertex 42
+    assert_not_equal @dg1, @dg2
+  end
+
+  def test_to_adjacency
+    assert_equal @dg1, @dg1.to_adjacency
+    assert_equal @ug, @ug.to_adjacency
+  end
+
+  def test_merge
+    merge = DirectedAdjacencyGraph.new(Array, @dg1, @ug)
+    assert_equal merge.num_edges, 12
+    assert_equal merge.num_vertices, 9
+    merge = DirectedAdjacencyGraph.new(Set, @dg1, @dg1)
+    assert_equal merge.num_edges, 6
+    assert_equal merge.num_vertices, 9
+  end
+
+  def test_set_edgelist_class
+    edges = @dg1.edges
+    @dg1.edgelist_class=Array
+    assert_equal edges, @dg1.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/test/third_party_tests/rgl_tests/TestGraphXML.rb

@@ -0,0 +1,57 @@
+require 'test/unit'
+require 'laser/third_party/rgl/graphxml'
+require 'laser/third_party/rgl/adjacency'
+require 'laser/third_party/rgl/topsort'
+require 'laser/third_party/rgl/connected_components'
+require 'laser/third_party/rgl/dot'
+
+include RGL
+
+class TestGraphXML < Test::Unit::TestCase
+  NORTH_DIR = File.expand_path(File.join(File.dirname(__FILE__), 'examples', 'north')) + '/'
+
+  def setup
+    @stream = File.new(File.join(NORTH_DIR, 'g.10.0.graphml'))
+  end
+
+  def tear_down
+	@stream.close
+  end
+
+  def test_graphxml
+	@dg = DirectedAdjacencyGraph.new.from_graphxml(@stream).edges.sort.join
+	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)
+  end
+
+  def test_north_graphs
+	name,nnodes,nedges = '',0,0
+	IO.foreach(NORTH_DIR + '/Graph.log') {
+	  |line|
+	  if /name:\s*(.*)\sformat: graphml\s+nodes: (\d+)\s+edges: (\d+)/ =~ line
+		name,nnodes,nedges = $1,$2.to_i,$3.to_i
+	  end
+	  if name && /directed: (\w+).*acyclic: (\w+).*connected: (\w+).*biconnected: (\w+)\s+/ =~ line
+		directed, acyclic, connected, biconnected = $1,$2,$3,$4
+		File.open(NORTH_DIR + name + '.graphml') {
+		  |file|
+		  print '.'; $stdout.flush
+		  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)
+		  assert_equal(acyclic,graph.acyclic?.to_s)
+
+		  num_comp = 0
+		  graph.to_undirected.each_connected_component {|x| num_comp += 1}
+		  assert_equal(connected,(num_comp == 1).to_s)
+
+# 		  if graph.directed?
+# 			num_comp = graph.strongly_connected_components.num_comp
+# 			#puts num_comp
+# 			assert_equal(biconnected, (num_comp == 1).to_s)
+# 		  end
+		}
+	  end
+	}
+  end
+end

data/test/third_party_tests/rgl_tests/TestImplicit.rb

@@ -0,0 +1,52 @@
+require 'test/unit'
+require 'laser/third_party/rgl/implicit'
+require 'laser/third_party/rgl/adjacency'
+
+include RGL
+
+class TestImplicit < Test::Unit::TestCase
+  def setup
+    @dg = DirectedAdjacencyGraph.new
+    [[1,2],[2,3],[2,4],[4,5],[1,6],[6,4]].each do |(src,target)| 
+      @dg.add_edge(src, target)
+    end
+
+	@cycle = ImplicitGraph.new { |g|
+	  g.vertex_iterator { |b| 0.upto(4,&b) }
+	  g.adjacent_iterator { |x, b| b.call((x+1)%5) }
+	  g.directed = true
+	}
+  end
+
+  def test_empty
+	empty = ImplicitGraph.new
+	assert(empty.empty?)
+	assert_equal([],empty.edges)
+	assert_equal([],empty.vertices)
+  end
+
+  def test_cycle
+	assert(!@cycle.empty?)
+	assert_equal([0, 1, 2, 3, 4],@cycle.vertices.sort)
+	assert_equal("(0-1)(1-2)(2-3)(3-4)(4-0)",@cycle.edges.sort.join)
+  end
+  
+  def test_vertex_filtered_graph
+	fg = @cycle.vertices_filtered_by {|v| v%2 == 0}
+	assert_equal([0, 2, 4],fg.vertices.sort)
+	assert_equal("(4-0)",fg.edges.sort.join)
+	assert(fg.directed?)
+
+	fg = @dg.vertices_filtered_by {|v| v%2 == 0}
+	assert_equal([2, 4, 6],fg.vertices.sort)
+	assert_equal("(2-4)(6-4)",fg.edges.sort.join)
+	assert(fg.directed?)
+  end
+
+  def test_edge_filtered_graph
+	fg = @cycle.edges_filtered_by {|u,v| u+v > 3}
+	assert_equal(@cycle.vertices.sort,fg.vertices.sort)
+	assert_equal("(2-3)(3-4)(4-0)",fg.edges.sort.join)
+	assert(fg.directed?)
+  end
+end

data/test/third_party_tests/rgl_tests/TestRdot.rb

@@ -0,0 +1,863 @@
+require 'test/unit'
+require 'laser/third_party/rgl/rdot'
+
+include RGL
+
+# 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 DOT::Port
+class TestDotPort < Test::Unit::TestCase
+  def test_name
+    port = DOT::Port.new()
+    assert_equal('', port.to_s)
+
+    port = DOT::Port.new('test_name')
+    assert_equal('<test_name>', port.to_s)
+  end
+
+  def test_label
+    port = DOT::Port.new(nil, 'test_label')
+    assert_equal('test_label', port.to_s)
+  end
+
+  def test_name_and_label
+    port = DOT::Port.new('test_name', 'test_label')
+    assert_equal('<test_name> test_label', port.to_s)
+  end
+
+  def test_nested_ports
+    port = DOT::Port.new([DOT::Port.new(nil, 'a'), DOT::Port.new(nil, 'b')])
+    assert_equal('{a | b}', port.to_s)
+  end
+
+  def test_name_label_and_nested_ports
+    port = DOT::Port.new('test_name', 'test_label')
+    port.ports = [DOT::Port.new(nil, 'a'), DOT::Port.new(nil, 'b')]
+    assert_equal('{a | b}', port.to_s)
+  end
+end
+
+# Tests for DOT::Node
+class TestDotNode < Test::Unit::TestCase
+
+  def test_no_name
+    node = DOT::Node.new()
+    dot = node.to_s
+    assert_nil(dot)
+  end
+
+  # bug 16125
+  def test_1prop_0comma
+    node = DOT::Node.new({"label"=>"the_label"})
+    dot = node.to_s
+    assert_no_match(dot, /,/)
+  end
+
+  def test_2prop_1comma
+    node = DOT::Node.new({"label"=>"the_label", "shape"=>"ellipse"})
+    dot = node.to_s
+    assert_match(dot, /\[[^,]*,[^,]*\]/)
+  end
+
+  def test_name_without_label
+    node = DOT::Node.new({"name"=>"test_name"})
+    dot = node.to_s
+    assert_no_match(dot, /label/)
+  end
+
+  def test_no_label
+    node = DOT::Node.new({"shape"=>"ellipse"})
+    dot = node.to_s
+    assert_no_match(dot, /label/)
+  end
+
+  def test_Mrecord_no_label_no_ports
+    node = DOT::Node.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 = DOT::Node.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 = DOT::Node.new({"name" => "test_name", "label" => "test_label", "shape"=>"Mrecord"})
+    node.ports << DOT::Port.new(nil, "a")
+    node.ports << DOT::Port.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 = DOT::Node.new({"name" => "test_name", "shape"=>"Mrecord"})
+    node.ports << DOT::Port.new(nil, "a")
+    node.ports << DOT::Port.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 = DOT::Node.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 = DOT::Node.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 = DOT::Node.new({"name" => "test_name", "label" => "test_label", "shape"=>"record"})
+    node.ports << DOT::Port.new(nil, "a")
+    node.ports << DOT::Port.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 = DOT::Node.new({"name" => "test_name", "shape"=>"record"})
+    node.ports << DOT::Port.new(nil, "a")
+    node.ports << DOT::Port.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 = DOT::Node.new({"name" => "test_name"})
+    node.ports << DOT::Port.new(nil, "a")
+    node.ports << DOT::Port.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 = DOT::Node.new({"name" => "test_name"})
+    node.ports << DOT::Port.new(nil, "a")
+    node.ports << DOT::Port.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 = DOT::Node.new({"name" => "Name with spaces"})
+    dot = node.to_s
+    assert_match(dot, /^"Name with spaces"$/)
+
+    node = DOT::Node.new({"name" => "Name with \"quotes\""})
+    dot = node.to_s
+    assert_match(dot, /^"Name with \\"quotes\\""$/)
+
+    node = DOT::Node.new({"name" => "Name with \\backslashes\\"})
+    dot = node.to_s
+    assert_match(dot, /^"Name with \\\\backslashes\\\\"$/)
+
+    node = DOT::Node.new({"name" => "Name with\nembedded\nnewlines"})
+    dot = node.to_s
+    assert_match(dot, /\A.*"Name with\nembedded\nnewlines".*\Z/m)
+
+    node = DOT::Node.new({"name" => "Name_with_trailing_newline\n"})
+    dot = node.to_s
+    assert_match(dot, /\A.*"Name_with_trailing_newline\n".*\Z/m)
+
+    node = DOT::Node.new({"name" => "123.456"})
+    dot = node.to_s
+    assert_match(dot, /^123.456$/)
+
+    node = DOT::Node.new({"name" => ".456"})
+    dot = node.to_s
+    assert_match(dot, /^.456$/)
+
+    node = DOT::Node.new({"name" => "-.456"})
+    dot = node.to_s
+    assert_match(dot, /^-.456$/)
+
+    node = DOT::Node.new({"name" => "-456"})
+    dot = node.to_s
+    assert_match(dot, /^-456$/)
+
+    node = DOT::Node.new({"name" => "-123.456"})
+    dot = node.to_s
+    assert_match(dot, /^-123.456$/)
+
+    node = DOT::Node.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 = DOT::Node.new({"name" => "test_name", "label" => "Label with spaces"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with spaces"/)
+
+    node = DOT::Node.new({"name" => "test_name", "label" => "Label with \"quotes\""})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with \\"quotes\\""/)
+
+    node = DOT::Node.new({"name" => "test_name", "label" => "Label with \\backslashes\\"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with \\\\backslashes\\\\"/)
+
+    node = DOT::Node.new({"name" => "test_name", "label" => "Label with\nembedded\nnewlines"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with\\nembedded\\nnewlines"/)
+
+    node = DOT::Node.new({"name" => "test_name", "label" => "Label_with_a_trailing_newline\n"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label_with_a_trailing_newline\\n"/)
+
+    node = DOT::Node.new({"name" => "test_name", "label" => "Left justified label\\l"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Left justified label\\l"/)
+
+    node = DOT::Node.new({"name" => "test_name", "label" => "Right justified label\\r"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Right justified label\\r"/)
+
+    node = DOT::Node.new({"name" => "test_name", "label" => "123.456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*123.456/)
+
+    node = DOT::Node.new({"name" => "test_name", "label" => ".456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*.456/)
+
+    node = DOT::Node.new({"name" => "test_name", "label" => "-.456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*-.456/)
+
+    node = DOT::Node.new({"name" => "test_name", "label" => "-456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*-456/)
+
+    node = DOT::Node.new({"name" => "test_name", "label" => "-123.456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*-123.456/)
+
+    node = DOT::Node.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 = DOT::Node.new({"name" => "test_name", "comment" => "Comment with spaces"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*"Comment with spaces"/)
+
+    node = DOT::Node.new({"name" => "test_name", "comment" => "Comment with \"quotes\""})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*"Comment with \\"quotes\\""/)
+
+    node = DOT::Node.new({"name" => "test_name", "comment" => "Comment with \\backslashes\\"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*"Comment with \\\\backslashes\\\\"/)
+
+    node = DOT::Node.new({"name" => "test_name", "comment" => "123.456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*123.456/)
+
+    node = DOT::Node.new({"name" => "test_name", "comment" => ".456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*.456/)
+
+    node = DOT::Node.new({"name" => "test_name", "comment" => "-.456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*-.456/)
+
+    node = DOT::Node.new({"name" => "test_name", "comment" => "-456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*-456/)
+
+    node = DOT::Node.new({"name" => "test_name", "comment" => "-123.456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*-123.456/)
+
+    node = DOT::Node.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 DOT::Edge
+class TestDotEdge < Test::Unit::TestCase
+
+  def test_0prop
+    edge = DOT::Edge.new({'from' => 'a', 'to' => 'b'})
+    dot = edge.to_s
+    assert_equal('a -- b', dot)
+  end
+
+  def test_1prop_0comma
+    edge = DOT::Edge.new({"label"=>"the_label"})
+    dot = edge.to_s
+    assert_no_match(dot, /,/)
+  end
+
+  def test_2prop_1comma
+    edge = DOT::Edge.new({"label"=>"the_label", "weight"=>"2"})
+    dot = edge.to_s
+    assert_match(dot, /\[[^,]*,[^,]*\]/)
+  end
+
+  def test_no_label
+    edge = DOT::Edge.new({"weight"=>"2"})
+    dot = edge.to_s
+    assert_no_match(dot, /label/)
+  end
+end
+
+# Tests for DOT::DirectedEdge
+class TestDotDirectedEdge < Test::Unit::TestCase
+
+  def test_0prop
+    edge = DOT::DirectedEdge.new({'from' => 'a', 'to' => 'b'})
+    dot = edge.to_s
+    assert_equal('a -> b', dot)
+  end
+
+  def test_1prop_0comma
+    edge = DOT::DirectedEdge.new({"label"=>"the_label"})
+    dot = edge.to_s
+    assert_no_match(dot, /,/)
+  end
+
+  def test_2prop_1comma
+    edge = DOT::DirectedEdge.new({"label"=>"the_label", "weight"=>"2"})
+    dot = edge.to_s
+    assert_match(dot, /\[[^,]*,[^,]*\]/)
+  end
+
+  def test_no_label
+    edge = DOT::DirectedEdge.new({"weight"=>"2"})
+    dot = edge.to_s
+    assert_no_match(dot, /label/)
+  end
+end
+
+# Tests for DOT::Graph
+class TestDotGraph < Test::Unit::TestCase
+  def test_graph_statement
+    graph = DOT::Graph.new()
+    dot = graph.to_s
+    assert_match(dot, /^\s*graph /)
+  end
+
+  def test_name_quoting
+    node = DOT::Graph.new({"name" => "Name with spaces"})
+    dot = node.to_s
+    assert_match(dot, /^graph "Name with spaces" \{$/)
+
+    node = DOT::Graph.new({"name" => "Name with \"quotes\""})
+    dot = node.to_s
+    assert_match(dot, /^graph "Name with \\"quotes\\"" \{$/)
+
+    node = DOT::Graph.new({"name" => "Name with \\backslashes\\"})
+    dot = node.to_s
+    assert_match(dot, /^graph "Name with \\\\backslashes\\\\" \{$/)
+
+    node = DOT::Graph.new({"name" => "Name with\nembedded\nnewlines"})
+    dot = node.to_s
+    assert_match(dot, /\A.*"Name with\nembedded\nnewlines".*\Z/m)
+
+    node = DOT::Graph.new({"name" => "Name_with_trailing_newline\n"})
+    dot = node.to_s
+    assert_match(dot, /\A.*"Name_with_trailing_newline\n".*\Z/m)
+
+    node = DOT::Graph.new({"name" => "123.456"})
+    dot = node.to_s
+    assert_match(dot, /^graph 123.456 \{$/)
+
+    node = DOT::Graph.new({"name" => ".456"})
+    dot = node.to_s
+    assert_match(dot, /^graph .456 \{$/)
+
+    node = DOT::Graph.new({"name" => "-.456"})
+    dot = node.to_s
+    assert_match(dot, /^graph -.456 \{$/)
+
+    node = DOT::Graph.new({"name" => "-456"})
+    dot = node.to_s
+    assert_match(dot, /^graph -456 \{$/)
+
+    node = DOT::Graph.new({"name" => "-123.456"})
+    dot = node.to_s
+    assert_match(dot, /^graph -123.456 \{$/)
+
+    node = DOT::Graph.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 = DOT::Graph.new({"name" => "test_name", "label" => "Label with spaces"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with spaces"/)
+
+    node = DOT::Graph.new({"name" => "test_name", "label" => "Label with \"quotes\""})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with \\"quotes\\""/)
+
+    node = DOT::Graph.new({"name" => "test_name", "label" => "Label with \\backslashes\\"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with \\\\backslashes\\\\"/)
+
+    node = DOT::Graph.new({"name" => "test_name", "label" => "Label with\nembedded\nnewlines"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with\\nembedded\\nnewlines"/)
+
+    node = DOT::Graph.new({"name" => "test_name", "label" => "Label_with_a_trailing_newline\n"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label_with_a_trailing_newline\\n"/)
+
+    node = DOT::Graph.new({"name" => "test_name", "label" => "Left justified label\\l"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Left justified label\\l"/)
+
+    node = DOT::Graph.new({"name" => "test_name", "label" => "Right justified label\\r"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Right justified label\\r"/)
+
+    node = DOT::Graph.new({"name" => "test_name", "label" => "123.456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*123.456/)
+
+    node = DOT::Graph.new({"name" => "test_name", "label" => ".456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*.456/)
+
+    node = DOT::Graph.new({"name" => "test_name", "label" => "-.456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*-.456/)
+
+    node = DOT::Graph.new({"name" => "test_name", "label" => "-456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*-456/)
+
+    node = DOT::Graph.new({"name" => "test_name", "label" => "-123.456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*-123.456/)
+
+    node = DOT::Graph.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 = DOT::Graph.new({"name" => "test_name", "comment" => "Comment with spaces"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*"Comment with spaces"/)
+
+    node = DOT::Graph.new({"name" => "test_name", "comment" => "Comment with \"quotes\""})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*"Comment with \\"quotes\\""/)
+
+    node = DOT::Graph.new({"name" => "test_name", "comment" => "Comment with \\backslashes\\"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*"Comment with \\\\backslashes\\\\"/)
+
+    node = DOT::Graph.new({"name" => "test_name", "comment" => "123.456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*123.456/)
+
+    node = DOT::Graph.new({"name" => "test_name", "comment" => ".456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*.456/)
+
+    node = DOT::Graph.new({"name" => "test_name", "comment" => "-.456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*-.456/)
+
+    node = DOT::Graph.new({"name" => "test_name", "comment" => "-456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*-456/)
+
+    node = DOT::Graph.new({"name" => "test_name", "comment" => "-123.456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*-123.456/)
+
+    node = DOT::Graph.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 = DOT::Node.new('name' => 'test_node1')
+    node2 = DOT::Node.new('name' => 'test_node2')
+
+    graph = DOT::Graph.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 = DOT::Graph.new('name' => 'test_graph', 'elements' => [node1])
+    assert_equal(node1, graph.pop)
+    assert_nil(graph.pop)
+  end
+end
+
+# Tests for DOT::Digraph
+class TestDotDigraph < Test::Unit::TestCase
+  def test_digraph_statement
+    digraph = DOT::Digraph.new()
+    dot = digraph.to_s
+    assert_match(dot, /^\s*digraph /)
+  end
+
+  def test_name_quoting
+    node = DOT::Digraph.new({"name" => "Name with spaces"})
+    dot = node.to_s
+    assert_match(dot, /^digraph "Name with spaces" \{$/)
+
+    node = DOT::Digraph.new({"name" => "Name with \"quotes\""})
+    dot = node.to_s
+    assert_match(dot, /^digraph "Name with \\"quotes\\"" \{$/)
+
+    node = DOT::Digraph.new({"name" => "Name with \\backslashes\\"})
+    dot = node.to_s
+    assert_match(dot, /^digraph "Name with \\\\backslashes\\\\" \{$/)
+
+    node = DOT::Digraph.new({"name" => "Name with\nembedded\nnewlines"})
+    dot = node.to_s
+    assert_match(dot, /\A.*"Name with\nembedded\nnewlines".*\Z/m)
+
+    node = DOT::Digraph.new({"name" => "Name_with_trailing_newline\n"})
+    dot = node.to_s
+    assert_match(dot, /\A.*"Name_with_trailing_newline\n".*\Z/m)
+
+    node = DOT::Digraph.new({"name" => "123.456"})
+    dot = node.to_s
+    assert_match(dot, /^digraph 123.456 \{$/)
+
+    node = DOT::Digraph.new({"name" => ".456"})
+    dot = node.to_s
+    assert_match(dot, /^digraph .456 \{$/)
+
+    node = DOT::Digraph.new({"name" => "-.456"})
+    dot = node.to_s
+    assert_match(dot, /^digraph -.456 \{$/)
+
+    node = DOT::Digraph.new({"name" => "-456"})
+    dot = node.to_s
+    assert_match(dot, /^digraph -456 \{$/)
+
+    node = DOT::Digraph.new({"name" => "-123.456"})
+    dot = node.to_s
+    assert_match(dot, /^digraph -123.456 \{$/)
+
+    node = DOT::Digraph.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 = DOT::Digraph.new({"name" => "test_name", "label" => "Label with spaces"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with spaces"/)
+
+    node = DOT::Digraph.new({"name" => "test_name", "label" => "Label with \"quotes\""})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with \\"quotes\\""/)
+
+    node = DOT::Digraph.new({"name" => "test_name", "label" => "Label with \\backslashes\\"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with \\\\backslashes\\\\"/)
+
+    node = DOT::Digraph.new({"name" => "test_name", "label" => "Label with\nembedded\nnewlines"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with\\nembedded\\nnewlines"/)
+
+    node = DOT::Digraph.new({"name" => "test_name", "label" => "Label_with_a_trailing_newline\n"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label_with_a_trailing_newline\\n"/)
+
+    node = DOT::Digraph.new({"name" => "test_name", "label" => "Left justified label\\l"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Left justified label\\l"/)
+
+    node = DOT::Digraph.new({"name" => "test_name", "label" => "Right justified label\\r"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Right justified label\\r"/)
+
+    node = DOT::Digraph.new({"name" => "test_name", "label" => "123.456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*123.456/)
+
+    node = DOT::Digraph.new({"name" => "test_name", "label" => ".456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*.456/)
+
+    node = DOT::Digraph.new({"name" => "test_name", "label" => "-.456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*-.456/)
+
+    node = DOT::Digraph.new({"name" => "test_name", "label" => "-456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*-456/)
+
+    node = DOT::Digraph.new({"name" => "test_name", "label" => "-123.456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*-123.456/)
+
+    node = DOT::Digraph.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 = DOT::Digraph.new({"name" => "test_name", "comment" => "Comment with spaces"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*"Comment with spaces"/)
+
+    node = DOT::Digraph.new({"name" => "test_name", "comment" => "Comment with \"quotes\""})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*"Comment with \\"quotes\\""/)
+
+    node = DOT::Digraph.new({"name" => "test_name", "comment" => "Comment with \\backslashes\\"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*"Comment with \\\\backslashes\\\\"/)
+
+    node = DOT::Digraph.new({"name" => "test_name", "comment" => "123.456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*123.456/)
+
+    node = DOT::Digraph.new({"name" => "test_name", "comment" => ".456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*.456/)
+
+    node = DOT::Digraph.new({"name" => "test_name", "comment" => "-.456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*-.456/)
+
+    node = DOT::Digraph.new({"name" => "test_name", "comment" => "-456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*-456/)
+
+    node = DOT::Digraph.new({"name" => "test_name", "comment" => "-123.456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*-123.456/)
+
+    node = DOT::Digraph.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 = DOT::Node.new('name' => 'test_node1')
+    node2 = DOT::Node.new('name' => 'test_node2')
+
+    graph = DOT::Digraph.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 = DOT::Digraph.new('name' => 'test_graph', 'elements' => [node1])
+    assert_equal(node1, graph.pop)
+    assert_nil(graph.pop)
+  end
+end
+
+# Tests for DOT::Subgraph
+class TestDotSubgraph < Test::Unit::TestCase
+  def test_subgraph_statement
+    subgraph = DOT::Subgraph.new()
+    dot = subgraph.to_s
+    assert_match(dot, /^\s*subgraph /)
+  end
+
+  def test_name_quoting
+    node = DOT::Subgraph.new({"name" => "Name with spaces"})
+    dot = node.to_s
+    assert_match(dot, /^subgraph "Name with spaces" \{$/)
+
+    node = DOT::Subgraph.new({"name" => "Name with \"quotes\""})
+    dot = node.to_s
+    assert_match(dot, /^subgraph "Name with \\"quotes\\"" \{$/)
+
+    node = DOT::Subgraph.new({"name" => "Name with \\backslashes\\"})
+    dot = node.to_s
+    assert_match(dot, /^subgraph "Name with \\\\backslashes\\\\" \{$/)
+
+    node = DOT::Subgraph.new({"name" => "Name with\nembedded\nnewlines"})
+    dot = node.to_s
+    assert_match(dot, /\A.*"Name with\nembedded\nnewlines".*\Z/m)
+
+    node = DOT::Subgraph.new({"name" => "Name_with_trailing_newline\n"})
+    dot = node.to_s
+    assert_match(dot, /\A.*"Name_with_trailing_newline\n".*\Z/m)
+
+    node = DOT::Subgraph.new({"name" => "123.456"})
+    dot = node.to_s
+    assert_match(dot, /^subgraph 123.456 \{$/)
+
+    node = DOT::Subgraph.new({"name" => ".456"})
+    dot = node.to_s
+    assert_match(dot, /^subgraph .456 \{$/)
+
+    node = DOT::Subgraph.new({"name" => "-.456"})
+    dot = node.to_s
+    assert_match(dot, /^subgraph -.456 \{$/)
+
+    node = DOT::Subgraph.new({"name" => "-456"})
+    dot = node.to_s
+    assert_match(dot, /^subgraph -456 \{$/)
+
+    node = DOT::Subgraph.new({"name" => "-123.456"})
+    dot = node.to_s
+    assert_match(dot, /^subgraph -123.456 \{$/)
+
+    node = DOT::Subgraph.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 = DOT::Subgraph.new({"name" => "test_name", "label" => "Label with spaces"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with spaces"/)
+
+    node = DOT::Subgraph.new({"name" => "test_name", "label" => "Label with \"quotes\""})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with \\"quotes\\""/)
+
+    node = DOT::Subgraph.new({"name" => "test_name", "label" => "Label with \\backslashes\\"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with \\\\backslashes\\\\"/)
+
+    node = DOT::Subgraph.new({"name" => "test_name", "label" => "Label with\nembedded\nnewlines"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with\\nembedded\\nnewlines"/)
+
+    node = DOT::Subgraph.new({"name" => "test_name", "label" => "Label_with_a_trailing_newline\n"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label_with_a_trailing_newline\\n"/)
+
+    node = DOT::Subgraph.new({"name" => "test_name", "label" => "Left justified label\\l"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Left justified label\\l"/)
+
+    node = DOT::Subgraph.new({"name" => "test_name", "label" => "Right justified label\\r"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Right justified label\\r"/)
+
+    node = DOT::Subgraph.new({"name" => "test_name", "label" => "123.456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*123.456/)
+
+    node = DOT::Subgraph.new({"name" => "test_name", "label" => ".456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*.456/)
+
+    node = DOT::Subgraph.new({"name" => "test_name", "label" => "-.456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*-.456/)
+
+    node = DOT::Subgraph.new({"name" => "test_name", "label" => "-456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*-456/)
+
+    node = DOT::Subgraph.new({"name" => "test_name", "label" => "-123.456"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*-123.456/)
+
+    node = DOT::Subgraph.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 = DOT::Subgraph.new({"name" => "test_name", "comment" => "Comment with spaces"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*"Comment with spaces"/)
+
+    node = DOT::Subgraph.new({"name" => "test_name", "comment" => "Comment with \"quotes\""})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*"Comment with \\"quotes\\""/)
+
+    node = DOT::Subgraph.new({"name" => "test_name", "comment" => "Comment with \\backslashes\\"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*"Comment with \\\\backslashes\\\\"/)
+
+    node = DOT::Subgraph.new({"name" => "test_name", "comment" => "123.456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*123.456/)
+
+    node = DOT::Subgraph.new({"name" => "test_name", "comment" => ".456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*.456/)
+
+    node = DOT::Subgraph.new({"name" => "test_name", "comment" => "-.456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*-.456/)
+
+    node = DOT::Subgraph.new({"name" => "test_name", "comment" => "-456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*-456/)
+
+    node = DOT::Subgraph.new({"name" => "test_name", "comment" => "-123.456"})
+    dot = node.to_s
+    assert_match(dot, /comment\s*=\s*-123.456/)
+
+    node = DOT::Subgraph.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 = DOT::Node.new('name' => 'test_node1')
+    node2 = DOT::Node.new('name' => 'test_node2')
+
+    graph = DOT::Subgraph.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 = DOT::Subgraph.new('name' => 'test_graph', 'elements' => [node1])
+    assert_equal(node1, graph.pop)
+    assert_nil(graph.pop)
+  end
+end