RubyGems - cast - Versions diffs - 0.1.0 → 0.2.0 - Mend

cast 0.1.0 → 0.2.0

Files changed (38) hide show

data/.gitignore +8 -0
data/CHANGELOG +50 -0
data/Gemfile +2 -0
data/LICENSE +22 -0
data/README.markdown +1948 -0
data/Rakefile +22 -0
data/cast.gemspec +20 -0
data/ext/cast.c +6 -0
data/ext/extconf.rb +1 -1
data/ext/parser.c +2 -2
data/ext/yylex.c +2592 -4171
data/ext/yylex.re +20 -26
data/lib/cast.rb +11 -16
data/lib/cast/c.tab.rb +2252 -2231
data/lib/cast/c.y +185 -161
data/lib/cast/c_nodes.rb +181 -391
data/lib/cast/inspect.rb +8 -10
data/lib/cast/node.rb +362 -365
data/lib/cast/node_list.rb +156 -165
data/lib/cast/parse.rb +86 -65
data/lib/cast/preprocessor.rb +72 -0
data/lib/cast/tempfile.rb +33 -0
data/lib/cast/to_s.rb +83 -75
data/lib/cast/version.rb +11 -0
data/test/all.rb +5 -0
data/test/{test_c_nodes.rb → c_nodes_test.rb} +91 -23
data/test/lexer_test.rb +323 -0
data/test/{test_node_list.rb → node_list_test.rb} +367 -396
data/test/{test_node.rb → node_test.rb} +142 -160
data/test/{test_parse.rb → parse_test.rb} +63 -17
data/test/{test_parser.rb → parser_test.rb} +62 -22
data/test/preprocessor_test.rb +87 -0
data/test/render_test.rb +2086 -0
data/test/{run.rb → test_helper.rb} +76 -88
metadata +100 -54
data/README +0 -6
data/doc/index.html +0 -2505
data/ext/cast_ext.c +0 -10

data/test/{test_node_list.rb → node_list_test.rb} RENAMED

@@ -1,50 +1,50 @@
-###
-### ##################################################################
-###
-### Tests for NodeList classes.
-###
-### ##################################################################
-###
-###
-### NodeListTest classes are abstract, inherited by classes which
-### define List() to return a NodeList class.  The tests defined in
-### NodeListTest subclasses are therefore used to test all NodeList
-### classes.
-###
+######################################################################
+#
+# Tests for NodeList classes.
+#
+######################################################################
+require 'test/test_helper'
+#
+# NodeListTest classes are abstract, inherited by classes which define
+# List() to return a NodeList class.  The tests defined in
+# NodeListTest subclasses are therefore used to test all NodeList
+# classes.
+#
 module NodeListTest
   @@submodules = []
   def self.submodules
     @@submodules
   end
-  def self.included m
+  def self.included(m)
     @@submodules << m
   end
   def setup
-    ## []
+    # []
     @empty = _List[]
-    ## [a]
+    # [a]
     a = C::Int.new
     @one = _List[a]
     @one_els = [a]
-    ## [a, b]
+    # [a, b]
     a, b = 2.of{C::Int.new}
     @two = _List[a, b]
     @two_els = [a, b]
-    ## [a, b, c]
+    # [a, b, c]
     a, b, c = 3.of{C::Int.new}
     @three = _List[a, b, c]
     @three_els = [a, b, c]
-    ## [a, b, c, d]
+    # [a, b, c, d]
     a, b, c, d = 4.of{C::Int.new}
     @four = _List[a, b, c, d]
     @four_els = [a, b, c, d]
-    ## [[a,b], [c,d], [e,f], [g,h]]
+    # [[a,b], [c,d], [e,f], [g,h]]
     a, b, c, d, e, f, g, h = 8.of{C::Int.new}
     l0 = _List[a,b]
     l1 = _List[c,d]
@@ -53,7 +53,7 @@ module NodeListTest
     @two_by_four = _List[l0, l1, l2, l3]
     @two_by_four_els = [l0, l1, l2, l3, a, b, c, d, e, f, g, h]
-    ## [a, [b,c], [d, [e], [], [[]]]]
+    # [a, [b,c], [d, [e], [], [[]]]]
     a, b, c, d, e = 5.of{C::Int.new}
     l1  = _List[b,c]
     l21 = _List[e]
@@ -96,82 +96,82 @@ module NodeListInitializeTest
   end
 end
-###
-### Tests dup, clone.
-###
+#
+# Tests dup, clone.
+#
 module NodeListCopyTest
   include NodeListTest
   def test_copy
-    ## empty
+    # empty
     a = empty
     b = empty.dup
     c = empty.clone
-    ##
+    #
     assert_copy a, b
-    ##
+    #
     assert_copy a, c
-    ## one
+    # one
     a = one
     b = one.dup
     c = one.clone
-    ##
+    #
     assert_copy a, b
     assert_copy a[0], b[0]
-    ##
+    #
     assert_copy a, c
     assert_copy a[0], c[0]
-    ## two
+    # two
     a = two
     b = two.dup
     c = two.clone
-    ##
+    #
     assert_copy a, b
     assert_copy a[0], b[0]
     assert_copy a[1], b[1]
-    ##
+    #
     assert_copy a, c
     assert_copy a[0], c[0]
     assert_copy a[1], c[1]
-    ## three
+    # three
     a = three
     b = three.dup
     c = three.clone
-    ##
+    #
     assert_copy a, b
     assert_copy a[0], b[0]
     assert_copy a[1], b[1]
     assert_copy a[2], b[2]
-    ##
+    #
     assert_copy a, c
     assert_copy a[0], c[0]
     assert_copy a[1], c[1]
     assert_copy a[2], c[2]
-    ## four
+    # four
     a = four
     b = four.dup
     c = four.clone
-    ##
+    #
     assert_copy a, b
     assert_copy a[0], b[0]
     assert_copy a[1], b[1]
     assert_copy a[2], b[2]
     assert_copy a[3], b[3]
-    ##
+    #
     assert_copy a, c
     assert_copy a[0], c[0]
     assert_copy a[1], c[1]
     assert_copy a[2], c[2]
     assert_copy a[3], c[3]
-    ## two_by_four
+    # two_by_four
     a = two_by_four
     b = two_by_four.dup
     c = two_by_four.clone
-    ##
+    #
     assert_copy a, b
     assert_copy a[0], b[0]
     assert_copy a[1], b[1]
@@ -185,7 +185,7 @@ module NodeListCopyTest
     assert_copy a[2][1], b[2][1]
     assert_copy a[3][0], b[3][0]
     assert_copy a[3][1], b[3][1]
-    ##
+    #
     assert_copy a, c
     assert_copy a[0], c[0]
     assert_copy a[1], c[1]
@@ -200,11 +200,11 @@ module NodeListCopyTest
     assert_copy a[3][0], c[3][0]
     assert_copy a[3][1], c[3][1]
-    ## big -- [a, [b,c], [d, [e], [], [[]]]]
+    # big -- [a, [b,c], [d, [e], [], [[]]]]
     a = big
     b = big.dup
     c = big.clone
-    ##
+    #
     assert_copy a, b
     assert_copy a[0], b[0]
     assert_copy a[1], b[1]
@@ -217,7 +217,7 @@ module NodeListCopyTest
     assert_copy a[2][2], b[2][2]
     assert_copy a[2][3], b[2][3]
     assert_copy a[2][3][0], b[2][3][0]
-    ##
+    #
     assert_copy a, c
     assert_copy a[0], c[0]
     assert_copy a[1], c[1]
@@ -233,17 +233,17 @@ module NodeListCopyTest
   end
 end
-###
-### Tests ==, eql?, hash.
-###
+#
+# Tests ==, eql?, hash.
+#
 module NodeListEqualTest
   include NodeListTest
-  def assert_eq a, b
+  def assert_eq(a, b)
     assert(a == b)
     assert(a.eql?(b))
     assert(a.hash == b.hash)
   end
-  def assert_not_eq a, b
+  def assert_not_eq(a, b)
     assert(!(a == b))
     assert(!a.eql?(b))
   end
@@ -263,31 +263,31 @@ module NodeListEqualTest
     assert_not_eq(two, three)
     assert_not_eq(three, two)
-    ## []
+    # []
     empty2 = _List[]
     assert_eq(empty, empty2)
-    ## [a]
+    # [a]
     a = C::Int.new
     one2 = _List[a]
     assert_eq(one, one2)
