cast 0.0.1 → 0.3.1

data/test/{test_node.rb → node_test.rb}

@@ -1,26 +1,16 @@
-###
-### ##################################################################
-###
-### Tests for Node core functionality.
-###
-### ##################################################################
-###
-
-require 'common'
-require 'stringio'
-
-require 'pp'
-class C::Node
-  def pretty_print q
-    q.text self.to_debug
-  end
-end
+######################################################################
+#
+# Tests for Node core functionality.
+#
+######################################################################
+
+require 'test_helper'
 
 Chain = C::NodeChain
 
-###
-### Some Node classes.
-###
+#
+# Some Node classes.
+#
 class X < C::Node
   child :a
   initializer :a
@@ -48,12 +38,11 @@ class V < C::Node
   initializer :a
 end
 
-class NodeInitializeTest < Test::Unit::TestCase
-  ###
-  ### ----------------------------------------------------------------
-  ###                            initialize
-  ### ----------------------------------------------------------------
-  ###
+class NodeInitializeTest < Minitest::Test
+
+  # ------------------------------------------------------------------
+  #                             initialize
+  # ------------------------------------------------------------------
 
   def test_initialize_w
     w = W.new
@@ -92,11 +81,10 @@ class NodeInitializeTest < Test::Unit::TestCase
     assert_same(x2, z.b)
   end
 
-  ###
-  ### ----------------------------------------------------------------
-  ###                           Node.new_at
-  ### ----------------------------------------------------------------
-  ###
+  # ------------------------------------------------------------------
+  #                            Node.new_at
+  # ------------------------------------------------------------------
+
   def test_new_at
     pos = C::Node::Pos.new('somefile', 5, 10)
     xa = X.new
@@ -106,7 +94,7 @@ class NodeInitializeTest < Test::Unit::TestCase
   end
 end
 
-class NodeEqualTest < Test::Unit::TestCase
+class NodeEqualTest < Minitest::Test
   def str
     "(struct s){.a = 1, [2] = {3, 4}, .b [5] = 6, 7}"
   end
@@ -120,7 +108,7 @@ class NodeEqualTest < Test::Unit::TestCase
     five  = C::IntLiteral.new(5)
     six   = C::IntLiteral.new(6)
     seven = C::IntLiteral.new(7)
-    
+
     mi0 = C::MemberInit.new(Chain[ma], one)
     mi10 = C::MemberInit.new(nil, three)
     mi11 = C::MemberInit.new(nil, four)
@@ -134,59 +122,58 @@ class NodeEqualTest < Test::Unit::TestCase
     return c
   end
 
-  ###
-  ### ----------------------------------------------------------------
-  ###                            ==, eql?
-  ### ----------------------------------------------------------------
-  ###
+  # ------------------------------------------------------------------
+  #                              ==, eql?
+  # ------------------------------------------------------------------
+
   def test_eq
-    ## copy should be equal
+    # copy should be equal
     assert_equal(node, node)
     assert(node.eql?(node))
 
-    ## change any one field and it should be not_equal
+    # change any one field and it should be not_equal
     n = node
     n.type = nil
-    assert_not_equal(node, n)
+    refute_equal(node, n)
     assert(!node.eql?(n))
 
     n = node
     n.member_inits[0].member[0] = C::Member.new('c')
-    assert_not_equal(node, n)
+    refute_equal(node, n)
     assert(!node.eql?(n))
     copy = node.dup
 
     n = node
     n.member_inits[2].member[1] = C::IntLiteral.new(8)
-    assert_not_equal(node, n)
+    refute_equal(node, n)
     assert(!node.eql?(n))
 
-    ## add a member's init and it should be not_equal
+    # add a member's init and it should be not_equal
     n = node
     n.member_inits[3].init = C::IntLiteral.new(9)
-    assert_not_equal(node, n)
+    refute_equal(node, n)
     assert(!node.eql?(n))
 
