rubytree 1.0.2 → 2.0.0

data/test/test_tree.rb

@@ -2,9 +2,7 @@
 
 # test_tree.rb - This file is part of the RubyTree package.
 #
-# Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2017, 2020, 2020 Anupam Sengupta
-#
-# All rights reserved.
+# Copyright (c) 2006-2022 Anupam Sengupta. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without modification,
 # are permitted provided that the following conditions are met:
@@ -31,9 +29,9 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
+# frozen_string_literal: true
 
 require 'test/unit'
-require 'structured_warnings'
 require 'json'
 require_relative '../lib/tree/tree_deps'
 
@@ -96,9 +94,9 @@ module TestTree
       assert_not_nil(@root.name, 'Name should not be nil')
       assert_equal('ROOT', @root.name, "Name should be 'ROOT'")
       assert_equal('Root Node', @root.content, "Content should be 'Root Node'")
-      assert(@root.is_root?, 'Should identify as root')
-      assert(!@root.has_children?, 'Cannot have any children')
-      assert(@root.has_content?, 'This root should have content')
+      assert(@root.root?, 'Should identify as root')
+      assert(!@root.children?, 'Cannot have any children')
+      assert(@root.content?, 'This root should have content')
       assert_equal(1, @root.size, 'Number of nodes should be one')
       assert_equal(0, @root.siblings.length, 'This root does not have any children')
       assert_equal(0, @root.in_degree, 'Root should have an in-degree of 0')
@@ -110,7 +108,7 @@ module TestTree
     def test_root
       setup_test_tree
 
-      # TODO: Should probably change this logic.  Root's root should
+      # @todo: Should probably change this logic.  Root's root should
       # return nil so that the possibility of a recursive error does not exist
       # at all.
       assert_same(@root, @root.root, "Root's root is self")
@@ -146,21 +144,21 @@ module TestTree
 
       assert_same(Tree::TreeNode, tree.class)
       assert_same(tree.name, :A)
-      assert_equal(true, tree.is_root?)
-      assert_equal(false, tree.is_leaf?)
+      assert_equal(true, tree.root?)
+      assert_equal(false, tree.leaf?)
       assert_equal(9, tree.size)
       assert_equal('Root content', tree.content)
       assert_equal(3, tree.children.count) # B, C, D
 
       leaf_with_content = tree[:B][:F][:I]
       assert_equal('Leaf content', leaf_with_content.content)
-      assert_equal(true, leaf_with_content.is_leaf?)
+      assert_equal(true, leaf_with_content.leaf?)
 
       leaf_without_content = tree[:C]
-      assert_equal(true, leaf_without_content.is_leaf?)
+      assert_equal(true, leaf_without_content.leaf?)
 
       interior_node = tree[:B][:F]
-      assert_equal(false, interior_node.is_leaf?)
+      assert_equal(false, interior_node.leaf?)
       assert_equal(2, interior_node.children.count)
 
       # Can't make a node without a name
@@ -196,21 +194,21 @@ module TestTree
 
       assert_same(Tree::TreeNode, tree.class)
       assert_same(:A, tree.name)
-      assert_equal(true, tree.is_root?)
-      assert_equal(false, tree.is_leaf?)
+      assert_equal(true, tree.root?)
+      assert_equal(false, tree.leaf?)
       assert_equal(9, tree.size)
       assert_equal('Root content', tree.content)
       assert_equal(3, tree.children.count) # B, C, D
 
       leaf_with_content = tree[:B][:F][:I]
       assert_equal('Leaf content', leaf_with_content.content)
-      assert_equal(true, leaf_with_content.is_leaf?)
+      assert_equal(true, leaf_with_content.leaf?)
 
       leaf_without_content = tree[:C]
-      assert_equal(true, leaf_without_content.is_leaf?)
+      assert_equal(true, leaf_without_content.leaf?)
 
       interior_node = tree[:B][:F]
-      assert_equal(false, interior_node.is_leaf?)
+      assert_equal(false, interior_node.leaf?)
       assert_equal(2, interior_node.children.count)
     end
 