-    ## [a, b]
+    # [a, b]
     a, b = 2.of{C::Int.new}
     two2 = _List[a, b]
     assert_eq(two, two2)
-    ## [a, b, c]
+    # [a, b, c]
     a, b, c = 3.of{C::Int.new}
     three2 = _List[a, b, c]
     assert_eq(three, three2)
-    ## [a, b, c, d]
+    # [a, b, c, d]
     a, b, c, d = 4.of{C::Int.new}
     four2 = _List[a, b, c, d]
     assert_eq(four, four2)
-    ## [[a,b], [c,d], [e,f], [g,h]]
+    # [[a,b], [c,d], [e,f], [g,h]]
     a, b, c, d, e, f, g, h = 8.of{C::Int.new}
     l0 = _List[a,b]
     l1 = _List[c,d]
@@ -296,7 +296,7 @@ module NodeListEqualTest
     two_by_four2 = _List[l0, l1, l2, l3]
     assert_eq(two_by_four, two_by_four2)
-    ## [a, [b,c], [d, [e], [], [[]]]]
+    # [a, [b,c], [d, [e], [], [[]]]]
     a, b, c, d, e = 5.of{C::Int.new}
     l1  = _List[b,c]
     l21 = _List[e]
@@ -311,11 +311,11 @@ end
 module NodeListWalkTest
   include NodeListTest
-  ###
-  ### Collect and return the args yielded to `node.send(method)' as an
-  ### Array, each element of which is an array of args yielded.
-  ###
-  def yields method, node, exp
+  #
+  # Collect and return the args yielded to `node.send(method)' as an
+  # Array, each element of which is an array of args yielded.
+  #
+  def yields(method, node, exp)
     ret = []
     out = node.send(method) do |*args|
       ret << args
@@ -324,18 +324,18 @@ module NodeListWalkTest
     return ret
   end
-  ###
-  ### Assert exp and out are equal, where elements are compared with
-  ### Array#same_list?.  That is, exp[i].same_list?(out[i]) for all i.
-  ###
-  def assert_equal_yields exp, out
+  #
+  # Assert exp and out are equal, where elements are compared with
+  # Array#same_list?.  That is, exp[i].same_list?(out[i]) for all i.
+  #
+  def assert_equal_yields(exp, out)
     if exp.zip(out).all?{|a,b| a.same_list?(b)}
       assert(true)
     else
       flunk("walk not equal: #{walk_str(out)} (expected #{walk_str(exp)})")
     end
   end
-  def walk_str walk
+  def walk_str(walk)
     walk.is_a? ::Array or
       raise "walk_str: expected ::Array"
     if walk.empty?
@@ -355,12 +355,11 @@ module NodeListWalkTest
     end
   end
-  ###
-  ### ----------------------------------------------------------------
-  ###                        each, reverse_each
-  ### ----------------------------------------------------------------
-  ###
-  def iter_str iter
+  # ------------------------------------------------------------------
+  #                         each, reverse_each
+  # ------------------------------------------------------------------
+  def iter_str(iter)
     iter.is_a? ::Array or
       raise "iter_str: expected ::Array"
     if iter.empty?
@@ -379,7 +378,7 @@ module NodeListWalkTest
       return s.string
     end
   end
-  def check_iter node, exp
+  def check_iter(node, exp)
     exp.map!{|n| [n]}
     out = yields(:each, node, node)
@@ -391,69 +390,68 @@ module NodeListWalkTest
   end
   def test_each
-    ## empty
+    # empty
     check_iter(empty, [])
-    ## one
-    a = *one_els
+    # one
+    a, = *one_els
     check_iter(one, [a])
-    ## two
+    # two
     a, b = *two_els
     check_iter(two, [a, b])
-    ## three
+    # three
     a, b, c = *three_els
     check_iter(three, [a, b, c])
-    ## four
+    # four
     a, b, c, d = *four_els
     check_iter(four, [a, b, c, d])
-    ## two_by_four
+    # two_by_four
     l0, l1, l2, l3, a, b, c, d, e, f, g, h = *two_by_four_els
     check_iter(two_by_four, [l0, l1, l2, l3])
-    ## big
+    # big
     l1, l2, l21, l22, l23, l230, a, b, c, d, e = *big_els
     check_iter(big, [a, l1, l2])
   end
-  ###
-  ### ----------------------------------------------------------------
-  ###                            each_index
-  ### ----------------------------------------------------------------
-  ###
+  # ------------------------------------------------------------------
+  #                             each_index
+  # ------------------------------------------------------------------
   def test_each_index
-    ## empty
+    # empty
     assert_equal([], yields(:each_index, empty, empty))
-    ## one
+    # one
     assert_equal([[0]], yields(:each_index, one, one))
-    ## two
+    # two
     assert_equal([[0], [1]], yields(:each_index, two, two))
-    ## two_by_four
+    # two_by_four
     assert_equal([[0], [1], [2], [3]], yields(:each_index, two_by_four, two_by_four))
-    ## big
+    # big
     assert_equal([[0], [1], [2]], yields(:each_index, big, big))
   end
 end
-###
-### Tests:
-###   -- node_before
-###   -- node_after
-###   -- remove_node
-###   -- insert_before
-###   -- insert_after
-###   -- replace_node
-###
+#
+# Tests:
+#   -- node_before
+#   -- node_after
+#   -- remove_node
+#   -- insert_before
+#   -- insert_after
+#   -- replace_node
+#
 module NodeListChildManagementTests
   include NodeListTest
-  def check_not_child list, node
+  def check_not_child(list, node)
     n = C::Int.new
     assert_raise(ArgumentError, list.node_before(node))
     assert_raise(ArgumentError, list.node_after(node))
@@ -463,7 +461,7 @@ module NodeListChildManagementTests
     assert_raise(ArgumentError, list.replace_node(node, n))
   end
-  def check_list list, *nodes
+  def check_list(list, *nodes)
     afters = nodes.dup
     afters.shift
     afters.push(nil)
@@ -476,18 +474,16 @@ module NodeListChildManagementTests
     nodes.each_index do |i|
       assert_same(nodes[i], list[i], "at index #{i}")
       assert_same(list, nodes[i].parent, "at index #{i}")
-      ## node_after
+      # node_after
       assert_same(afters[i], list.node_after(nodes[i]), "at index #{i} (expected id=#{afters[i].object_id}, got id=#{list.node_after(nodes[i]).object_id})")
-      ## node_before
+      # node_before
       assert_same(befores[i], list.node_before(nodes[i]), "at index #{i}")
     end
   end
-  ###
-  ### ----------------------------------------------------------------
-  ###                   insert_before, insert_after
-  ### ----------------------------------------------------------------
-  ###
+  # ------------------------------------------------------------------
+  #                    insert_before, insert_after
+  # ------------------------------------------------------------------
   def test_insert_one_into_one
     a1, a2 = 2.of{C::Int.new}
@@ -495,11 +491,11 @@ module NodeListChildManagementTests
     a = _List[a1]
     b = _List[b1]
-    ## beginning
+    # beginning
     assert_same(b, b.insert_before(b1, b2))
     check_list(b, b2, b1)
-    ## end
+    # end
     assert_same(a, a.insert_after(a1, a2))
     check_list(a, a1, a2)
   end
@@ -510,11 +506,11 @@ module NodeListChildManagementTests
     a = _List[a1]
     b = _List[b1]
-    ## beginning
+    # beginning
     assert_same(a, a.insert_before(a1, a2, a3))
     check_list(a, a2, a3, a1)
-    ## end
+    # end
     assert_same(b, b.insert_after(b1, b2, b3))
     check_list(b, b1, b2, b3)
   end
@@ -525,11 +521,11 @@ module NodeListChildManagementTests
     a = _List[a1]
     b = _List[b1]
-    ## beginning
+    # beginning
     assert_same(a, a.insert_before(a1, a2, a3, a4))
     check_list(a, a2, a3, a4, a1)
-    ## end
+    # end
     assert_same(b, b.insert_after(b1, b2, b3, b4))
     check_list(b, b1, b2, b3, b4)
   end
@@ -540,16 +536,16 @@ module NodeListChildManagementTests
     a = _List[a1]
     b = _List[b1]
-    ## beginning
+    # beginning
     assert_same(a, a.insert_before(a1, a2, a3, a4, a5))
     check_list(a, a2, a3, a4, a5, a1)
