RubyGems - cast - Versions diffs - 0.0.1 → 0.3.1 - Mend

cast 0.0.1 → 0.3.1

Files changed (44) hide show

checksums.yaml +7 -0
data/.gitignore +10 -0
data/CHANGELOG +63 -0
data/Gemfile +9 -0
data/LICENSE +22 -0
data/README.markdown +1924 -0
data/Rakefile +29 -0
data/cast.gemspec +18 -0
data/ext/cast.c +6 -0
data/ext/cast.h +141 -0
data/ext/extconf.rb +2 -0
data/ext/parser.c +287 -0
data/ext/yylex.re +340 -0
data/lib/cast.rb +11 -9
data/lib/cast/c.y +904 -0
data/lib/{c_nodes.rb → cast/c_nodes.rb} +188 -392
data/lib/{to_debug.rb → cast/inspect.rb} +18 -20
data/lib/cast/node.rb +741 -0
data/lib/{node_list.rb → cast/node_list.rb} +175 -176
data/lib/{parse.rb → cast/parse.rb} +86 -65
data/lib/cast/preprocessor.rb +59 -0
data/lib/cast/tempfile.rb +33 -0
data/lib/{to_s.rb → cast/to_s.rb} +133 -80
data/lib/cast/version.rb +11 -0
data/test/c_nodes_test.rb +224 -0
data/test/lexer_test.rb +335 -0
data/test/{test_node_list.rb → node_list_test.rb} +401 -413
data/test/{test_node.rb → node_test.rb} +186 -214
data/test/parse_test.rb +2068 -0
data/test/{test_parser.rb → parser_test.rb} +145 -58
data/test/preprocessor_test.rb +85 -0
data/test/render_test.rb +2116 -0
data/test/test_helper.rb +198 -0
metadata +83 -52
data/README +0 -6
data/doc/index.html +0 -2513
data/install.rb +0 -14
data/lib/c.tab.rb +0 -3433
data/lib/c.y +0 -935
data/lib/node.rb +0 -744
data/test/common.rb +0 -174
data/test/run.rb +0 -5
data/test/test_c_nodes.rb +0 -160
data/test/test_parse.rb +0 -2014

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

@@ -1,53 +1,50 @@
-require 'common'
-require 'stringio'
-###
-### ##################################################################
-###
-### 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_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]
@@ -56,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]
@@ -99,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]
@@ -188,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]
@@ -203,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]
@@ -220,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]
@@ -236,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 refute_eq(a, b)
     assert(!(a == b))
     assert(!a.eql?(b))
   end
@@ -259,38 +256,38 @@ module NodeListEqualTest
     assert_eq(two_by_four, two_by_four)
     assert_eq(big, big)
-    assert_not_eq(empty, one)
-    assert_not_eq(one, empty)
-    assert_not_eq(one, two)
-    assert_not_eq(two, one)
-    assert_not_eq(two, three)
-    assert_not_eq(three, two)
+    refute_eq(empty, one)
+    refute_eq(one, empty)
+    refute_eq(one, two)
+    refute_eq(two, one)
+    refute_eq(two, three)
+    refute_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]
@@ -299,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]
@@ -314,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
@@ -327,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?
@@ -358,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?
@@ -382,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)
@@ -394,79 +390,78 @@ 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))
-    assert_raise(ArgumentError, list.remove_node(node))
-    assert_raise(ArgumentError, list.insert_after(node, n))
-    assert_raise(ArgumentError, list.insert_before(node, n))
-    assert_raise(ArgumentError, list.replace_node(node, n))
+    assert_raises(ArgumentError, list.node_before(node))
+    assert_raises(ArgumentError, list.node_after(node))
+    assert_raises(ArgumentError, list.remove_node(node))
+    assert_raises(ArgumentError, list.insert_after(node, n))
+    assert_raises(ArgumentError, list.insert_before(node, n))
+    assert_raises(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)
@@ -479,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}
@@ -498,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
@@ -513,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
@@ -528,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
@@ -543,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}
@@ -562,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
@@ -589,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
@@ -616,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
@@ -643,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]
@@ -672,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]
@@ -683,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]
@@ -697,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]
@@ -712,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
@@ -733,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)
@@ -752,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)
@@ -777,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
@@ -813,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)
@@ -832,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)
@@ -863,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)
@@ -882,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)
@@ -913,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)
@@ -932,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)
@@ -963,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)
@@ -982,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)
@@ -1013,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)
@@ -1032,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
@@ -1058,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}
@@ -1072,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))
@@ -1080,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))
@@ -1094,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))
@@ -1110,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))
@@ -1123,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)
@@ -1142,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)
@@ -1151,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]
@@ -1162,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
-    assert_raise(ArgumentError){a.first(-1)}
+    # negative array size
+    assert_raises(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)
@@ -1179,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)
@@ -1188,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]
@@ -1199,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
-    assert_raise(ArgumentError){a.last(-1)}
+    # negative array size
+    assert_raises(ArgumentError){a.last(-1)}
   end
-  ###
-  ### ----------------------------------------------------------------
-  ###                              empty?
-  ### ----------------------------------------------------------------
-  ###
+  # ------------------------------------------------------------------
+  #                               empty?
+  # ------------------------------------------------------------------
   def test_empty
     assert(_List[].empty?)