@@ -236,7 +234,7 @@ module TestTree
       assert_equal(2, added_children.count)
       assert_equal(7, tree.size)
       assert_equal('G content', tree[:G].content)
-      assert_equal(true, tree[:G].is_leaf?)
+      assert_equal(true, tree[:G].leaf?)
       assert_equal(5, tree[:B].size)
       assert_equal(3, tree[:B].children.count)
 
@@ -291,24 +289,15 @@ module TestTree
     def test_has_content_eh
       a_node = Tree::TreeNode.new('A Node')
       assert_nil(a_node.content, 'The node should not have content')
-      assert(!a_node.has_content?, 'The node should not have content')
+      assert(!a_node.content?, 'The node should not have content')
 
       a_node.content = 'Something'
       assert_not_nil(a_node.content, 'The node should now have content')
-      assert(a_node.has_content?, 'The node should now have content')
-    end
-
-    # Test the equivalence of size and length methods.
-    def test_length_is_size
-      setup_test_tree
-      assert_equal(@root.size, @root.length, 'Length and size methods should return the same result')
+      assert(a_node.content?, 'The node should now have content')
     end
 
     # Test the <=> operator.
     def test_spaceship
-      require 'structured_warnings'
-      StructuredWarnings::StandardWarning.disable # Disable the warnings for using integers as node names
-
       first_node  = Tree::TreeNode.new(1)
       second_node = Tree::TreeNode.new(2)
 
@@ -326,8 +315,6 @@ module TestTree
 
       second_node = Tree::TreeNode.new('ABC')
       assert_equal(0, first_node <=> second_node)
-
-      StructuredWarnings::StandardWarning.enable
     end
 
     # Test the inclusion of Comparable
@@ -342,7 +329,7 @@ module TestTree
       assert(node_b >  node_a, "Node B is lexically 'greater than' node A")
       assert(node_b >= node_a, "Node B is lexically 'greater than' node A")
 
-      assert(!(node_a == node_b), 'Node A and Node B are not equal')
+      assert(node_a != node_b, 'Node A and Node B are not equal')
       assert(node_b.between?(node_a, node_c), 'Node B is lexically between node A and node C')
     end
 
@@ -382,7 +369,7 @@ module TestTree
     def test_first_sibling
       setup_test_tree
 
-      # TODO: Need to fix the first_sibling method to return nil for nodes with no siblings.
+      # @todo: Need to fix the first_sibling method to return nil for nodes with no siblings.
       assert_same(@root, @root.first_sibling, "Root's first sibling is itself")
       assert_same(@child1, @child1.first_sibling, "Child1's first sibling is itself")
       assert_same(@child1, @child2.first_sibling, "Child2's first sibling should be child1")
@@ -391,26 +378,26 @@ module TestTree
       assert_not_same(@child1, @child4.first_sibling, "Child4's first sibling is itself")
     end
 
-    # Test the is_first_sibling? method.
+    # Test the first_sibling? method.
     def test_is_first_sibling_eh
       setup_test_tree
 
-      assert(@root.is_first_sibling?, "Root's first sibling is itself")
-      assert(@child1.is_first_sibling?, "Child1's first sibling is itself")
-      assert(!@child2.is_first_sibling?, 'Child2 is not the first sibling')
-      assert(!@child3.is_first_sibling?, 'Child3 is not the first sibling')
-      assert(@child4.is_first_sibling?, "Child4's first sibling is itself")
+      assert(@root.first_sibling?, "Root's first sibling is itself")
+      assert(@child1.first_sibling?, "Child1's first sibling is itself")
+      assert(!@child2.first_sibling?, 'Child2 is not the first sibling')
+      assert(!@child3.first_sibling?, 'Child3 is not the first sibling')
+      assert(@child4.first_sibling?, "Child4's first sibling is itself")
     end
 
-    # Test the is_last_sibling? method.
+    # Test the last_sibling? method.
     def test_is_last_sibling_eh
       setup_test_tree
 