-    ## end
+    # end
     assert_same(b, b.insert_after(b1, b2, b3, b4, b5))
     check_list(b, b1, b2, b3, b4, b5)
   end
-  def insert_one_into_two
+  def test_insert_one_into_two
     a1, a2, a3 = 3.of{C::Int.new}
     b1, b2, b3 = 3.of{C::Int.new}
     c1, c2, c3 = 3.of{C::Int.new}
@@ -559,19 +555,19 @@ module NodeListChildManagementTests
     c = _List[c1, c2]
     d = _List[d1, d2]
-    ## beginning
+    # beginning
     assert_same(a, a.insert_before(a1, a3))
     check_list(a, a3, a1, a2)
-    ## end
+    # end
     assert_same(b, b.insert_after(b2, b3))
     check_list(b, b1, b2, b3)
-    ## middle (after)
+    # middle (after)
     assert_same(c, c.insert_after(c1, c3))
     check_list(c, c1, c3, c2)
-    ## middle (before)
+    # middle (before)
     assert_same(d, d.insert_before(d2, d3))
     check_list(d, d1, d3, d2)
   end
@@ -586,19 +582,19 @@ module NodeListChildManagementTests
     c = _List[c1, c2]
     d = _List[d1, d2]
-    ## beginning
+    # beginning
     assert_same(a, a.insert_before(a1, a3, a4))
     check_list(a, a3, a4, a1, a2)
-    ## end
+    # end
     assert_same(b, b.insert_after(b2, b3, b4))
     check_list(b, b1, b2, b3, b4)
-    ## middle (after)
+    # middle (after)
     assert_same(c, c.insert_after(c1, c3, c4))
     check_list(c, c1, c3, c4, c2)
-    ## middle (before)
+    # middle (before)
     assert_same(d, d.insert_before(d2, d3, d4))
     check_list(d, d1, d3, d4, d2)
   end
@@ -613,19 +609,19 @@ module NodeListChildManagementTests
     c = _List[c1, c2]
     d = _List[d1, d2]
-    ## beginning
+    # beginning
     assert_same(a, a.insert_before(a1, a3, a4, a5))
     check_list(a, a3, a4, a5, a1, a2)
-    ## end
+    # end
     assert_same(b, b.insert_after(b2, b3, b4, b5))
     check_list(b, b1, b2, b3, b4, b5)
-    ## middle (after)
+    # middle (after)
     assert_same(c, c.insert_after(c1, c3, c4, c5))
     check_list(c, c1, c3, c4, c5, c2)
-    ## middle (before)
+    # middle (before)
     assert_same(d, d.insert_before(d2, d3, d4, d5))
     check_list(d, d1, d3, d4, d5, d2)
   end
@@ -640,25 +636,25 @@ module NodeListChildManagementTests
     c = _List[c1, c2]
     d = _List[d1, d2]
-    ## beginning
+    # beginning
     assert_same(a, a.insert_before(a1, a3, a4, a5, a6))
     check_list(a, a3, a4, a5, a6, a1, a2)
-    ## end
+    # end
     assert_same(b, b.insert_after(b2, b3, b4, b5, b6))
     check_list(b, b1, b2, b3, b4, b5, b6)
-    ## middle (after)
+    # middle (after)
     assert_same(c, c.insert_after(c1, c3, c4, c5, c6))
     check_list(c, c1, c3, c4, c5, c6, c2)
-    ## middle (before)
+    # middle (before)
     assert_same(d, d.insert_before(d2, d3, d4, d5, d6))
     check_list(d, d1, d3, d4, d5, d6, d2)
   end
   def test_insert_attached
-    ## one (before)
+    # one (before)
     a1 = C::Int.new
     b1 = C::Int.new
     a = _List[a1]
@@ -669,7 +665,7 @@ module NodeListChildManagementTests
     assert_copy(b1, a[0])
     assert_same(a1, a[1])
-    ## one (after)
+    # one (after)
     a1 = C::Int.new
     b1 = C::Int.new
     a = _List[a1]
@@ -680,7 +676,7 @@ module NodeListChildManagementTests
     assert_same(a1, a[0])
     assert_copy(b1, a[1])
-    ## many (before)
+    # many (before)
     a1 = C::Int.new
     b1, b2, b3, b4 = 4.of{C::Int.new}
     a = _List[a1]
@@ -694,7 +690,7 @@ module NodeListChildManagementTests
     assert_copy(b4, a[3])
     assert_same(a1, a[4])
-    ## many (after)
+    # many (after)
     a1 = C::Int.new
     b1, b2, b3, b4 = 4.of{C::Int.new}
     a = _List[a1]
@@ -709,11 +705,9 @@ module NodeListChildManagementTests
     assert_copy(b4, a[4])
   end
-  ###
-  ### ----------------------------------------------------------------
-  ###                           remove_node
-  ### ----------------------------------------------------------------
-  ###
+  # ------------------------------------------------------------------
+  #                            remove_node
+  # ------------------------------------------------------------------
   def test_remove_one_from_one
     a1 = C::Int.new
@@ -730,12 +724,12 @@ module NodeListChildManagementTests
     a = _List[a1, a2]
     b = _List[b1, b2]
-    ## beginning
+    # beginning
     assert_same(a, a.remove_node(a1))
     check_list(a, a2)
     assert_nil(a1.parent)
-    ## end
+    # end
     assert_same(b, b.remove_node(b2))
     check_list(b, b1)
     assert_nil(b2.parent)
@@ -749,17 +743,17 @@ module NodeListChildManagementTests
     b = _List[b1, b2, b3]
     c = _List[c1, c2, c3]
-    ## beginning
+    # beginning
     assert_same(a, a.remove_node(a1))
     check_list(a, a2, a3)
     assert_nil(a1.parent)
-    ## end
+    # end
     assert_same(b, b.remove_node(b3))
     check_list(b, b1, b2)
     assert_nil(b3.parent)
-    ## middle
+    # middle
     assert_same(c, c.remove_node(c2))
     check_list(c, c1, c3)
     assert_nil(c2.parent)
@@ -774,27 +768,25 @@ module NodeListChildManagementTests
     b = _List[b1, b2, b3, b4]
     c = _List[c1, c2, c3, c4]
-    ## beginning
+    # beginning
     assert_same(a, a.remove_node(a1))
     check_list(a, a2, a3, a4)
     assert_nil(a1.parent)
-    ## end
+    # end
     assert_same(b, b.remove_node(b4))
     check_list(b, b1, b2, b3)
     assert_nil(b4.parent)
-    ## middle
+    # middle
     assert_same(c, c.remove_node(c2))
     check_list(c, c1, c3, c4)
     assert_nil(c2.parent)
   end
-  ###
-  ### ----------------------------------------------------------------
-  ###                           replace_node
-  ### ----------------------------------------------------------------
-  ###
+  # ------------------------------------------------------------------
+  #                            replace_node
+  # ------------------------------------------------------------------
   def test_replace_with_none_in_one
     a1 = C::Int.new
@@ -810,12 +802,12 @@ module NodeListChildManagementTests
     a = _List[a1, a2]
     b = _List[b1, b2]
-    ## beginning
+    # beginning
     assert_same(a, a.replace_node(a1))
     check_list(a, a2)
     assert_nil(a1.parent)
-    ## end
+    # end
     assert_same(b, b.replace_node(b2))
     check_list(b, b1)
     assert_nil(b2.parent)
@@ -829,17 +821,17 @@ module NodeListChildManagementTests
     b = _List[b1, b2, b3]
     c = _List[c1, c2, c3]
-    ## beginning
+    # beginning
     assert_same(a, a.replace_node(a1))
     check_list(a, a2, a3)
     assert_nil(a1.parent)
-    ## end
+    # end
     assert_same(b, b.replace_node(b3))
     check_list(b, b1, b2)
     assert_nil(b3.parent)
-    ## middle
+    # middle
     assert_same(c, c.replace_node(c2))
     check_list(c, c1, c3)
     assert_nil(c2.parent)
@@ -860,12 +852,12 @@ module NodeListChildManagementTests
     a = _List[a1, a2]
     b = _List[b1, b2]
-    ## beginning
+    # beginning
     assert_same(a, a.replace_node(a1, a3))
     check_list(a, a3, a2)
     assert_nil(a1.parent)
