rgl 0.4.0 → 0.5.0

data/test/prim_test.rb

@@ -0,0 +1,98 @@
+require 'test_helper'
+
+require 'rgl/prim'
+require 'rgl/adjacency'
+
+include RGL
+
+class TestPrim < Test::Unit::TestCase
+
+  def setup
+    @graph = AdjacencyGraph[1,2, 1,3, 2,3, 2,4, 3,4]
+
+    @edge_weights = {
+        [1, 2] => 10,
+        [1, 3] => 1,
+        [2, 3] => 1,
+        [2, 4] => 1,
+        [3, 4] => 10
+    }
+
+    @edge_weights_lambda = lambda { |edge| @edge_weights[edge] }
+  end
+
+  def test_minimum_spanning_tree
+    assert(minimum_spanning_tree.is_a?(AdjacencyGraph))
+  end
+
+  def test_minimum_spanning_tree_edges
+    assert_equal([[1, 3], [2, 3], [2, 4]], minimum_spanning_tree_edges)
+  end
+
+  def test_minimum_spanning_tree_for_disconnected_graph
+    @graph.add_edge(5, 6)
+    @graph.add_edge(6, 7)
+    @edge_weights.merge!([5, 6] => 1, [6, 7] => 2)
+
+    assert_equal([[1, 3], [2, 3], [2, 4]], minimum_spanning_tree_edges(@edge_weights, 1))
+    assert_equal([[5, 6], [6, 7]], minimum_spanning_tree_edges(@edge_weights, 5))
+  end
+
+  def test_visitor
+    visitor = DijkstraVisitor.new(@graph)
+
+    events = []
+
+    %w[examine_vertex examine_edge edge_relaxed edge_not_relaxed finish_vertex].each do |event|
+      visitor.send("set_#{event}_event_handler") { |*args| events << { event.to_sym => args } }
+    end
+
+    @graph.prim_minimum_spanning_tree(@edge_weights, 1, visitor)
+
+    assert_equal(
+        [
+            { :examine_vertex => [1] },
+            { :examine_edge   => [1, 2] },
+            { :edge_relaxed   => [1, 2] },
+            { :examine_edge   => [1, 3] },
+            { :edge_relaxed   => [1, 3] },
+            { :finish_vertex  => [1] },
+            { :examine_vertex => [3] },
+            { :examine_edge   => [3, 2] },
+            { :edge_relaxed   => [3, 2] },
+            { :examine_edge   => [3, 4] },
+            { :edge_relaxed   => [3, 4] },
+            { :finish_vertex  => [3] },
+            { :examine_vertex => [2] },
+            { :examine_edge   => [2, 4] },
+            { :edge_relaxed   => [2, 4] },
+            { :finish_vertex  => [2] },
+            { :examine_vertex => [4] },
+            { :finish_vertex  => [4] },
+        ],
+        events
+    )
+  end
+
+  def test_negative_weights
+    @edge_weights[[1, 3]] = -2
+    @edge_weights[[2, 3]] = -2
+
+    assert_equal([[1, 3], [2, 3], [2, 4]], minimum_spanning_tree_edges)
+  end
+
+  private
+
+  def minimum_spanning_tree_edges(edge_weights = @edge_weights, start_vertex = nil)
+    sorted_edges(@graph.prim_minimum_spanning_tree(edge_weights, start_vertex))
+  end
+
+  def minimum_spanning_tree(edge_weights = @edge_weights)
+    @graph.prim_minimum_spanning_tree(edge_weights)
+  end
+
+  def sorted_edges(graph)
+    graph.edges.map { |e| [e.source, e.target].sort }.sort
+  end
+
+end

data/{tests/TestRdot.rb → test/rdot_test.rb}

@@ -1,4 +1,5 @@
-require 'test/unit'
+require 'test_helper'
+
 require 'rgl/rdot'
 
 include RGL