-      assert(@root.is_last_sibling?, "Root's last sibling is itself")
-      assert(!@child1.is_last_sibling?, 'Child1 is not the last sibling')
-      assert(!@child2.is_last_sibling?, 'Child2 is not the last sibling')
-      assert(@child3.is_last_sibling?, "Child3's last sibling is itself")
-      assert(@child4.is_last_sibling?, "Child4's last sibling is itself")
+      assert(@root.last_sibling?, "Root's last sibling is itself")
+      assert(!@child1.last_sibling?, 'Child1 is not the last sibling')
+      assert(!@child2.last_sibling?, 'Child2 is not the last sibling')
+      assert(@child3.last_sibling?, "Child3's last sibling is itself")
+      assert(@child4.last_sibling?, "Child4's last sibling is itself")
     end
 
     # Test the last_sibling method.
@@ -452,15 +439,15 @@ module TestTree
       assert_equal(0, siblings.length, 'Root should not have any siblings')
     end
 
-    # Test the is_only_child? method.
+    # Test the only_child? method.
     def test_is_only_child_eh
       setup_test_tree
 
-      assert(@root.is_only_child?, 'Root is an only child')
-      assert(!@child1.is_only_child?, 'Child1 is not the only child')
-      assert(!@child2.is_only_child?, 'Child2 is not the only child')
-      assert(!@child3.is_only_child?, 'Child3 is not the only child')
-      assert(@child4.is_only_child?, 'Child4 is an only child')
+      assert(@root.only_child?, 'Root is an only child')
+      assert(!@child1.only_child?, 'Child1 is not the only child')
+      assert(!@child2.only_child?, 'Child2 is not the only child')
+      assert(!@child3.only_child?, 'Child3 is not the only child')
+      assert(@child4.only_child?, 'Child4 is an only child')
     end
 
     # Test the next_sibling method.
@@ -487,14 +474,14 @@ module TestTree
 
     # Test the add method.
     def test_add
-      assert(!@root.has_children?, 'Should not have any children')
+      assert(!@root.children?, 'Should not have any children')
 
       assert_equal(1, @root.size, 'Should have 1 node (the root)')
       @root.add(@child1)
 
       @root << @child2
 
-      assert(@root.has_children?, 'Should have children')
+      assert(@root.children?, 'Should have children')
       assert_equal(3, @root.size, 'Should have three nodes')
 
       @root << @child3 << @child4
@@ -533,7 +520,8 @@ module TestTree
       begin
         root << two << deep
       rescue RuntimeError => e
-        raise("Error! The RuntimeError #{e} should not have been thrown. The same node can be added to different branches.")
+        raise("Error! The RuntimeError #{e} should not have been thrown. " \
+              'The same node can be added to different branches.')
       end
 
       assert_raise(ArgumentError) { root << three << three }
@@ -549,7 +537,7 @@ module TestTree
 
     # Test Addition at a specific position
     def test_add_at_specific_position
-      assert(!@root.has_children?, 'Should not have any children')
+      assert(!@root.children?, 'Should not have any children')
 
       assert_equal(1, @root.size, 'Should have 1 node (the root)')
       @root.add(@child1) # First Child added at position 0
@@ -579,7 +567,9 @@ module TestTree
 
       # Now, a negative test.  We are preventing addition to a position that does not exist.
       assert_raise(RuntimeError) do
-        @root.add(@child5, @root.children.size + 1) # Fifth child inserted beyond the last position that is valid (at 5th pos).
+        # Fifth child inserted beyond the last position that is valid (at 5th
+        # pos).
+        @root.add(@child5, @root.children.size + 1)
       end
       # Validate that we still have children = [@child1, @child3, @child2, @child4]
       assert_equal(@child1, @root[0])
@@ -589,9 +579,12 @@ module TestTree
       assert_nil(@root[4])
       assert_equal(4, @root.children.size, 'Should have four child nodes')
 
-      # Another negative test.  Lets attempt to add from the end at a position that is not available
+      # Another negative test. Lets attempt to add from the end at a position
+      # that is not available
       assert_raise(RuntimeError) do