-    ## end
+    # end
     assert_same(b, b.replace_node(b2, b3))
     check_list(b, b1, b3)
     assert_nil(b2.parent)
@@ -879,17 +871,17 @@ module NodeListChildManagementTests
     b = _List[b1, b2, b3]
     c = _List[c1, c2, c3]
-    ## beginning
+    # beginning
     assert_same(a, a.replace_node(a1, a4))
     check_list(a, a4, a2, a3)
     assert_nil(a1.parent)
-    ## end
+    # end
     assert_same(b, b.replace_node(b3, b4))
     check_list(b, b1, b2, b4)
     assert_nil(b3.parent)
-    ## middle
+    # middle
     assert_same(c, c.replace_node(c2, c4))
     check_list(c, c1, c4, c3)
     assert_nil(c2.parent)
@@ -910,12 +902,12 @@ module NodeListChildManagementTests
     a = _List[a1, a2]
     b = _List[b1, b2]
-    ## beginning
+    # beginning
     assert_same(a, a.replace_node(a1, a3, a4))
     check_list(a, a3, a4, a2)
     assert_nil(a1.parent)
-    ## end
+    # end
     assert_same(b, b.replace_node(b2, b3, b4))
     check_list(b, b1, b3, b4)
     assert_nil(b2.parent)
@@ -929,17 +921,17 @@ module NodeListChildManagementTests
     b = _List[b1, b2, b3]
     c = _List[c1, c2, c3]
-    ## beginning
+    # beginning
     assert_same(a, a.replace_node(a1, a4, a5))
     check_list(a, a4, a5, a2, a3)
     assert_nil(a1.parent)
-    ## end
+    # end
     assert_same(b, b.replace_node(b3, b4, b5))
     check_list(b, b1, b2, b4, b5)
     assert_nil(b3.parent)
-    ## middle
+    # middle
     assert_same(c, c.replace_node(c2, c4, c5))
     check_list(c, c1, c4, c5, c3)
     assert_nil(c2.parent)
@@ -960,12 +952,12 @@ module NodeListChildManagementTests
     a = _List[a1, a2]
     b = _List[b1, b2]
-    ## beginning
+    # beginning
     assert_same(a, a.replace_node(a1, a3, a4, a5))
     check_list(a, a3, a4, a5, a2)
     assert_nil(a1.parent)
-    ## end
+    # end
     assert_same(b, b.replace_node(b2, b3, b4, b5))
     check_list(b, b1, b3, b4, b5)
     assert_nil(b2.parent)
@@ -979,17 +971,17 @@ module NodeListChildManagementTests
     b = _List[b1, b2, b3]
     c = _List[c1, c2, c3]
-    ## beginning
+    # beginning
     assert_same(a, a.replace_node(a1, a4, a5, a6))
     check_list(a, a4, a5, a6, a2, a3)
     assert_nil(a1.parent)
-    ## end
+    # end
     assert_same(b, b.replace_node(b3, b4, b5, b6))
     check_list(b, b1, b2, b4, b5, b6)
     assert_nil(b3.parent)
-    ## middle
+    # middle
     assert_same(c, c.replace_node(c2, c4, c5, c6))
     check_list(c, c1, c4, c5, c6, c3)
     assert_nil(c2.parent)
@@ -1010,12 +1002,12 @@ module NodeListChildManagementTests
     a = _List[a1, a2]
     b = _List[b1, b2]
-    ## beginning
+    # beginning
     assert_same(a, a.replace_node(a1, a3, a4, a5, a6))
     check_list(a, a3, a4, a5, a6, a2)
     assert_nil(a1.parent)
-    ## end
+    # end
     assert_same(b, b.replace_node(b2, b3, b4, b5, b6))
     check_list(b, b1, b3, b4, b5, b6)
     assert_nil(b2.parent)
@@ -1029,24 +1021,24 @@ module NodeListChildManagementTests
     b = _List[b1, b2, b3]
     c = _List[c1, c2, c3]
-    ## beginning
+    # beginning
     assert_same(a, a.replace_node(a1, a4, a5, a6, a7))
     check_list(a, a4, a5, a6, a7, a2, a3)
     assert_nil(a1.parent)
-    ## end
+    # end
     assert_same(b, b.replace_node(b3, b4, b5, b6, b7))
     check_list(b, b1, b2, b4, b5, b6, b7)
     assert_nil(b3.parent)
-    ## middle
+    # middle
     assert_same(c, c.replace_node(c2, c4, c5, c6, c7))
     check_list(c, c1, c4, c5, c6, c7, c3)
     assert_nil(c2.parent)
   end
   def test_replace_with_attached
-    ## one
+    # one
     a1 = C::Int.new
     a = _List[a1]
     b1 = C::Int.new
@@ -1055,7 +1047,7 @@ module NodeListChildManagementTests
     assert_copy(b1, a[0])
     assert_nil(a1.parent)
-    ## many
+    # many
     a1 = C::Int.new
     a = _List[a1]
     b1, b2, b3, b4 = 4.of{C::Int.new}
@@ -1069,7 +1061,7 @@ module NodeListChildManagementTests
   end
   def test_replace_with_duplicated
-    ## one
+    # one
     a1, a2 = 2.of{C::Int.new}
     a = _List[a1]
     assert_same(a, a.replace_node(a1, a2, a2))
@@ -1077,7 +1069,7 @@ module NodeListChildManagementTests
     assert_same(a2, a[0])
     assert_copy(a2, a[1])
-    ## many
+    # many
     a1, a2, a3, a4 = 4.of{C::Int.new}
     a = _List[a1, a2, a3]
     assert_same(a, a.replace_node(a1, a2, a4, a2, a4))
@@ -1091,13 +1083,13 @@ module NodeListChildManagementTests
   end
   def test_replace_with_replaced
-    ## one
+    # one
     a1 = C::Int.new
     a = _List[a1]
     assert_same(a, a.replace_node(a1, a1))
     assert_same_list([a1], a)
-    ## many -- some are the replaced node
+    # many -- some are the replaced node
     a1, a2, a3 = 3.of{C::Int.new}
     a = _List[a1]
     assert_same(a, a.replace_node(a1, a1, a2, a3, a1))
@@ -1107,7 +1099,7 @@ module NodeListChildManagementTests
     assert_same(a3, a[2])
     assert_copy(a1, a[3])
-    ## many -- all are the replaced node
+    # many -- all are the replaced node
     a1 = C::Int.new
     a = _List[a1]
     assert_same(a, a.replace_node(a1, a1, a1, a1))
@@ -1120,18 +1112,17 @@ end
 module NodeListArrayQueryTests
   include NodeListTest
-  ###
-  ### ----------------------------------------------------------------
-  ###                           first, last
-  ### ----------------------------------------------------------------
-  ###
+  # ------------------------------------------------------------------
+  #                            first, last
+  # ------------------------------------------------------------------
   def test_first
-    ## empty
+    # empty
     a = _List[]
     assert_nil(a.first)
-    ## one
+    # one
     a1 = C::Int.new
     a = _List[a1]
     assert_same(a1, a.first)
@@ -1139,7 +1130,7 @@ module NodeListArrayQueryTests
     assert_same_list([a1], a.first(1))
     assert_same_list([a1], a.first(2))
-    ## two
+    # two
     a1, a2 = 2.of{C::Int.new}
     a = _List[a1, a2]
     assert_same(a1, a.first)
@@ -1148,7 +1139,7 @@ module NodeListArrayQueryTests
     assert_same_list([a1, a2], a.first(2))
     assert_same_list([a1, a2], a.first(3))
-    ## three
+    # three
     ret = a.first(3)
     a1, a2, a3 = 3.of{C::Int.new}
     a = _List[a1, a2, a3]
@@ -1159,16 +1150,16 @@ module NodeListArrayQueryTests
     assert_same_list([a1, a2, a3], a.first(3))
     assert_same_list([a1, a2, a3], a.first(4))
-    ## negative array size
+    # negative array size
     assert_raise(ArgumentError){a.first(-1)}
   end
   def test_last
-    ## empty
+    # empty
     a = _List[]
     assert_nil(a.last)
-    ## one
+    # one
     a1 = C::Int.new
     a = _List[a1]
     assert_same(a1, a.last)
@@ -1176,7 +1167,7 @@ module NodeListArrayQueryTests
     assert_same_list([a1], a.last(1))
     assert_same_list([a1], a.last(2))