-    ## change a member's init and it should be not_equal
+    # change a member's init and it should be not_equal
     n = node
     n.member_inits[0].init = C::IntLiteral.new(10)
-    assert_not_equal(node, n)
+    refute_equal(node, n)
     assert(!node.eql?(n))
 
-    ## add a member specifier and it should be not_equal
+    # add a member specifier and it should be not_equal
     n = node
     n.member_inits[3].member = Chain[C::Member.new('d')]
-    assert_not_equal(node, n)
+    refute_equal(node, n)
     assert(!node.eql?(n))
 
-    ## pop a member and it should be not_equal
+    # pop a member and it should be not_equal
     n = node
     n.member_inits.pop
-    assert_not_equal(node, n)
+    refute_equal(node, n)
     assert(!node.eql?(n))
 
-    ## assign a field a copy of what's there and it should still be
-    ## equal
+    # assign a field a copy of what's there and it should still be
+    # equal
     n = node
     n.member_inits[0].member[0] = C::Member.new('a')
     assert_equal(node, n)
@@ -198,17 +185,16 @@ class NodeEqualTest < Test::Unit::TestCase
     assert(node.eql?(n))
   end
 
-  ###
-  ### ----------------------------------------------------------------
-  ###                               hash
-  ### ----------------------------------------------------------------
-  ###
+  # ------------------------------------------------------------------
+  #                                hash
+  # ------------------------------------------------------------------
+
   def test_hash
-    ## copy should be equal
+    # copy should be equal
     assert_equal(node.hash, node.hash)
 
-    ## should be equal after assigning to a field a copy of what's
-    ## there
+    # should be equal after assigning to a field a copy of what's
+    # there
     n = node
     n.member_inits[0].member[0] = C::Member.new('a')
     assert_equal(node.hash, n.hash)
@@ -219,11 +205,9 @@ class NodeEqualTest < Test::Unit::TestCase
   end
 end
 
-class NodeCopyTest < Test::Unit::TestCase
+class NodeCopyTest < Minitest::Test
   def setup
-    ## (struct s){.a = 1, [2] = {3, 4}, .b [5] = 6, 7}
-
-
+    # (struct s){.a = 1, [2] = {3, 4}, .b [5] = 6, 7}
 
     @c_t_n = 's'
     @c_t   = C::Struct.new(@c_t_n)
@@ -273,11 +257,10 @@ class NodeCopyTest < Test::Unit::TestCase
   end
   attr_accessor :c, :d, :e
 
-  ###
-  ### ----------------------------------------------------------------
-  ###                            dup, clone
-  ### ----------------------------------------------------------------
-  ###
+  # ------------------------------------------------------------------
+  #                             dup, clone
+  # ------------------------------------------------------------------
+
   def check_node value
     cres = yield(c)
     dres = yield(d)
@@ -290,20 +273,20 @@ class NodeCopyTest < Test::Unit::TestCase
       assert_same(value, dres)
       assert_same(value, eres)
     end
-    assert_raise(NoMethodError){dres.new_method}
+    assert_raises(NoMethodError){dres.new_method}
     case value.object_id
     when @c.object_id, @c_mis1_i_mis0.object_id
       assert_same(100, eres.new_method)
     else
-      assert_raise(NoMethodError){eres.new_method}
+      assert_raises(NoMethodError){eres.new_method}
     end
   end
 
   def test_copy
-    ## each element should be equal, but not the same, except for
-    ## immediate values
-    ##
-    ## (struct s){.a = 1, [2] = {3, 4}, .b [5] = 6, 7}
+    # each element should be equal, but not the same, except for
+    # immediate values
+    #
+    # (struct s){.a = 1, [2] = {3, 4}, .b [5] = 6, 7}
     assert_tree(c)
     assert_tree(d)
     assert_tree(e)
@@ -348,14 +331,14 @@ class NodeCopyTest < Test::Unit::TestCase
   end
 end
 