@@ -1215,112 +1201,108 @@ 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)]))
-    assert_equal(nil, list.index([b]))
+    assert_nil(list.index([b]))
     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]))
@@ -1328,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))
@@ -1341,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))
@@ -1352,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))
@@ -1379,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
@@ -1394,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')
@@ -1428,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)
@@ -1453,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))
@@ -1479,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))
@@ -1505,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))
@@ -1531,7 +1509,7 @@ module NodeListModifierTests
   end
   def test_push_attached
-    ## one
+    # one
     a1 = C::Int.new
     b1 = C::Int.new
     a = _List[a1]
@@ -1542,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]
@@ -1558,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)
@@ -1583,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))
@@ -1609,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))
@@ -1635,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))
@@ -1661,7 +1639,7 @@ module NodeListModifierTests
   end
   def test_unshift_attached
-    ## one
+    # one
     a1 = C::Int.new
     b1 = C::Int.new
     a = _List[a1]
@@ -1672,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]
@@ -1688,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)
@@ -1716,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)
@@ -1745,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)
@@ -1759,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)
@@ -1767,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)
@@ -1777,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)
@@ -1791,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)
@@ -1800,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)
@@ -1810,14 +1788,24 @@ module NodeListModifierTests
     assert_nil(c.parent)
   end
+  def test_pop_bad
+    # too many args
+    a, b = 2.of{C::Int.new}
+    list = _List[a, b]
+    assert_raises(ArgumentError){list.pop(1, 2)}
+    assert_same_list([a, b], list)
+    assert_same(list, a.parent)
+    assert_same(list, b.parent)
+  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
@@ -1825,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
@@ -1833,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
@@ -1843,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)
@@ -1872,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)
@@ -1886,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)
@@ -1894,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)
@@ -1904,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)
@@ -1918,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)
@@ -1927,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)
@@ -1937,11 +1925,19 @@ module NodeListModifierTests
     assert_nil(b.parent)
   end
-  ###
-  ### ----------------------------------------------------------------
-  ###                              insert
-  ### ----------------------------------------------------------------
-  ###
+  def test_shift_bad
+    # too many args
+    a, b = 2.of{C::Int.new}
+    list = _List[a, b]
+    assert_raises(ArgumentError){list.shift(1, 2)}
+    assert_same_list([a, b], list)
+    assert_same(list, a.parent)
+    assert_same(list, b.parent)
+  end
+  # ------------------------------------------------------------------
+  #                               insert
+  # ------------------------------------------------------------------
   def test_insert_one_into_one
     a1, a2 = 2.of{C::Int.new}
@@ -1949,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
@@ -1964,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
@@ -1979,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
@@ -1994,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}
@@ -2011,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
@@ -2033,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
@@ -2054,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
@@ -2075,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]
@@ -2099,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]
@@ -2113,11 +2109,9 @@ module NodeListModifierTests
     assert_same(a1, a[4])
   end
-  ###
-  ### ----------------------------------------------------------------
-  ###                              concat
-  ### ----------------------------------------------------------------
-  ###
+  # ------------------------------------------------------------------
+  #                               concat
+  # ------------------------------------------------------------------
   def test_concat_zero_on_zero
     a = _List[]
@@ -2156,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
@@ -2169,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])
@@ -2183,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])
@@ -2197,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])
@@ -2211,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])
@@ -2226,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])
@@ -2234,11 +2228,9 @@ module NodeListModifierTests
     assert_copy(b2, a[3])
   end
-  ###
-  ### ----------------------------------------------------------------
-  ###                            delete_at
-  ### ----------------------------------------------------------------
-  ###
+  # ------------------------------------------------------------------
+  #                             delete_at
+  # ------------------------------------------------------------------
   def test_delete_at_one
     a1 = C::Int.new
@@ -2250,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))
@@ -2266,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))
@@ -2289,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))
@@ -2297,11 +2289,9 @@ module NodeListModifierTests
     assert_same_list([a1, a3, a4], a)
   end
-  ###
-  ### ----------------------------------------------------------------
-  ###                              clear
-  ### ----------------------------------------------------------------
-  ###
+  # ------------------------------------------------------------------
+  #                               clear
+  # ------------------------------------------------------------------
   def test_clear_empty
     assert_same(empty, empty.clear)
@@ -2341,11 +2331,9 @@ module NodeListModifierTests
     assert_nil(l2.parent)
   end
-  ###
-  ### ----------------------------------------------------------------
-  ###                             replace
-  ### ----------------------------------------------------------------
-  ###
+  # ------------------------------------------------------------------
+  #                              replace
+  # ------------------------------------------------------------------
   def test_replace_none_with_none
     a = _List[]
@@ -2441,7 +2429,7 @@ module NodeListModifierTests
   end
   def test_replace_with_attached
-    ## one
+    # one
     a1 = C::Int.new
     a = _List[a1]
     b1 = C::Int.new
@@ -2451,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}
@@ -2466,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}"
@@ -2474,7 +2462,7 @@ NodeListTest.submodules.each do |test_module|
   %w[NodeArray NodeChain].each do |list_class|
     test_class = test_module.name.sub(/^NodeList/, list_class)
     eval "
-      class #{test_class} < Test::Unit::TestCase
+      class #{test_class} < Minitest::Test
         def _List
           C::#{list_class}
         end