-    ## two
+    # two
     a1, a2 = 2.of{C::Int.new}
     a = _List[a1, a2]
     assert_same(a2, a.last)
@@ -1185,7 +1176,7 @@ module NodeListArrayQueryTests
     assert_same_list([a1, a2], a.last(2))
     assert_same_list([a1, a2], a.last(3))
-    ## three
+    # three
     ret = a.last(3)
     a1, a2, a3 = 3.of{C::Int.new}
     a = _List[a1, a2, a3]
@@ -1196,15 +1187,13 @@ module NodeListArrayQueryTests
     assert_same_list([a1, a2, a3], a.last(3))
     assert_same_list([a1, a2, a3], a.last(4))
-    ## negative array size
+    # negative array size
     assert_raise(ArgumentError){a.last(-1)}
   end
-  ###
-  ### ----------------------------------------------------------------
-  ###                              empty?
-  ### ----------------------------------------------------------------
-  ###
+  # ------------------------------------------------------------------
+  #                               empty?
+  # ------------------------------------------------------------------
   def test_empty
     assert(_List[].empty?)
@@ -1212,104 +1201,100 @@ module NodeListArrayQueryTests
     assert(!_List[_List[]].empty?)
   end
-  ###
-  ### ----------------------------------------------------------------
-  ###                               to_a
-  ### ----------------------------------------------------------------
-  ###
+  # ------------------------------------------------------------------
+  #                                to_a
+  # ------------------------------------------------------------------
   def test_to_a
-    ## empty
+    # empty
     r = empty.to_a
     assert_same(::Array, r.class)
     assert_same_list([], r)
-    ## one
-    a = *one_els
+    # one
+    a, = *one_els
     r = one.to_a
     assert_same(::Array, r.class)
     assert_same_list([a], r)
-    ## two
+    # two
     a, b = *two_els
     r = two.to_a
     assert_same(::Array, r.class)
     assert_same_list([a, b], r)
-    ## three
+    # three
     a, b, c = *three_els
     r = three.to_a
     assert_same(::Array, r.class)
     assert_same_list([a, b, c], r)
-    ## four
+    # four
     a, b, c, d = *four_els
     r = four.to_a
     assert_same(::Array, r.class)
     assert_same_list([a, b, c, d], r)
-    ## two_by_four
+    # two_by_four
     l0, l1, l2, l3, a, b, c, d, e, f, g, h = *two_by_four_els
     r = two_by_four.to_a
     assert_same(::Array, r.class)
     assert_same_list([l0, l1, l2, l3], r)
-    ## big
+    # big
     l1, l2, l21, l22, l23, l230, a, b, c, d, e = *big_els
     r = big.to_a
     assert_same(::Array, r.class)
     assert_same_list([a, l1, l2], r)
   end
-  ###
-  ### ----------------------------------------------------------------
-  ###                          index, rindex
-  ### ----------------------------------------------------------------
-  ###
+  # ------------------------------------------------------------------
+  #                           index, rindex
+  # ------------------------------------------------------------------
   def test_index
-    ## empty
+    # empty
     empty = _List[]
     assert_nil(empty.index(C::Int.new))
     assert_nil(empty.index(nil))
-    ##
+    #
     assert_nil(empty.rindex(C::Int.new))
     assert_nil(empty.rindex(nil))
-    ## one
+    # one
     a = C::Int.new(1)
     list = _List[a]
-    ##
+    #
     assert_equal(0, list.index(a))
     assert_equal(0, list.index(C::Int.new(1)))
     assert_nil(list.index(C::Int.new))
     assert_nil(list.index(nil))
-    ##
+    #
     assert_equal(0, list.rindex(a))
     assert_nil(list.rindex(C::Int.new))
     assert_nil(list.rindex(nil))
-    ## two
+    # two
     a = C::Int.new(1)
     b = C::Int.new(2)
     list = _List[a, b]
-    ##
+    #
     assert_equal(0, list.index(a))
     assert_equal(1, list.index(b))
     assert_nil(list.index(C::Int.new))
     assert_nil(list.index(nil))
-    ##
+    #
     assert_equal(0, list.rindex(a))
     assert_equal(1, list.rindex(b))
     assert_nil(list.rindex(C::Int.new))
     assert_nil(list.rindex(nil))
-    ## nested -- [a, [b]]
+    # nested -- [a, [b]]
     a = C::Int.new(1)
     b = C::Int.new(2)
     l1 = _List[b]
     list = _List[a, l1]
-    ##
+    #
     assert_equal(0, list.index(a))
     assert_equal(1, list.index(l1))
     assert_equal(1, list.index(_List[C::Int.new(2)]))
@@ -1317,7 +1302,7 @@ module NodeListArrayQueryTests
     assert_nil(list.index([a]))
     assert_nil(list.index(C::Int.new))
     assert_nil(list.index(nil))
-    ##
+    #
     assert_equal(0, list.rindex(a))
     assert_equal(1, list.rindex(l1))
     assert_equal(1, list.rindex(_List[b]))
@@ -1325,11 +1310,11 @@ module NodeListArrayQueryTests
     assert_nil(list.rindex(C::Int.new))
     assert_nil(list.rindex(nil))
-    ## repeated
+    # repeated
     a1, a2, a3 = 3.of{C::Int.new(-1)}
     b1, b2, b3 = 3.of{C::Int.new(1)}
     list = _List[a1, b1, a2, b2, a3, b3]
-    ##
+    #
     assert_equal(0, list.index(a1))
     assert_equal(0, list.index(a2))
     assert_equal(0, list.index(a3))
@@ -1338,7 +1323,7 @@ module NodeListArrayQueryTests
     assert_equal(1, list.index(b3))
     assert_nil(list.index(C::Int.new))
     assert_nil(list.index(nil))
-    ##
+    #
     assert_equal(4, list.rindex(a1))
     assert_equal(4, list.rindex(a2))
     assert_equal(4, list.rindex(a3))
@@ -1349,26 +1334,24 @@ module NodeListArrayQueryTests
     assert_nil(list.rindex(nil))
   end
-  ###
-  ### ----------------------------------------------------------------
-  ###                            values_at
-  ### ----------------------------------------------------------------
-  ###
+  # ------------------------------------------------------------------
+  #                             values_at
+  # ------------------------------------------------------------------
   def test_values_at
-    ## empty
+    # empty
     assert_same_list([], empty.values_at())
     assert_same_list([nil], empty.values_at(1))
     assert_same_list([nil], empty.values_at(-1))
-    ## one
-    a = *one_els
+    # one
+    a, = *one_els
     assert_same_list([], one.values_at())
     assert_same_list([a], one.values_at(0))
     assert_same_list([a], one.values_at(-1))
     assert_same_list([nil, a], one.values_at(1, -1))
-    ## big -- [a, [b,c], [d, [e], [], [[]]]]
+    # big -- [a, [b,c], [d, [e], [], [[]]]]
     l1, l2, l21, l22, l23, l230, a, b, c, d, e = *big_els
     assert_same_list([], big.values_at())
     assert_same_list([l2], big.values_at(-1))
@@ -1376,14 +1359,12 @@ module NodeListArrayQueryTests
     assert_same_list([a, l1, l2], big.values_at(0, -2, -1))
   end
-  ###
-  ### ----------------------------------------------------------------
-  ###                               join
-  ### ----------------------------------------------------------------
-  ###
+  # ------------------------------------------------------------------
+  #                                join
+  # ------------------------------------------------------------------
   class N < C::Node
-    def initialize s
+    def initialize(s)
       @s = s
     end
     def to_s
@@ -1391,25 +1372,25 @@ module NodeListArrayQueryTests
     end
   end
   def test_join
-    ## empty
+    # empty
     list = _List[]
     assert_equal('', list.join)
     assert_equal('', list.join('.'))
-    ## one
+    # one
     a = N.new('a')
     list = _List[a]
     assert_equal('a', list.join)
     assert_equal('a', list.join('.'))
-    ## two
+    # two
     a = N.new('a')
     b = N.new('b')
     list = _List[a, b]
     assert_equal('ab', list.join)
     assert_equal('a.b', list.join('.'))
-    ## two_by_two
+    # two_by_two
     a = N.new('a')
     b = N.new('b')
     c = N.new('c')
@@ -1425,24 +1406,24 @@ end
 module NodeListModifierTests
   include NodeListTest
   def test_push_none