-class NodeWalkTest < Test::Unit::TestCase
-  ###
-  ### Collect and return the args yielded to `node.send(method)' as an
-  ### Array, each element of which is an array of args yielded.
-  ###
-  ### Also, assert that the return value of the method is `exp'.
-  ###
-  def yields method, node, exp
+class NodeWalkTest < Minitest::Test
+  #
+  # Collect and return the args yielded to `node.send(method)' as an
+  # Array, each element of which is an array of args yielded.
+  #
+  # Also, assert that the return value of the method is `exp'.
+  #
+  def yields(method, node, exp)
     ret = []
     out = node.send(method) do |*args|
       ret << args
@@ -365,18 +348,18 @@ class NodeWalkTest < Test::Unit::TestCase
     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?
@@ -404,17 +387,16 @@ class NodeWalkTest < Test::Unit::TestCase
     end
   end
 
-  ###
-  ### ----------------------------------------------------------------
-  ###                 depth_first, reverse_depth_first
-  ### ----------------------------------------------------------------
-  ###
-  def check_depth_firsts node, exp
-    ## depth_first
+  # ------------------------------------------------------------------
+  #                  depth_first, reverse_depth_first
+  # ------------------------------------------------------------------
+
+  def check_depth_firsts(node, exp)
+    # depth_first
     out = yields(:depth_first, node, node)
     assert_equal_yields exp, out
 
-    ## reverse_depth_first
+    # reverse_depth_first
     exp = exp.reverse.map! do |ev, node|
       if ev == :ascending
         [:descending, node]
@@ -427,13 +409,13 @@ class NodeWalkTest < Test::Unit::TestCase
   end
 
   def test_depth_first
-    ## empty node
+    # empty node
     d = C::Int.new
     d.longness = 1
     check_depth_firsts(d,
                        [[:descending, d], [:ascending, d]])
 
-    ## one-storey -- populate both the list child and nonlist child
+    # one-storey -- populate both the list child and nonlist child
     d = C::Declaration.new(C::Int.new)
     d.declarators << C::Declarator.new
     d.declarators[0].name = 'one'
@@ -450,7 +432,7 @@ class NodeWalkTest < Test::Unit::TestCase
                          [:ascending, d]
                        ])
 
-    ## multi-layer
+    # multi-layer
     d.declarators[0].indirect_type = C::Function.new
     d.declarators[0].indirect_type.params = Chain[]
     d.declarators[0].indirect_type.params << C::Parameter.new(C::Int.new, 'i')
@@ -478,8 +460,8 @@ class NodeWalkTest < Test::Unit::TestCase
                        ])
   end
 
-  def check_depth_first_prunes pruned_nodes, node, exp
-    ## depth_first
+  def check_depth_first_prunes(pruned_nodes, node, exp)
+    # depth_first
     out = yields(:depth_first, node, node) do |ev, node|
       if ev.equal? :descending
         if pruned_nodes.any?{|n| n.equal? node}
@@ -488,7 +470,7 @@ class NodeWalkTest < Test::Unit::TestCase
       end
     end
     assert_equal_yields exp, out
-    ##
+    #
     ret = catch :prune do
       node.depth_first do |ev, node|
         throw :prune, :x if ev.equal? :ascending
@@ -497,7 +479,7 @@ class NodeWalkTest < Test::Unit::TestCase
     end
     assert_same(:x, ret)
 
-    ## reverse_depth_first
+    # reverse_depth_first
     exp = exp.reverse.map! do |ev, node|
       if ev.equal? :ascending
         [:descending, node]
@@ -513,7 +495,7 @@ class NodeWalkTest < Test::Unit::TestCase
       end
     end
     assert_equal_yields exp, out
-    ##
+    #
     ret = catch :prune do
       node.reverse_depth_first do |ev, node|
         throw :prune, :x if ev.equal? :ascending
@@ -524,13 +506,13 @@ class NodeWalkTest < Test::Unit::TestCase
   end
 
   def test_depth_first_prune
-    ## empty node
+    # empty node
     d = C::Int.new
     d.longness = 1
     check_depth_first_prunes([d], d,
                        [[:descending, d], [:ascending, d]])
 
