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

cast 0.0.1 → 0.3.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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