-    ## empty
+    # empty
     list = _List[]
     assert_same(list, list.push)
     assert_same_list([], list)
-    ## one
+    # one
     a = C::Int.new
     list = _List[a]
     assert_same(list, list.push)
     assert_same_list([a], list)
-    ## two
+    # two
     a, b = 2.of{C::Int.new}
     list = _List[a, b]
     assert_same(list, list.push)
     assert_same_list([a, b], list)
-    ## three
+    # three
     a, b, c = 3.of{C::Int.new}
     list = _List[a, b, c]
     assert_same(list, list.push)
@@ -1450,25 +1431,25 @@ module NodeListModifierTests
   end
   def test_push_one
-    ## empty
+    # empty
     a = C::Int.new
     list = _List[]
     assert_same(list, list.push(a))
     assert_same_list([a], list)
-    ## one
+    # one
     a, b = 2.of{C::Int.new}
     list = _List[a]
     assert_same(list, list.push(b))
     assert_same_list([a, b], list)
-    ## two
+    # two
     a, b, c = 3.of{C::Int.new}
     list = _List[a, b]
     assert_same(list, list.push(c))
     assert_same_list([a, b, c], list)
-    ## three
+    # three
     a, b, c, d = 4.of{C::Int.new}
     list = _List[a, b, c]
     assert_same(list, list.push(d))
@@ -1476,25 +1457,25 @@ module NodeListModifierTests
   end
   def test_push_two
-    ## empty
+    # empty
     a, b = 2.of{C::Int.new}
     list = _List[]
     assert_same(list, list.push(a, b))
     assert_same_list([a, b], list)
-    ## one
+    # one
     a, b, c = 3.of{C::Int.new}
     list = _List[a]
     assert_same(list, list.push(b, c))
     assert_same_list([a, b, c], list)
-    ## two
+    # two
     a, b, c, d = 4.of{C::Int.new}
     list = _List[a, b]
     assert_same(list, list.push(c, d))
     assert_same_list([a, b, c, d], list)
-    ## three
+    # three
     a, b, c, d, e = 5.of{C::Int.new}
     list = _List[a, b, c]
     assert_same(list, list.push(d, e))
@@ -1502,25 +1483,25 @@ module NodeListModifierTests
   end
   def test_push_three
-    ## empty
+    # empty
     a, b, c = 3.of{C::Int.new}
     list = _List[]
     assert_same(list, list.push(a, b, c))
     assert_same_list([a, b, c], list)
-    ## one
+    # one
     a, b, c, d = 4.of{C::Int.new}
     list = _List[a]
     assert_same(list, list.push(b, c, d))
     assert_same_list([a, b, c, d], list)
-    ## two
+    # two
     a, b, c, d, e = 5.of{C::Int.new}
     list = _List[a, b]
     assert_same(list, list.push(c, d, e))
     assert_same_list([a, b, c, d, e], list)
-    ## three
+    # three
     a, b, c, d, e, f = 6.of{C::Int.new}
     list = _List[a, b, c]
     assert_same(list, list.push(d, e, f))
@@ -1528,7 +1509,7 @@ module NodeListModifierTests
   end
   def test_push_attached
-    ## one
+    # one
     a1 = C::Int.new
     b1 = C::Int.new
     a = _List[a1]
@@ -1539,7 +1520,7 @@ module NodeListModifierTests
     assert_same(a1, a[0])
     assert_copy(b1, a[1])
-    ## many
+    # many
     a1 = C::Int.new
     b1, b2, b3, b4 = 4.of{C::Int.new}
     a = _List[a1]
@@ -1555,24 +1536,24 @@ module NodeListModifierTests
   end
   def test_unshift_none
-    ## empty
+    # empty
     list = _List[]
     assert_same(list, list.unshift)
     assert_same_list([], list)
-    ## one
+    # one
     a = C::Int.new
     list = _List[a]
     assert_same(list, list.unshift)
     assert_same_list([a], list)
-    ## two
+    # two
     a, b = 2.of{C::Int.new}
     list = _List[a, b]
     assert_same(list, list.unshift)
     assert_same_list([a, b], list)
-    ## three
+    # three
     a, b, c = 3.of{C::Int.new}
     list = _List[a, b, c]
     assert_same(list, list.unshift)
@@ -1580,25 +1561,25 @@ module NodeListModifierTests
   end
   def test_unshift_one
-    ## empty
+    # empty
     a = C::Int.new
     list = _List[]
     assert_same(list, list.unshift(a))
     assert_same_list([a], list)
-    ## one
+    # one
     a, b = 2.of{C::Int.new}
     list = _List[a]
     assert_same(list, list.unshift(b))
     assert_same_list([b, a], list)
-    ## two
+    # two
     a, b, c = 3.of{C::Int.new}
     list = _List[a, b]
     assert_same(list, list.unshift(c))
     assert_same_list([c, a, b], list)
-    ## three
+    # three
     a, b, c, d = 4.of{C::Int.new}
     list = _List[a, b, c]
     assert_same(list, list.unshift(d))
@@ -1606,25 +1587,25 @@ module NodeListModifierTests
   end
   def test_unshift_two
-    ## empty
+    # empty
     a, b = 2.of{C::Int.new}
     list = _List[]
     assert_same(list, list.unshift(a, b))
     assert_same_list([a, b], list)
-    ## one
+    # one
     a, b, c = 3.of{C::Int.new}
     list = _List[a]
     assert_same(list, list.unshift(b, c))
     assert_same_list([b, c, a], list)
-    ## two
+    # two
     a, b, c, d = 4.of{C::Int.new}
     list = _List[a, b]
     assert_same(list, list.unshift(c, d))
     assert_same_list([c, d, a, b], list)
-    ## three
+    # three
     a, b, c, d, e = 5.of{C::Int.new}
     list = _List[a, b, c]
     assert_same(list, list.unshift(d, e))
@@ -1632,25 +1613,25 @@ module NodeListModifierTests
   end
   def test_unshift_three
-    ## empty
+    # empty
     a, b, c = 3.of{C::Int.new}
     list = _List[]
     assert_same(list, list.unshift(a, b, c))
     assert_same_list([a, b, c], list)
-    ## one
+    # one
     a, b, c, d = 4.of{C::Int.new}
     list = _List[a]
     assert_same(list, list.unshift(b, c, d))
     assert_same_list([b, c, d, a], list)
-    ## two
+    # two
     a, b, c, d, e = 5.of{C::Int.new}
     list = _List[a, b]
     assert_same(list, list.unshift(c, d, e))
     assert_same_list([c, d, e, a, b], list)
-    ## three
+    # three
     a, b, c, d, e, f = 6.of{C::Int.new}
     list = _List[a, b, c]
     assert_same(list, list.unshift(d, e, f))
@@ -1658,7 +1639,7 @@ module NodeListModifierTests
   end
   def test_unshift_attached
-    ## one
+    # one
     a1 = C::Int.new
     b1 = C::Int.new
     a = _List[a1]
@@ -1669,7 +1650,7 @@ module NodeListModifierTests
     assert_copy(b1, a[0])
     assert_same(a1, a[1])
-    ## many
+    # many
     a1 = C::Int.new
     b1, b2, b3, b4 = 4.of{C::Int.new}
     a = _List[a1]
@@ -1685,26 +1666,26 @@ module NodeListModifierTests
   end
   def test_pop
-    ## empty
+    # empty
     list = _List[]
     assert_same(nil, list.pop)
     assert_same_list([], list)
-    ## one
+    # one
     a = C::Int.new
     list = _List[a]
     assert_same(a, list.pop)
     assert_same_list([], list)
     assert_nil(a.parent)
-    ## two
+    # two
     a, b = 2.of{C::Int.new}
     list = _List[a, b]
     assert_same(b, list.pop)
     assert_same_list([a], list)
     assert_nil(b.parent)
-    ## three
+    # three
     a, b, c = 3.of{C::Int.new}
     list = _List[a, b, c]
     assert_same(c, list.pop)
@@ -1713,27 +1694,27 @@ module NodeListModifierTests
   end
   def test_pop_none
-    ## empty
+    # empty
     list = _List[]
     ret = list.pop(0)
     assert_same_list([], ret)
     assert_same_list([], list)
-    ## one
+    # one
     a = C::Int.new
     list = _List[a]
     ret = list.pop(0)
     assert_same_list([], ret)
     assert_same_list([a], list)