-    ## one-storey -- populate both the list child and nonlist child
+    # one-storey -- populate both the list child and nonlist child
     d = C::Declaration.new(C::Int.new)
     d.declarators << C::Declarator.new
     d.declarators[0].name = 'one'
@@ -544,7 +526,7 @@ class NodeWalkTest < Test::Unit::TestCase
                          [:ascending, d]
                        ])
 
-    ## multi-layer
+    # multi-layer
     d.type = C::Struct.new('S')
     d.type.members = Chain[]
     d.type.members << C::Declaration.new(C::Int.new)
@@ -567,13 +549,11 @@ class NodeWalkTest < Test::Unit::TestCase
                        ])
   end
 
-  ###
-  ### ----------------------------------------------------------------
-  ###                        each, reverse_each
-  ### ----------------------------------------------------------------
-  ###
+  # ------------------------------------------------------------------
+  #                         each, reverse_each
+  # ------------------------------------------------------------------
 
-  def iter_str iter
+  def iter_str(iter)
     iter.is_a? ::Array or
       raise "iter_str: expected ::Array"
     if iter.empty?
@@ -592,7 +572,7 @@ class NodeWalkTest < Test::Unit::TestCase
       return s.string
     end
   end
-  def check_each node, exp
+  def check_each(node, exp)
     exp.map!{|n| [n]}
 
     out = yields(:each, node, node)
@@ -603,34 +583,31 @@ class NodeWalkTest < Test::Unit::TestCase
     assert_equal_yields exp, out
   end
   def test_each
-    ## empty
+    # empty
     parent = X.new
     check_each(parent, [])
 
-    ## one child
+    # one child
     x1 = X.new
     parent = X.new(x1)
     check_each(parent, [x1])
 
-    ## two children
+    # two children
     x1, x2 = 2.of{X.new}
     parent = Y.new(x1, x2)
     check_each(parent, [x1, x2])
 
-    ## three with some nil and some fields
+    # three with some nil and some fields
     x1, x2, x3, x4, x5 = 5.of{X.new}
     parent = Z.new(x1, x2, nil, x4, x5)
     check_each(parent, [x1, x5])
   end
 
-  ###
-  ### ----------------------------------------------------------------
-  ###                    preorder, reverse_preorder
-  ###                   postorder, reverse_postorder
-  ### ----------------------------------------------------------------
-  ###
+  # ------------------------------------------------------------------
+  #      preorder, reverse_preorder, postorder, reverse_postorder
+  # ------------------------------------------------------------------
 
-  def check_preorder node, exp
+  def check_preorder(node, exp)
     exp.map!{|n| [n]}
 
     out = yields(:preorder, node, node)
@@ -640,7 +617,7 @@ class NodeWalkTest < Test::Unit::TestCase
     exp.reverse!
     assert_equal_yields exp, out
   end
-  def check_postorder node, exp
+  def check_postorder(node, exp)
     exp.map!{|n| [n]}
 
     out = yields(:postorder, node, node)
@@ -651,12 +628,12 @@ class NodeWalkTest < Test::Unit::TestCase
     assert_equal_yields exp, out
   end
   def test_preorder
-    ## empty node
+    # empty node
     d = C::Int.new
     d.longness = 1
     check_preorder(d, [d])
 
-    ## one-storey -- populate both the list child and nonlist child
+    # one-storey -- populate both the list child and nonlist child
     d = C::Declaration.new(C::Int.new)
     d.declarators << C::Declarator.new
     d.declarators[0].name = 'one'
@@ -671,7 +648,7 @@ class NodeWalkTest < Test::Unit::TestCase
                      d.declarators[1]
                    ])
 
-    ## multi-layer
+    # multi-layer
     d.declarators[0].indirect_type = C::Function.new
     d.declarators[0].indirect_type.params = Chain[]
     d.declarators[0].indirect_type.params << C::Parameter.new(C::Int.new, 'i')