-        @root.add(@child5, -(@root.children.size + 2)) # Fifth child inserted beyond the first position that is valid; i.e. at -6
+        # Fifth child inserted beyond the first position that is valid; i.e. at
+        # -6
+        @root.add(@child5, -(@root.children.size + 2))
       end
       assert_nil(@root[-5])
       assert_equal(@child1, @root[-4])
@@ -600,8 +593,11 @@ module TestTree
       assert_equal(@child4, @root[-1])
       assert_equal(4, @root.children.size, 'Should have four child nodes')
 
-      # Lets correctly add the fifth child from the end to effectively prepend the node.
-      @root.add(@child5, -(@root.children.size + 1)) # Fifth child inserted beyond the first position; i.e. at -5
+      # Lets correctly add the fifth child from the end to effectively prepend
+      # the node.
+
+      # Fifth child inserted beyond the first position; i.e. at -5
+      @root.add(@child5, -(@root.children.size + 1))
       assert_nil(@root[-6])
       assert_equal(@child5, @root[-5])
       assert_equal(@child1, @root[-4])
@@ -658,40 +654,40 @@ module TestTree
       @root << @child1
       @root << @child2
 
-      assert(@root.has_children?, 'Should have children')
+      assert(@root.children?, 'Should have children')
       assert_equal(3, @root.size, 'Should have three nodes')
 
       @root.remove!(@child1)
       assert_equal(2, @root.size, 'Should have two nodes')
       @root.remove!(@child2)
 
-      assert(!@root.has_children?, 'Should have no children')
+      assert(!@root.children?, 'Should have no children')
       assert_equal(1, @root.size, 'Should have one node')
 
       @root << @child1
       @root << @child2
 
-      assert(@root.has_children?, 'Should have children')
+      assert(@root.children?, 'Should have children')
       assert_equal(3, @root.size, 'Should have three nodes')
 
       @root.remove_all!
 
-      assert(!@root.has_children?, 'Should have no children')
+      assert(!@root.children?, 'Should have no children')
       assert_equal(1, @root.size, 'Should have one node')
 
       # Some negative testing
       @root.remove!(nil)
-      assert(!@root.has_children?, 'Should have no children')
+      assert(!@root.children?, 'Should have no children')
       assert_equal(1, @root.size, 'Should have one node')
     end
 
     # Test the remove_all! method.
     def test_remove_all_bang
       setup_test_tree
-      assert(@root.has_children?, 'Should have children')
+      assert(@root.children?, 'Should have children')
       @root.remove_all!
 
-      assert(!@root.has_children?, 'Should have no children')
+      assert(!@root.children?, 'Should have no children')
       assert_equal(1, @root.size, 'Should have one node')
     end
 
@@ -699,8 +695,8 @@ module TestTree
     def test_remove_from_parent_bang
       setup_test_tree
 
-      assert(@root.has_children?, 'Should have children')
-      assert(!@root.is_leaf?, 'Root is not a leaf here')
+      assert(@root.children?, 'Should have children')
+      assert(!@root.leaf?, 'Root is not a leaf here')
 
       child1 = @root[0]
       assert_not_nil(child1, 'Child 1 should exist')
@@ -718,10 +714,10 @@ module TestTree
     def test_children
       setup_test_tree
 
-      assert(@root.has_children?, 'Should have children')
+      assert(@root.children?, 'Should have children')
       assert_equal(5, @root.size, 'Should have five nodes')
-      assert(@child3.has_children?, 'Should have children')
-      assert(!@child3.is_leaf?, 'Should not be a leaf')
+      assert(@child3.children?, 'Should have children')
+      assert(!@child3.leaf?, 'Should not be a leaf')
 
       assert_equal(1, @child3.node_height, 'The subtree at Child 3 should have a height of 1')
       [@child1, @child2, @child4].each do |child|
@@ -795,9 +791,9 @@ module TestTree
     def test_each
       setup_test_tree
 