-    ## two
+    # two
     a, b = 2.of{C::Int.new}
     list = _List[a, b]
     ret = list.pop(0)
     assert_same_list([], ret)
     assert_same_list([a, b], list)
-    ## three
+    # three
     a, b, c = 3.of{C::Int.new}
     list = _List[a, b, c]
     ret = list.pop(0)
@@ -1742,13 +1723,13 @@ module NodeListModifierTests
   end
   def test_pop_one
-    ## empty
+    # empty
     list = _List[]
     ret = list.pop(1)
     assert_same_list([], ret)
     assert_same_list([], list)
-    ## one
+    # one
     a = C::Int.new
     list = _List[a]
     ret = list.pop(1)
@@ -1756,7 +1737,7 @@ module NodeListModifierTests
     assert_same_list([], list)
     assert_nil(a.parent)
-    ## two
+    # two
     a, b = 2.of{C::Int.new}
     list = _List[a, b]
     ret = list.pop(1)
@@ -1764,7 +1745,7 @@ module NodeListModifierTests
     assert_same_list([a], list)
     assert_nil(b.parent)
-    ## three
+    # three
     a, b, c = 3.of{C::Int.new}
     list = _List[a, b, c]
     ret = list.pop(1)
@@ -1774,13 +1755,13 @@ module NodeListModifierTests
   end
   def test_pop_two
-    ## empty
+    # empty
     list = _List[]
     ret = list.pop(2)
     assert_same_list([], ret)
     assert_same_list([], list)
-    ## one
+    # one
     a = C::Int.new
     list = _List[a]
     ret = list.pop(2)
@@ -1788,7 +1769,7 @@ module NodeListModifierTests
     assert_same_list([], list)
     assert_nil(a.parent)
-    ## two
+    # two
     a, b = 2.of{C::Int.new}
     list = _List[a, b]
     ret = list.pop(2)
@@ -1797,7 +1778,7 @@ module NodeListModifierTests
     assert_nil(a.parent)
     assert_nil(b.parent)
-    ## three
+    # three
     a, b, c = 3.of{C::Int.new}
     list = _List[a, b, c]
     ret = list.pop(2)
@@ -1808,7 +1789,7 @@ module NodeListModifierTests
   end
   def test_pop_bad
-    ## too many args
+    # too many args
     a, b = 2.of{C::Int.new}
     list = _List[a, b]
     assert_raise(ArgumentError){list.pop(1, 2)}
@@ -1818,13 +1799,13 @@ module NodeListModifierTests
   end
   def test_shift
-    ## empty
+    # empty
     list = _List[]
     ret = list.shift
     assert_nil(ret)
     assert_same_list([], list)
-    ## one
+    # one
     a = C::Int.new
     list = _List[a]
     ret = list.shift
@@ -1832,7 +1813,7 @@ module NodeListModifierTests
     assert_same_list([], list)
     assert_nil(a.parent)
-    ## two
+    # two
     a, b = 2.of{C::Int.new}
     list = _List[a, b]
     ret = list.shift
@@ -1840,7 +1821,7 @@ module NodeListModifierTests
     assert_same_list([b], list)
     assert_nil(a.parent)
-    ## three
+    # three
     a, b, c = 3.of{C::Int.new}
     list = _List[a, b, c]
     ret = list.shift
@@ -1850,27 +1831,27 @@ module NodeListModifierTests
   end
   def test_shift_none
-    ## empty
+    # empty
     list = _List[]
     ret = list.shift(0)
     assert_same_list([], ret)
     assert_same_list([], list)
-    ## one
+    # one
     a = C::Int.new
     list = _List[a]
     ret = list.shift(0)
     assert_same_list([], ret)
     assert_same_list([a], list)
-    ## two
+    # two
     a, b = 2.of{C::Int.new}
     list = _List[a, b]
     ret = list.shift(0)
     assert_same_list([], ret)
     assert_same_list([a, b], list)
-    ## three
+    # three
     a, b, c = 3.of{C::Int.new}
     list = _List[a, b, c]
     ret = list.shift(0)
@@ -1879,13 +1860,13 @@ module NodeListModifierTests
   end
   def test_shift_one
-    ## empty
+    # empty
     list = _List[]
     ret = list.shift(1)
     assert_same_list([], ret)
     assert_same_list([], list)
-    ## one
+    # one
     a = C::Int.new
     list = _List[a]
     ret = list.shift(1)
@@ -1893,7 +1874,7 @@ module NodeListModifierTests
     assert_same_list([], list)
     assert_nil(a.parent)
-    ## two
+    # two
     a, b = 2.of{C::Int.new}
     list = _List[a, b]
     ret = list.shift(1)
@@ -1901,7 +1882,7 @@ module NodeListModifierTests
     assert_same_list([b], list)
     assert_nil(a.parent)
-    ## three
+    # three
     a, b, c = 3.of{C::Int.new}
     list = _List[a, b, c]
     ret = list.shift(1)
@@ -1911,13 +1892,13 @@ module NodeListModifierTests
   end
   def test_shift_two
-    ## empty
+    # empty
     list = _List[]
     ret = list.shift(2)
     assert_same_list([], ret)
     assert_same_list([], list)
-    ## one
+    # one
     a = C::Int.new
     list = _List[a]
     ret = list.shift(2)
@@ -1925,7 +1906,7 @@ module NodeListModifierTests
     assert_same_list([], list)
     assert_nil(a.parent)
-    ## two
+    # two
     a, b = 2.of{C::Int.new}
     list = _List[a, b]
     ret = list.shift(2)
@@ -1934,7 +1915,7 @@ module NodeListModifierTests
     assert_nil(a.parent)
     assert_nil(b.parent)
-    ## three
+    # three
     a, b, c = 3.of{C::Int.new}
     list = _List[a, b, c]
     ret = list.shift(2)
@@ -1945,7 +1926,7 @@ module NodeListModifierTests
   end
   def test_shift_bad
-    ## too many args
+    # too many args
     a, b = 2.of{C::Int.new}
     list = _List[a, b]
     assert_raise(ArgumentError){list.shift(1, 2)}
@@ -1954,11 +1935,9 @@ module NodeListModifierTests
     assert_same(list, b.parent)
   end
-  ###
-  ### ----------------------------------------------------------------
-  ###                              insert
-  ### ----------------------------------------------------------------
-  ###
+  # ------------------------------------------------------------------
+  #                               insert
+  # ------------------------------------------------------------------
   def test_insert_one_into_one
     a1, a2 = 2.of{C::Int.new}
@@ -1966,11 +1945,11 @@ module NodeListModifierTests
     a = _List[a1]
     b = _List[b1]
-    ## beginning
+    # beginning
     a.insert(0, a2)
     assert_same_list([a2, a1], a)
-    ## end
+    # end
     b.insert(1, b2)
     assert_same_list([b1, b2], b)
   end
@@ -1981,11 +1960,11 @@ module NodeListModifierTests
     a = _List[a1]
     b = _List[b1]
-    ## beginning
+    # beginning
     a.insert(0, a2, a3)
     assert_same_list([a2, a3, a1], a)
-    ## end
+    # end
     b.insert(1, b2, b3)
     assert_same_list([b1, b2, b3], b)
   end
@@ -1996,11 +1975,11 @@ module NodeListModifierTests
     a = _List[a1]
     b = _List[b1]
-    ## beginning
+    # beginning
     a.insert(0, a2, a3, a4)
     assert_same_list([a2, a3, a4, a1], a)
-    ## end
+    # end
     b.insert(1, b2, b3, b4)
     assert_same_list([b1, b2, b3, b4], b)
   end
@@ -2011,16 +1990,16 @@ module NodeListModifierTests
     a = _List[a1]
     b = _List[b1]
-    ## beginning
+    # beginning
     a.insert(0, a2, a3, a4, a5)
     assert_same_list([a2, a3, a4, a5, a1], a)
-    ## end
+    # end
     b.insert(1, b2, b3, b4, b5)
     assert_same_list([b1, b2, b3, b4, b5], b)
   end
-  def insert_one_into_two
+  def test_insert_one_into_two
     a1, a2, a3 = 3.of{C::Int.new}
     b1, b2, b3 = 3.of{C::Int.new}
     c1, c2, c3 = 3.of{C::Int.new}
@@ -2028,16 +2007,16 @@ module NodeListModifierTests
     b = _List[b1, b2]
     c = _List[c1, c2]