@@ -692,12 +669,12 @@ class NodeWalkTest < Test::Unit::TestCase
                    ])
   end
   def test_postorder
-    ## empty node
+    # empty node
     d = C::Int.new
     d.longness = 1
     check_preorder(d, [d])
 
-    ## one-storey -- populate both the list child and nonlist child
+    # one-storey -- populate both the list child and nonlist child
     d = C::Declaration.new(C::Int.new)
     d.declarators << C::Declarator.new
     d.declarators[0].name = 'one'
@@ -712,7 +689,7 @@ class NodeWalkTest < Test::Unit::TestCase
                      d
                     ])
 
-    ## multi-layer
+    # multi-layer
     d.declarators[0].indirect_type = C::Function.new
     d.declarators[0].indirect_type.params = Chain[]
     d.declarators[0].indirect_type.params << C::Parameter.new(C::Int.new, 'i')
@@ -732,7 +709,7 @@ class NodeWalkTest < Test::Unit::TestCase
                      d
                     ])
   end
-  def check_preorder_prune method, pruned_nodes, root, exp
+  def check_preorder_prune(method, pruned_nodes, root, exp)
     exp.map!{|n| [n]}
 
     out = yields(method, root, root) do |node|
@@ -744,13 +721,13 @@ class NodeWalkTest < Test::Unit::TestCase
   end
 
   def test_preorder_prune
-    ## empty node
+    # empty node
     d = C::Int.new
     d.longness = 1
     check_preorder_prune(:preorder, [d], d, [d])
     check_preorder_prune(:reverse_preorder, [d], d, [d])
 
-    ## one-storey -- populate both the list child and nonlist child
+    # one-storey -- populate both the list child and nonlist child
     d = C::Declaration.new(C::Int.new)
     d.declarators << C::Declarator.new
     d.declarators[0].name = 'one'
@@ -769,7 +746,7 @@ class NodeWalkTest < Test::Unit::TestCase
                                    d.type,
                                  ])
 
-    ## multi-layer
+    # multi-layer
     d.type = C::Struct.new('S')
     d.type.members = Chain[]
     d.type.members << C::Declaration.new(C::Int.new)
@@ -798,14 +775,12 @@ class NodeWalkTest < Test::Unit::TestCase
                                  ])
   end
 
-  ###
-  ### ----------------------------------------------------------------
-  ###                 next, prev, list_next, list_prev
-  ### ----------------------------------------------------------------
-  ###
+  # ------------------------------------------------------------------
+  #                  next, prev, list_next, list_prev
+  # ------------------------------------------------------------------
 
   def test_next_prev
-    ## list parent
+    # list parent
     i1 = C::Int.new
     i2 = C::Int.new
     list = Chain[i1, i2]
@@ -814,7 +789,7 @@ class NodeWalkTest < Test::Unit::TestCase
     assert_same(i1, i2.prev)
     assert_nil(i1.prev)
 
-    ## node parent
+    # node parent
     i1 = C::IntLiteral.new(1)
     i2 = C::IntLiteral.new(2)
     a = C::Add.new(i1, i2)
@@ -823,14 +798,14 @@ class NodeWalkTest < Test::Unit::TestCase
     assert_same(i1, i2.prev)
     assert_nil(i1.prev)
 
-    ## no parent
+    # no parent
     i = C::Int.new
-    assert_raise(C::Node::NoParent){i.next}
-    assert_raise(C::Node::NoParent){i.prev}
+    assert_raises(C::Node::NoParent){i.next}
+    assert_raises(C::Node::NoParent){i.prev}
   end
 
   def test_list_next_prev
-    ## list parent
+    # list parent
     i1 = C::Int.new
     i2 = C::Int.new
     list = Chain[i1, i2]
@@ -839,28 +814,28 @@ class NodeWalkTest < Test::Unit::TestCase
     assert_same(i1, i2.list_prev)
     assert_nil(i1.list_prev)
 