-      assert(@root.has_children?, 'Should have children')
+      assert(@root.children?, 'Should have children')
       assert_equal(5, @root.size, 'Should have five nodes')
-      assert(@child3.has_children?, 'Should have children')
+      assert(@child3.children?, 'Should have children')
 
       nodes = []
       @root.each { |node| nodes << node }
@@ -882,14 +878,14 @@ module TestTree
       # Test the root node
       assert_equal(test_root.name, new_root.name, 'Must identify as ROOT')
       assert_equal(test_root.content, new_root.content, "Must have root's content")
-      assert(new_root.is_root?, 'Must be the ROOT node')
-      assert(new_root.has_children?, 'Must have a child node')
+      assert(new_root.root?, 'Must be the ROOT node')
+      assert(new_root.children?, 'Must have a child node')
 
       # Test the child node
       new_child = new_root[test_child.name]
       assert_equal(test_child.name, new_child.name, 'Must have child 1')
-      assert(new_child.has_content?, 'Child must have content')
-      assert(new_child.is_only_child?, 'Child must be the only child')
+      assert(new_child.content?, 'Child must have content')
+      assert(new_child.only_child?, 'Child must be the only child')
 
       new_child_content = new_child.content
       assert_equal(Hash, new_child_content.class, "Class of child's content should be a hash")
@@ -898,8 +894,8 @@ module TestTree
       # Test the grand-child node
       new_grand_child = new_child[test_grand_child.name]
       assert_equal(test_grand_child.name, new_grand_child.name, 'Must have grand child')
-      assert(new_grand_child.has_content?, 'Grand-child must have content')
-      assert(new_grand_child.is_only_child?, 'Grand-child must be the only child')
+      assert(new_grand_child.content?, 'Grand-child must have content')
+      assert(new_grand_child.only_child?, 'Grand-child must be the only child')
 
       new_grand_child_content = new_grand_child.content
       assert_equal(Array, new_grand_child_content.class, "Class of grand-child's content should be an Array")
@@ -948,34 +944,6 @@ module TestTree
       assert_same(person, @root.content, 'Content should be the same')
     end
 
-    # Test the depth computation algorithm.  Note that this is an incorrect computation and actually returns height+1
-    # instead of depth.  This method has been deprecated in this release and may be removed in the future.
-    def test_depth
-      require 'structured_warnings'
-      assert_warn(StructuredWarnings::DeprecatedMethodWarning) { do_deprecated_depth }
-    rescue LoadError
-      # Since the structured_warnings package is not present, we revert to good old Kernel#warn behavior.
-      do_deprecated_depth
-    end
-
-    # Run the assertions for the deprecated depth method.
-    def do_deprecated_depth
-      assert_equal(1, @root.depth, "A single node's depth is 1")
-
-      @root << @child1
-      assert_equal(2, @root.depth, 'This should be of depth 2')
-
-      @root << @child2
-      assert_equal(2, @root.depth, 'This should be of depth 2')
-
-      @child2 << @child3
-      assert_equal(3, @root.depth, 'This should be of depth 3')
-      assert_equal(2, @child2.depth, 'This should be of depth 2')
-
-      @child3 << @child4
-      assert_equal(4, @root.depth, 'This should be of depth 4')
-    end
-
     # Test the height computation algorithm
     def test_node_height
       assert_equal(0, @root.node_height, "A single node's height is 0")
@@ -1000,8 +968,7 @@ module TestTree
       assert_equal(0, @child4.node_height, 'This should be of height 0')
     end
 
-    # Test the depth computation algorithm.  Note that this is the correct depth computation.  The original
-    # Tree::TreeNode#depth was incorrectly computing the height of the node - instead of its depth.
+    # Test the depth computation algorithm.
     def test_node_depth
       assert_equal(0, @root.node_depth, "A root node's depth is 0")
 
@@ -1090,9 +1057,8 @@ module TestTree
       end
 
       assert_equal(Enumerator, j.breadth_each.class) if defined?(Enumerator.class) # Without a block