-    ## beginning
+    # beginning
     a.insert(0, a3)
     assert_same_list([a3, a1, a2], a)
-    ## end
+    # end
     b.insert(2, b3)
     assert_same_list([b1, b2, b3], b)
-    ## middle
-    c.insert1(c1, c3)
+    # middle
+    c.insert(1, c3)
     assert_same_list([c1, c3, c2], c)
   end
@@ -2050,15 +2029,15 @@ module NodeListModifierTests
     b = _List[b1, b2]
     c = _List[c1, c2]
-    ## beginning
+    # beginning
     a.insert(0, a3, a4)
     assert_same_list([a3, a4, a1, a2], a)
-    ## end
+    # end
     b.insert(2, b3, b4)
     assert_same_list([b1, b2, b3, b4], b)
-    ## middle
+    # middle
     c.insert(1, c3, c4)
     assert_same_list([c1, c3, c4, c2], c)
   end
@@ -2071,15 +2050,15 @@ module NodeListModifierTests
     b = _List[b1, b2]
     c = _List[c1, c2]
-    ## beginning
+    # beginning
     a.insert(0, a3, a4, a5)
     assert_same_list([a3, a4, a5, a1, a2], a)
-    ## end
+    # end
     b.insert(2, b3, b4, b5)
     assert_same_list([b1, b2, b3, b4, b5], b)
-    ## middle
+    # middle
     c.insert(1, c3, c4, c5)
     assert_same_list([c1, c3, c4, c5, c2], c)
   end
@@ -2092,21 +2071,21 @@ module NodeListModifierTests
     b = _List[b1, b2]
     c = _List[c1, c2]
-    ## beginning
+    # beginning
     a.insert(0, a3, a4, a5, a6)
     assert_same_list([a3, a4, a5, a6, a1, a2], a)
-    ## end
+    # end
     b.insert(2, b3, b4, b5, b6)
     assert_same_list([b1, b2, b3, b4, b5, b6], b)
-    ## middle (after)
+    # middle (after)
     c.insert(1, c3, c4, c5, c6)
     assert_same_list([c1, c3, c4, c5, c6, c2], c)
   end
   def test_insert_attached
-    ## one
+    # one
     a1 = C::Int.new
     b1 = C::Int.new
     a = _List[a1]
@@ -2116,7 +2095,7 @@ module NodeListModifierTests
     assert_same(a1, a[0])
     assert_copy(b1, a[1])
-    ## many
+    # many
     a1 = C::Int.new
     b1, b2, b3, b4 = 4.of{C::Int.new}
     a = _List[a1]
@@ -2130,11 +2109,9 @@ module NodeListModifierTests
     assert_same(a1, a[4])
   end
-  ###
-  ### ----------------------------------------------------------------
-  ###                              concat
-  ### ----------------------------------------------------------------
-  ###
+  # ------------------------------------------------------------------
+  #                               concat
+  # ------------------------------------------------------------------
   def test_concat_zero_on_zero
     a = _List[]
@@ -2173,7 +2150,7 @@ module NodeListModifierTests
     assert_same(a, a.concat(b))
     assert_same_list([b1], b)
-    ##
+    #
     assert_equal(1, a.length)
     assert_copy(b1, a[0])
   end
@@ -2186,7 +2163,7 @@ module NodeListModifierTests
     assert_same(a, a.concat(b))
     assert_same_list([b1], b)
-    ##
+    #
     assert_equal(2, a.length)
     assert_same(a1, a[0])
     assert_copy(b1, a[1])
@@ -2200,7 +2177,7 @@ module NodeListModifierTests
     assert_same(a, a.concat(b))
     assert_same_list([b1], b)
-    ##
+    #
     assert_equal(3, a.length)
     assert_same(a1, a[0])
     assert_same(a2, a[1])
@@ -2214,7 +2191,7 @@ module NodeListModifierTests
     assert_same(a, a.concat(b))
     assert_same_list([b1, b2], b)
-    ##
+    #
     assert_equal(2, a.length)
     assert_copy(b1, a[0])
     assert_copy(b2, a[1])
@@ -2228,7 +2205,7 @@ module NodeListModifierTests
     assert_same(a, a.concat(b))
     assert_same_list([b1, b2], b)
-    ##
+    #
     assert_equal(3, a.length)
     assert_same(a1, a[0])
     assert_copy(b1, a[1])
@@ -2243,7 +2220,7 @@ module NodeListModifierTests
     assert_same(a, a.concat(b))
     assert_same_list([b1, b2], b)
-    ##
+    #
     assert_equal(4, a.length)
     assert_same(a1, a[0])
     assert_same(a2, a[1])
@@ -2251,11 +2228,9 @@ module NodeListModifierTests
     assert_copy(b2, a[3])
   end
-  ###
-  ### ----------------------------------------------------------------
-  ###                            delete_at
-  ### ----------------------------------------------------------------
-  ###
+  # ------------------------------------------------------------------
+  #                             delete_at
+  # ------------------------------------------------------------------
   def test_delete_at_one
     a1 = C::Int.new
@@ -2267,14 +2242,14 @@ module NodeListModifierTests
   end
   def test_delete_at_two
-    ## delete_at 0
+    # delete_at 0
     a1, a2 = 2.of{C::Int.new}
     a = _List[a1, a2]
     assert_same(a1, a.delete_at(0))
     assert_nil(a1.parent)
     assert_same_list([a2], a)
-    ## delete_at 1
+    # delete_at 1
     a1, a2 = 2.of{C::Int.new}
     a = _List[a1, a2]
     assert_same(a2, a.delete_at(1))
@@ -2283,21 +2258,21 @@ module NodeListModifierTests
   end
   def test_delete_at_three
-    ## delete at 0
+    # delete at 0
     a1, a2, a3 = 3.of{C::Int.new}
     a = _List[a1, a2, a3]
     assert_same(a1, a.delete_at(0))
     assert_nil(a1.parent)
     assert_same_list([a2, a3], a)
-    ## delete at 1
+    # delete at 1
     a1, a2, a3 = 3.of{C::Int.new}
     a = _List[a1, a2, a3]
     assert_same(a2, a.delete_at(1))
     assert_nil(a2.parent)
     assert_same_list([a1, a3], a)
-    ## delete at 2
+    # delete at 2
     a1, a2, a3 = 3.of{C::Int.new}
     a = _List[a1, a2, a3]
     assert_same(a3, a.delete_at(2))
@@ -2306,7 +2281,7 @@ module NodeListModifierTests
   end
   def test_delete_at_four
-    ## delete at 1
+    # delete at 1
     a1, a2, a3, a4 = 4.of{C::Int.new}
     a = _List[a1, a2, a3, a4]
     assert_same(a2, a.delete_at(1))
@@ -2314,11 +2289,9 @@ module NodeListModifierTests
     assert_same_list([a1, a3, a4], a)
   end
-  ###
-  ### ----------------------------------------------------------------
-  ###                              clear
-  ### ----------------------------------------------------------------
-  ###
+  # ------------------------------------------------------------------
+  #                               clear
+  # ------------------------------------------------------------------
   def test_clear_empty
     assert_same(empty, empty.clear)
@@ -2358,11 +2331,9 @@ module NodeListModifierTests
     assert_nil(l2.parent)
   end
-  ###
-  ### ----------------------------------------------------------------
-  ###                             replace
-  ### ----------------------------------------------------------------
-  ###
+  # ------------------------------------------------------------------
+  #                              replace
+  # ------------------------------------------------------------------
   def test_replace_none_with_none
     a = _List[]
@@ -2458,7 +2429,7 @@ module NodeListModifierTests
   end
   def test_replace_with_attached
-    ## one
+    # one
     a1 = C::Int.new
     a = _List[a1]
     b1 = C::Int.new
@@ -2468,7 +2439,7 @@ module NodeListModifierTests
     assert_equal(1, a.length)
     assert_copy(b1, a[0])
-    ## many
+    # many
     a1 = C::Int.new
     a = _List[a1]
     b1, b2, b3, b4 = 4.of{C::Int.new}
@@ -2483,7 +2454,7 @@ module NodeListModifierTests
   end
 end
-## Make concrete test classes.
+# Make concrete test classes.
 NodeListTest.submodules.each do |test_module|
   test_module.name =~ /^NodeList/ or
     raise "NodeListTest submodule name does not start with 'NodeList': #{test_module.name}"