-    ## node parent
+    # node parent
     i1 = C::IntLiteral.new(1)
     i2 = C::IntLiteral.new(2)
     a = C::Add.new(i1, i2)
-    assert_raise(C::Node::BadParent){i1.list_next}
-    assert_raise(C::Node::BadParent){i2.list_next}
-    assert_raise(C::Node::BadParent){i1.list_prev}
-    assert_raise(C::Node::BadParent){i2.list_prev}
+    assert_raises(C::Node::BadParent){i1.list_next}
+    assert_raises(C::Node::BadParent){i2.list_next}
+    assert_raises(C::Node::BadParent){i1.list_prev}
+    assert_raises(C::Node::BadParent){i2.list_prev}
 
-    ## no parent
+    # no parent
     i = C::Int.new
-    assert_raise(C::Node::NoParent){i.list_next}
-    assert_raise(C::Node::NoParent){i.list_prev}
+    assert_raises(C::Node::NoParent){i.list_next}
+    assert_raises(C::Node::NoParent){i.list_prev}
   end
 end
 
-class NodeTreeTest < Test::Unit::TestCase
+class NodeTreeTest < Minitest::Test
   def setup
-    ## @c = "(int){[1] = 10,
-    ##             .x = 20,
-    ##             [2] .y = 30
-    ##            }
+    # @c = "(int){[1] = 10,
+    #             .x = 20,
+    #             [2] .y = 30
+    #            }
     @c = C::CompoundLiteral.new
     c.type = C::Int.new
     c.member_inits << C::MemberInit.new
@@ -978,26 +953,26 @@ class NodeTreeTest < Test::Unit::TestCase
     assert_tree(mi)
     assert_same_list([mi1, mi2, mis[1], mis[2]], c.member_inits)
 
-    assert_raise(C::Node::NoParent){mi.replace_with(nil)}
+    assert_raises(C::Node::NoParent){mi.replace_with(nil)}
     i1 = C::Int.new
     i2 = C::Int.new
-    assert_raise(ArgumentError){c.type.replace_with(i1, i2)}
+    assert_raises(ArgumentError){c.type.replace_with(i1, i2)}
   end
 
   def test_node_swap_with
-    ## swap with itself -- attached
+    # swap with itself -- attached
     x = X.new
     parent = X.new(x)
     assert_same(x, x.swap_with(x))
     assert_same(parent, x.parent)
     assert_same(x, parent.a)
 
-    ## swap with itself -- detached
+    # swap with itself -- detached
     x = X.new
     assert_same(x, x.swap_with(x))
     assert_nil(x.parent)
 
-    ## both attached
+    # both attached
     x = X.new
     y = X.new
     xp = X.new(x)
@@ -1008,7 +983,7 @@ class NodeTreeTest < Test::Unit::TestCase
     assert_same(yp, x.parent)
     assert_same(y, xp.a)
 
-    ## only receiver attached
+    # only receiver attached
     x = X.new
     y = X.new
     xp = X.new(x)
@@ -1017,7 +992,7 @@ class NodeTreeTest < Test::Unit::TestCase
     assert_same(xp, y.parent)
     assert_same(y, xp.a)
 
-    ## only arg attached
+    # only arg attached
     x = X.new
     y = X.new
     yp = X.new(y)
@@ -1026,7 +1001,7 @@ class NodeTreeTest < Test::Unit::TestCase
     assert_same(x, yp.a)
     assert_nil(y.parent)
 
-    ## neither attached
+    # neither attached
     x = X.new
     y = X.new
     assert_same(x, x.swap_with(y))
@@ -1034,16 +1009,15 @@ class NodeTreeTest < Test::Unit::TestCase
     assert_nil(y.parent)
   end
 
-  ###
-  ### ----------------------------------------------------------------
-  ###                     insert_next, insert_prev
-  ### ----------------------------------------------------------------
-  ###
+  # ------------------------------------------------------------------
+  #                      insert_next, insert_prev
+  # ------------------------------------------------------------------
+
   def test_node_insert_next_detached
     x1, x2 = 2.of{X.new}