-      if defined?(Enumerable::Enumerator.class)
-        assert_equal(Enumerable::Enumerator, j.breadth_each.class)
-      end # Without a block
+      # Without a block
+      assert_equal(Enumerable::Enumerator, j.breadth_each.class) if defined?(Enumerable::Enumerator.class)
 
       # Now test without a block
       result_array = j.breadth_each.collect { |node| node }
@@ -1136,10 +1102,11 @@ module TestTree
         assert_equal(expected_array[i].name, result_array[i].name)
       end
 
-      assert_equal(Enumerator, j.preordered_each.class) if defined?(Enumerator.class) # Without a block
-      if defined?(Enumerable::Enumerator.class)
-        assert_equal(Enumerable::Enumerator, j.preordered_each.class)
-      end # Without a block
+      assert_equal(Enumerator, j.preordered_each.class) \
+        if defined?(Enumerator.class) # Without a block
+
+      assert_equal(Enumerable::Enumerator, j.preordered_each.class) \
+        if defined?(Enumerable::Enumerator.class)
     end
 
     # Test the postordered_each method.
@@ -1179,9 +1146,9 @@ module TestTree
       end
 
       assert_equal(Enumerator, j.postordered_each.class) if defined?(Enumerator.class) # Without a block
-      if defined?(Enumerable::Enumerator.class)
-        assert_equal(Enumerable::Enumerator, j.postordered_each.class)
-      end # Without a block
+
+      assert_equal(Enumerable::Enumerator, j.postordered_each.class) \
+        if defined?(Enumerable::Enumerator.class)
 
       # Now test without a block
       result_array = j.postordered_each.collect { |node| node }
@@ -1196,75 +1163,75 @@ module TestTree
     def test_detached_copy
       setup_test_tree
 
-      assert(@root.has_children?, 'The root should have children')
+      assert(@root.children?, 'The root should have children')
       copy_of_root = @root.detached_copy
-      assert(!copy_of_root.has_children?, 'The copy should not have children')
+      assert(!copy_of_root.children?, 'The copy should not have children')
       assert_equal(@root.name, copy_of_root.name, 'The names should be equal')
 
       # Try the same test with a child node
-      assert(!@child3.is_root?, 'Child 3 is not a root')
-      assert(@child3.has_children?, 'Child 3 has children')
+      assert(!@child3.root?, 'Child 3 is not a root')
+      assert(@child3.children?, 'Child 3 has children')
       copy_of_child3 = @child3.detached_copy
-      assert(copy_of_child3.is_root?, "Child 3's copy is a root")
-      assert(!copy_of_child3.has_children?, "Child 3's copy does not have children")
+      assert(copy_of_child3.root?, "Child 3's copy is a root")
+      assert(!copy_of_child3.children?, "Child 3's copy does not have children")
     end
 
     # Test the detached_subtree_copy method.
     def test_detached_subtree_copy
       setup_test_tree
 
-      assert(@root.has_children?, 'The root should have children.')
+      assert(@root.children?, 'The root should have children.')
       tree_copy = @root.detached_subtree_copy
 
       assert_equal(@root.name, tree_copy.name, 'The names should be equal.')
       assert_not_equal(@root.object_id, tree_copy.object_id, 'Object_ids should differ.')
-      assert(tree_copy.is_root?, 'Copied root should be a root node.')
-      assert(tree_copy.has_children?, 'Copied tree should have children.')
+      assert(tree_copy.root?, 'Copied root should be a root node.')
+      assert(tree_copy.children?, 'Copied tree should have children.')
       assert_equal(tree_copy.children.count, @root.children.count,
                    'Copied tree and the original tree should have same number of children.')
 
       assert_equal(tree_copy[0].name, @child1.name, 'The names of Child1 (original and copy) should be same.')
       assert_not_equal(tree_copy[0].object_id, @child1.object_id,
                        'Child1 Object_ids (original and copy) should differ.')