@@ -44,7 +45,7 @@ class TestDotPort < Test::Unit::TestCase
   end
 
   def test_name_label_and_nested_ports
-    port = DOT::Port.new('test_name', 'test_label')
+    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
@@ -55,51 +56,51 @@ class TestDotNode < Test::Unit::TestCase
 
   def test_no_name
     node = DOT::Node.new()
-    dot = node.to_s
+    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
+    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
+    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
+    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
+    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
+    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
+    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 = 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
@@ -108,7 +109,7 @@ class TestDotNode < Test::Unit::TestCase
   end
 
   def test_Mrecord_no_label_with_ports
-    node = DOT::Node.new({"name" => "test_name", "shape"=>"Mrecord"})
+    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
@@ -117,21 +118,21 @@ class TestDotNode < Test::Unit::TestCase
   end
 
   def test_record_no_label_no_ports
-    node = DOT::Node.new({"name" => "test_name", "shape"=>"record"})
-    dot = node.to_s
+    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
+    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 = 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
@@ -140,7 +141,7 @@ class TestDotNode < Test::Unit::TestCase
   end
 
   def test_record_no_label_with_ports
-    node = DOT::Node.new({"name" => "test_name", "shape"=>"record"})
+    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
@@ -149,7 +150,7 @@ class TestDotNode < Test::Unit::TestCase
   end
 
   def test_no_shape_no_label_no_ports
-    node = DOT::Node.new({"name" => "test_name"})
+    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
@@ -158,7 +159,7 @@ class TestDotNode < Test::Unit::TestCase
   end
 
   def test_no_shape_no_label_with_ports
-    node = DOT::Node.new({"name" => "test_name"})
+    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
@@ -167,140 +168,140 @@ class TestDotNode < Test::Unit::TestCase
   end
 
   def test_name_quoting
-    node = DOT::Node.new({"name" => "Name with spaces"})
-    dot = node.to_s
+    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
+    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
+    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
+    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
+    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
+    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
+    node = DOT::Node.new({ "name" => ".456" })
+    dot  = node.to_s
     assert_match(dot, /^.456$/)
 
-    node = DOT::Node.new({"name" => "-.456"})
-    dot = node.to_s
+    node = DOT::Node.new({ "name" => "-.456" })
+    dot  = node.to_s
     assert_match(dot, /^-.456$/)
 
-    node = DOT::Node.new({"name" => "-456"})
-    dot = node.to_s
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
@@ -309,26 +310,26 @@ end
 class TestDotEdge < Test::Unit::TestCase
 
   def test_0prop
-    edge = DOT::Edge.new({'from' => 'a', 'to' => 'b'})
-    dot = edge.to_s
+    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
+    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
+    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
+    edge = DOT::Edge.new({ "weight" => "2" })
+    dot  = edge.to_s
     assert_no_match(dot, /label/)
   end
 end
@@ -337,26 +338,26 @@ end
 class TestDotDirectedEdge < Test::Unit::TestCase
 
   def test_0prop
-    edge = DOT::DirectedEdge.new({'from' => 'a', 'to' => 'b'})
-    dot = edge.to_s
+    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
+    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
+    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
+    edge = DOT::DirectedEdge.new({ "weight" => "2" })
+    dot  = edge.to_s
     assert_no_match(dot, /label/)
   end
 end
@@ -365,145 +366,145 @@ end
 class TestDotGraph < Test::Unit::TestCase
   def test_graph_statement
     graph = DOT::Graph.new()
-    dot = graph.to_s
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
 
@@ -532,145 +533,145 @@ end
 class TestDotDigraph < Test::Unit::TestCase
   def test_digraph_statement
     digraph = DOT::Digraph.new()
-    dot = digraph.to_s
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
 
@@ -699,145 +700,145 @@ end
 class TestDotSubgraph < Test::Unit::TestCase
   def test_subgraph_statement
     subgraph = DOT::Subgraph.new()
-    dot = subgraph.to_s
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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