-    assert_raise(C::Node::NoParent){x1.insert_next}
+    assert_raises(C::Node::NoParent){x1.insert_next}
     assert_nil(x1.parent)
-    assert_raise(C::Node::NoParent){x1.insert_next(x2)}
+    assert_raises(C::Node::NoParent){x1.insert_next(x2)}
     assert_nil(x1.parent)
     assert_nil(x2.parent)
   end
@@ -1051,9 +1025,9 @@ class NodeTreeTest < Test::Unit::TestCase
     parent = X.new
     x1, x2 = 2.of{X.new}
     parent.a = x1
-    assert_raise(C::Node::BadParent){x1.insert_next}
+    assert_raises(C::Node::BadParent){x1.insert_next}
     assert_same(parent, x1.parent)
-    assert_raise(C::Node::BadParent){x1.insert_next(x2)}
+    assert_raises(C::Node::BadParent){x1.insert_next(x2)}
     assert_same(parent, x1.parent)
     assert_nil(x2.parent)
   end
@@ -1072,9 +1046,9 @@ class NodeTreeTest < Test::Unit::TestCase
 
   def test_node_insert_prev_detached
     a1, a2 = 2.of{X.new}
-    assert_raise(C::Node::NoParent){a1.insert_prev}
+    assert_raises(C::Node::NoParent){a1.insert_prev}
     assert_nil(a1.parent)
-    assert_raise(C::Node::NoParent){a1.insert_prev(a2)}
+    assert_raises(C::Node::NoParent){a1.insert_prev(a2)}
     assert_nil(a1.parent)
     assert_nil(a2.parent)
   end
@@ -1082,9 +1056,9 @@ class NodeTreeTest < Test::Unit::TestCase
     parent = X.new
     x1, x2 = 2.of{X.new}
     parent.a = x1
-    assert_raise(C::Node::BadParent){x1.insert_prev}
+    assert_raises(C::Node::BadParent){x1.insert_prev}
     assert_same(parent, x1.parent)
-    assert_raise(C::Node::BadParent){x1.insert_prev(x2)}
+    assert_raises(C::Node::BadParent){x1.insert_prev(x2)}
     assert_same(parent, x1.parent)
     assert_nil(x2.parent)
   end
@@ -1101,33 +1075,31 @@ class NodeTreeTest < Test::Unit::TestCase
     assert_same_list([x2, x3, x4, x1], parent)
   end
 
-  ###
-  ### ----------------------------------------------------------------
-  ###                     node_after, node_before
-  ### ----------------------------------------------------------------
-  ###
+  # ------------------------------------------------------------------
+  #                      node_after, node_before
+  # ------------------------------------------------------------------
 
   def test_node_after_before
-    ## node not a child
+    # node not a child
     x1, x2 = 2.of{X.new}
     parent = X.new(x1)
-    assert_raise(ArgumentError){parent.node_after(x2)}
-    assert_raise(ArgumentError){parent.node_before(x2)}
+    assert_raises(ArgumentError){parent.node_after(x2)}
+    assert_raises(ArgumentError){parent.node_before(x2)}
 
     x1, x2 = 2.of{X.new}
     parent = Z.new(nil, x1, nil, x2, nil)
-    assert_raise(ArgumentError){parent.node_after(x1)}
-    assert_raise(ArgumentError){parent.node_after(x2)}
-    assert_raise(ArgumentError){parent.node_before(x1)}
-    assert_raise(ArgumentError){parent.node_before(x2)}
+    assert_raises(ArgumentError){parent.node_after(x1)}
+    assert_raises(ArgumentError){parent.node_after(x2)}
+    assert_raises(ArgumentError){parent.node_before(x1)}
+    assert_raises(ArgumentError){parent.node_before(x2)}
 
-    ## one child
+    # one child
     x = X.new
     parent = X.new(x)
     assert_nil(parent.node_after(x))
     assert_nil(parent.node_before(x))
 