-      assert(!tree_copy[0].is_root?, 'Child1 copied should not be root.')
-      assert(!tree_copy[0].has_children?, 'Child1 copied should not have children.')
+      assert(!tree_copy[0].root?, 'Child1 copied should not be root.')
+      assert(!tree_copy[0].children?, 'Child1 copied should not have children.')
 
       assert_equal(tree_copy[1].name, @child2.name, 'The names of Child2 (original and copy) should be same.')
       assert_not_equal(tree_copy[1].object_id, @child2.object_id,
                        'Child2 Object_ids (original and copy) should differ.')
-      assert(!tree_copy[1].is_root?, 'Child2 copied should not be root.')
-      assert(!tree_copy[1].has_children?, 'Child2 copied should not have children.')
+      assert(!tree_copy[1].root?, 'Child2 copied should not be root.')
+      assert(!tree_copy[1].children?, 'Child2 copied should not have children.')
 
       assert_equal(tree_copy[2].name, @child3.name, 'The names of Child3 (original and copy) should be same.')
       assert_not_equal(tree_copy[2].object_id, @child3.object_id,
                        'Child3 Object_ids (original and copy) should differ.')
-      assert(!tree_copy[2].is_root?, 'Child3 copied should not be root.')
-      assert(tree_copy[2].has_children?, 'Child3 copied should have children.')
+      assert(!tree_copy[2].root?, 'Child3 copied should not be root.')
+      assert(tree_copy[2].children?, 'Child3 copied should have children.')
 
       assert_equal(tree_copy[2][0].name, @child4.name, 'The names of Child4 (original and copy) should be same.')
       assert_not_equal(tree_copy[2][0].object_id, @child4.object_id,
                        'Child4 Object_ids (original and copy) should differ.')
-      assert(!tree_copy[2][0].is_root?, 'Child4 copied should not be root.')
-      assert(!tree_copy[2][0].has_children?, 'Child4 copied should not have children.')
+      assert(!tree_copy[2][0].root?, 'Child4 copied should not be root.')
+      assert(!tree_copy[2][0].children?, 'Child4 copied should not have children.')
     end
 
-    # Test the has_children? method.
+    # Test the children? method.
     def test_has_children_eh
       setup_test_tree
-      assert(@root.has_children?, 'The Root node MUST have children')
+      assert(@root.children?, 'The Root node MUST have children')
     end
 
-    # test the is_leaf? method.
+    # test the leaf? method.
     def test_is_leaf_eh
       setup_test_tree
-      assert(!@child3.is_leaf?, 'Child 3 is not a leaf node')
-      assert(@child4.is_leaf?, 'Child 4 is a leaf node')
+      assert(!@child3.leaf?, 'Child 3 is not a leaf node')
+      assert(@child4.leaf?, 'Child 4 is a leaf node')
     end
 
-    # Test the is_root? method.
+    # Test the root? method.
     def test_is_root_eh
       setup_test_tree
-      assert(@root.is_root?, 'The ROOT node must respond as the root node')
+      assert(@root.root?, 'The ROOT node must respond as the root node')
     end
 
     # Test the content= method.
@@ -1285,7 +1252,7 @@ module TestTree
     end
 
     # Test the << method.
-    def test_lt2 # Test the << method
+    def test_lt2
       @root << @child1
       @root << @child2
       @root << @child3 << @child4
@@ -1296,7 +1263,7 @@ module TestTree
     end
 
     # Test the [] method.
-    def test_index #  Test the [] method
+    def test_index
       assert_raise(ArgumentError) { @root[nil] }
 
       @root << @child1
@@ -1304,7 +1271,8 @@ module TestTree
       assert_equal(@child1.name, @root['Child1'].name, 'Child 1 should be returned')
       assert_equal(@child1.name, @root[0].name, 'Child 1 should be returned')
       assert_equal(@child1.name, @root[-2].name, 'Child 1 should be returned') # Negative access also works
-      assert_equal(@child1.name, @root[-@root.children.size].name, 'Child 1 should be returned') # Negative access also works
+      assert_equal(@child1.name,
+                   @root[-@root.children.size].name, 'Child 1 should be returned') # Negative access also works
 
       assert_equal(@child2.name, @root['Child2'].name, 'Child 2 should be returned')
       assert_equal(@child2.name, @root[1].name, 'Child 2 should be returned')