-    ## two children
+    # two children
     x1 = X.new
     x2 = X.new
     parent = Y.new(x1, x2)
@@ -1136,7 +1108,7 @@ class NodeTreeTest < Test::Unit::TestCase
     assert_same(x1, parent.node_before(x2))
     assert_nil(parent.node_before(x1))
 
-    ## skip over stuff in the middle
+    # skip over stuff in the middle
     x1, x2, x3, x4, x5 = 5.of{X.new}
     parent = Z.new(x1, x2, nil, x4, x5)
     assert_same(x5, parent.node_after(x1))
@@ -1144,7 +1116,7 @@ class NodeTreeTest < Test::Unit::TestCase
     assert_same(x1, parent.node_before(x5))
     assert_nil(parent.node_before(x1))
 
-    ## skip over stuff at the end
+    # skip over stuff at the end
     x1, x2, x3, x4, x5 = 5.of{X.new}
     parent = Z.new(nil, x2, x3, x4, nil)
     assert_nil(parent.node_after(x3))
@@ -1152,20 +1124,20 @@ class NodeTreeTest < Test::Unit::TestCase
   end
 
   def test_remove_node
-    ## node not a child
+    # node not a child
     x1, x2, x3 = 3.of{X.new}
     parent = Z.new(x1, x2)
-    assert_raise(ArgumentError){parent.remove_node(x2)}
-    assert_raise(ArgumentError){parent.remove_node(x3)}
+    assert_raises(ArgumentError){parent.remove_node(x2)}
+    assert_raises(ArgumentError){parent.remove_node(x3)}
 
-    ## one child
+    # one child
     x = X.new
     parent = X.new(x)
     assert_same(parent, parent.remove_node(x))
     assert_tree(parent)
     assert_tree(x)
 
-    ## two children
+    # two children
     x1, x2 = 2.of{X.new}
     parent = Y.new(x1, x2)
     assert_same(parent, parent.remove_node(x2))
@@ -1176,13 +1148,13 @@ class NodeTreeTest < Test::Unit::TestCase
   end
 
   def test_replace_node
-    ## node not a child
+    # node not a child
     x1, x2, x3, x4 = 3.of{X.new}
     parent = Z.new(x1, x2)
-    assert_raise(ArgumentError){parent.replace_node(x2, x4)}
-    assert_raise(ArgumentError){parent.replace_node(x3, x4)}
+    assert_raises(ArgumentError){parent.replace_node(x2, x4)}
+    assert_raises(ArgumentError){parent.replace_node(x3, x4)}
 
-    ## no newnode
+    # no newnode
     x = X.new
     parent = X.new(x)
     assert_same(parent, parent.replace_node(x))
@@ -1190,32 +1162,32 @@ class NodeTreeTest < Test::Unit::TestCase
     assert_tree(x)
     assert_nil(parent.a)
 
-    ## >1 newnode
+    # >1 newnode
     x1, x2, x3 = 3.of{X.new}
     parent = X.new(x1)
-    assert_raise(ArgumentError){parent.replace_node(x1, x2, x3)}
+    assert_raises(ArgumentError){parent.replace_node(x1, x2, x3)}
 
-    ## one child
+    # one child
     x1, x2 = 2.of{X.new}
     parent = X.new(x1)
     assert_same(parent, parent.replace_node(x1, x2))
     assert_tree(parent)
     assert_tree(x1)
     assert_same(x2, parent.a)
-    ##
+    #
     assert_same(parent, parent.replace_node(x2, nil))
     assert_tree(parent)
     assert_tree(x2)
     assert_nil(parent.a)
 
-    ## two children
+    # two children
     x1, x2, x3 = 3.of{X.new}
     parent = Y.new(x1, x2)
     assert_same(parent, parent.replace_node(x2, x3))
     assert_tree(parent)
     assert_tree(x2)
     assert_same(x3, parent.b)
-    ##
+    #
     assert_same(parent, parent.replace_node(x3, nil))
     assert_tree(parent)
     assert_tree(x3)