@@ -1407,46 +1375,12 @@ module TestTree
       assert_equal(k[1].name, root_node[1].name, 'Child 2 should be returned')
     end
 
-    # Test the old CamelCase method names
-    def test_old_camel_case_names
-      setup_test_tree
-
-      meth_names_to_test = %w[isRoot? isLeaf? hasContent?
-                              hasChildren? firstChild lastChild
-                              firstSibling isFirstSibling? lastSibling isLastSibling?
-                              isOnlyChild? nextSibling previousSibling nodeHeight nodeDepth
-                              removeFromParent! removeAll! freezeTree! ]
-
-      require 'structured_warnings'
-
-      StructuredWarnings::DeprecatedMethodWarning.disable do
-        # noinspection RubyResolve
-        assert(@root.isRoot?) # Test if the original method is really called
-      end
-
-      meth_names_to_test.each do |meth_name|
-        assert_warn(StructuredWarnings::DeprecatedMethodWarning) { @root.send(meth_name) }
-      end
-
-      # Special Case for printTree to avoid putting stuff on the STDOUT during the unit test.
-      begin
-        require 'stringio'
-        $stdout = StringIO.new
-        assert_warn(StructuredWarnings::DeprecatedMethodWarning) { @root.send('printTree') }
-      ensure
-        $stdout = STDOUT
-      end
-    end
-
     # Test usage of integers as node names
     def test_integer_node_names
-      require 'structured_warnings'
-      assert_warn(StructuredWarnings::StandardWarning) do
-        @n_root = Tree::TreeNode.new(0, 'Root Node')
-        @n_child1 = Tree::TreeNode.new(1, 'Child Node 1')
-        @n_child2 = Tree::TreeNode.new(2, 'Child Node 2')
-        @n_child3 = Tree::TreeNode.new('three', 'Child Node 3')
-      end
+      @n_root = Tree::TreeNode.new(0, 'Root Node')
+      @n_child1 = Tree::TreeNode.new(1, 'Child Node 1')
+      @n_child2 = Tree::TreeNode.new(2, 'Child Node 2')
+      @n_child3 = Tree::TreeNode.new('three', 'Child Node 3')
 
       @n_root << @n_child1
       @n_root << @n_child2
@@ -1454,18 +1388,11 @@ module TestTree
 
       # Node[n] is really accessing the nth child with a zero-base
       assert_not_equal(@n_root[1].name, 1) # This is really the second child
-      assert_equal(@n_root[0].name, 1)     # This will work, as it is the first child
-      assert_equal(@n_root[1, true].name, 1) # This will work, as the flag is now enabled
+      assert_equal(@n_root[0].name, '1')     # This will work, as it is the first child
+      assert_equal(@n_root[1].name, '2')     # This will work, as the flag is now enabled
 
       # Sanity check for the "normal" string name cases. Both cases should work.
-      assert_equal(@n_root['three', false].name, 'three')
-
-      StructuredWarnings::StandardWarning.disable
-      assert_equal(@n_root['three', true].name, 'three')
-
-      # Also ensure that the warning is actually being thrown
-      StructuredWarnings::StandardWarning.enable
-      assert_warn(StructuredWarnings::StandardWarning) { assert_equal(@n_root['three', true].name, 'three') }
+      assert_equal(@n_root['three'].name, 'three')
     end
 
     # Test the addition of a node to itself as a child
@@ -1485,10 +1412,10 @@ module TestTree
       setup_test_tree
 
       leafs = @root.each_leaf
-      parents = leafs.collect { |leaf| leaf.parent }
-      leafs.each { |leaf| leaf.remove_from_parent! }
+      parents = leafs.collect(&:parent)
+      leafs.each(&:remove_from_parent!)
       parents.each do |parent|
-        assert(parent.is_leaf?) unless parent.has_children?
+        assert(parent.leaf?) unless parent.children?
       end
     end