rubytree 0.9.7 → 2.0.0

data/test/test_binarytree.rb

@@ -3,7 +3,7 @@
 # test_binarytree.rb - This file is part of the RubyTree package.
 #
 #
-# Copyright (c) 2006, 2007, 2008, 2009, 2010, 2012, 2013, 2015 Anupam Sengupta
+# Copyright (c) 2006, 2007, 2008, 2009, 2010, 2012, 2013, 2015, 2017, 2022 Anupam Sengupta
 #
 # All rights reserved.
 #
@@ -32,20 +32,20 @@
 # (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 'tree/binarytree'
+require_relative '../lib/tree/binarytree'
 
 module TestTree
   # Test class for the binary tree node.
   class TestBinaryTreeNode < Test::Unit::TestCase
-
     # Setup the test data scaffolding.
     def setup
-      @root = Tree::BinaryTreeNode.new("ROOT", "Root Node")
+      @root = Tree::BinaryTreeNode.new('ROOT', 'Root Node')
 
-      @left_child1  = Tree::BinaryTreeNode.new("A Child at Left", "Child Node @ left")
-      @right_child1 = Tree::BinaryTreeNode.new("B Child at Right", "Child Node @ right")
+      @left_child1  = Tree::BinaryTreeNode.new('A Child at Left', 'Child Node @ left')
+      @right_child1 = Tree::BinaryTreeNode.new('B Child at Right', 'Child Node @ right')
     end
 
     # Tear down the test data scaffolding.
@@ -58,22 +58,22 @@ module TestTree
     # Test initialization of the binary tree.
     def test_initialize
       assert_not_nil(@root, "Binary tree's Root should have been created")
-      assert_nil(@root.left_child, "The initial left child of root should be nil")
-      assert_nil(@root.right_child, "The initial right child of root should be nil")
-      assert_equal(@root.children.size, 0, "Initially no children should be present")
+      assert_nil(@root.left_child, 'The initial left child of root should be nil')
+      assert_nil(@root.right_child, 'The initial right child of root should be nil')
+      assert_equal(@root.children.size, 0, 'Initially no children should be present')
     end
 
     def test_from_hash
       # Can't make a root node without a name
-      assert_raise (ArgumentError) { Tree::BinaryTreeNode.from_hash({})}
+      assert_raise(ArgumentError) { Tree::BinaryTreeNode.from_hash({}) }
       # Can't have multiple roots
-      assert_raise (ArgumentError) { Tree::BinaryTreeNode.from_hash({:A => {}, :B => {}}) }
+      assert_raise(ArgumentError) { Tree::BinaryTreeNode.from_hash({ A: {}, B: {} }) }
 
       # Can't have more than 2 children
-      too_many_kids = {:A => {:B => {}, :C => {}, :D => {} } }
+      too_many_kids = { A: { B: {}, C: {}, D: {} } }
       assert_raise(ArgumentError) { Tree::BinaryTreeNode.from_hash(too_many_kids) }
 
-      valid_hash = {:A => {:B => {}, :C => { :D => {} } } }
+      valid_hash = { A: { B: {}, C: { D: {} } } }
       tree = Tree::BinaryTreeNode.from_hash(valid_hash)
       #    A
       #   / \
@@ -83,24 +83,24 @@ module TestTree
 
       assert_same(tree.class, Tree::BinaryTreeNode)
       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(2, tree.children.count) # B, C, D
       assert_equal(4, tree.size)
 
-      valid_hash_with_content = {[:A, "Content!"] => {:B => {}, :C => { [:D, "More content"] => {} } } }
+      valid_hash_with_content = { [:A, 'Content!'] => { B: {}, C: { [:D, 'More content'] => {} } } }
       tree2 = Tree::BinaryTreeNode.from_hash(valid_hash_with_content)
 
       assert_equal(Tree::BinaryTreeNode, tree2.class)
-      assert_equal("Content!" , tree2.content)
-      assert_equal("More content", tree2[:C][:D].content)
+      assert_equal('Content!', tree2.content)
+      assert_equal('More content', tree2[:C][:D].content)
     end
 
     def test_add_from_hash
-      root = Tree::BinaryTreeNode.new("Root")
+      root = Tree::BinaryTreeNode.new('Root')
 
       # Can't have too many children
-      too_many_kids = {:child1 => {}, :child2 => {}, :child3 => {}}
+      too_many_kids = { child1: {}, child2: {}, child3: {} }
       assert_raise(ArgumentError) { root.add_from_hash(too_many_kids) }
       assert_equal(0, root.children.count) # Nothing added
 
@@ -108,7 +108,7 @@ module TestTree
       assert_equal([], root.add_from_hash({}))
       assert_equal(1, root.size)
 
-      valid_hash = {:A => {}, :B => { :C => {}, [:D, "leaf"] => {} } }
+      valid_hash = { A: {}, B: { C: {}, [:D, 'leaf'] => {} } }
       added = root.add_from_hash(valid_hash)
       #   root
       #   / \
@@ -120,48 +120,48 @@ module TestTree
       assert_equal(2, added.count)
       assert_equal(5, root.size)
       assert_equal(root.children.count, 2)
-      assert_equal("leaf", root[:B][:D].content)
+      assert_equal('leaf', root[:B][:D].content)
 
       # Can't add more than two children
-      assert_raise(ArgumentError) { root.add_from_hash({:X => {}}) }
-      node = Tree::BinaryTreeNode.new("Root 2")
-      assert_raise(ArgumentError) { node.add_from_hash({:A => {}, :B => {}, :C => {}}) }
+      assert_raise(ArgumentError) { root.add_from_hash({ X: {} }) }
+      node = Tree::BinaryTreeNode.new('Root 2')
+      assert_raise(ArgumentError) { node.add_from_hash({ A: {}, B: {}, C: {} }) }
     end
 
     # Test the add method.
     def test_add
       @root.add @left_child1
-      assert(!@left_child1.is_root?, "Left child1 cannot be a root after addition to the ROOT node")
+      assert(!@left_child1.root?, 'Left child1 cannot be a root after addition to the ROOT node')
 
-      assert_same(@left_child1, @root.left_child, "The left node should be left_child1")
-      assert_same(@left_child1, @root.first_child, "The first node should be left_child1")
+      assert_same(@left_child1, @root.left_child, 'The left node should be left_child1')
+      assert_same(@left_child1, @root.first_child, 'The first node should be left_child1')
 
       @root.add @right_child1
-      assert(!@right_child1.is_root?, "Right child1 cannot be a root after addition to the ROOT node")
+      assert(!@right_child1.root?, 'Right child1 cannot be a root after addition to the ROOT node')
 
-      assert_same(@right_child1, @root.right_child, "The right node should be right_child1")
-      assert_same(@right_child1, @root.last_child, "The first node should be right_child1")
+      assert_same(@right_child1, @root.right_child, 'The right node should be right_child1')
+      assert_same(@right_child1, @root.last_child, 'The first node should be right_child1')
 
       assert_raise ArgumentError do
-        @root.add Tree::BinaryTreeNode.new("The third child!")
+        @root.add Tree::BinaryTreeNode.new('The third child!')
       end
 
       assert_raise ArgumentError do
-        @root << Tree::BinaryTreeNode.new("The third child!")
+        @root << Tree::BinaryTreeNode.new('The third child!')
       end
     end
 
     # Test the inordered_each method.
     def test_inordered_each
-      a = Tree::BinaryTreeNode.new("a")
-      b = Tree::BinaryTreeNode.new("b")
-      c = Tree::BinaryTreeNode.new("c")
-      d = Tree::BinaryTreeNode.new("d")
-      e = Tree::BinaryTreeNode.new("e")
-      f = Tree::BinaryTreeNode.new("f")
-      g = Tree::BinaryTreeNode.new("g")
-      h = Tree::BinaryTreeNode.new("h")
-      i = Tree::BinaryTreeNode.new("i")
+      a = Tree::BinaryTreeNode.new('a')
+      b = Tree::BinaryTreeNode.new('b')
+      c = Tree::BinaryTreeNode.new('c')
+      d = Tree::BinaryTreeNode.new('d')
+      e = Tree::BinaryTreeNode.new('e')
+      f = Tree::BinaryTreeNode.new('f')
+      g = Tree::BinaryTreeNode.new('g')
+      h = Tree::BinaryTreeNode.new('h')
+      i = Tree::BinaryTreeNode.new('i')
 
       # Create the following Tree
       #        f         <-- level 0 (Root)
@@ -175,24 +175,25 @@ module TestTree
       f << g
       b << d << c
       d << e
-      g.right_child = i         # This needs to be explicit
+      g.right_child = i # This needs to be explicit
       i << h
 
       # The expected order of response
       expected_array = [a, b, c, d, e, f, g, h, i]
 
       result_array = []
-      result = f.inordered_each { |node| result_array << node.detached_copy}
+      result = f.inordered_each { |node| result_array << node.detached_copy }
 
-      assert_equal(f, result)   # each should return the original object
+      assert_equal(f, result) # each should return the original object
 
-      expected_array.each_index do |i|
+      expected_array.each_index do |idx|
         # Match only the names.
-        assert_equal(expected_array[i].name, result_array[i].name)
+        assert_equal(expected_array[idx].name, result_array[idx].name)
       end
 
-      assert_equal(Enumerator, f.inordered_each.class) if defined?(Enumerator.class )# Without a block
-      assert_equal(Enumerable::Enumerator, f.inordered_each.class) if defined?(Enumerable::Enumerator.class )# Without a block
+      assert_equal(Enumerator, f.inordered_each.class) if defined?(Enumerator.class) # Without a block
+
+      assert_equal(Enumerable::Enumerator, f.inordered_each.class) if defined?(Enumerable::Enumerator.class)
     end
 
     # Test the left_child method.
@@ -200,7 +201,7 @@ module TestTree
       @root << @left_child1
       @root << @right_child1
       assert_same(@left_child1, @root.left_child, "The left child should be 'left_child1")
-      assert_not_same(@right_child1, @root.left_child, "The right_child1 is not the left child")
+      assert_not_same(@right_child1, @root.left_child, 'The right_child1 is not the left child')
     end
 
     # Test the right_child method.
@@ -208,7 +209,7 @@ module TestTree
       @root << @left_child1
       @root << @right_child1
       assert_same(@right_child1, @root.right_child, "The right child should be 'right_child1")
-      assert_not_same(@left_child1, @root.right_child, "The left_child1 is not the left child")
+      assert_not_same(@left_child1, @root.right_child, 'The left_child1 is not the left child')
     end
 
     # Test left_child= method.
@@ -216,18 +217,18 @@ module TestTree
       @root << @left_child1
       @root << @right_child1
       assert_same(@left_child1, @root.left_child, "The left child should be 'left_child1")
-      assert(!@left_child1.is_root?, "The left child now cannot be a root.")
+      assert(!@left_child1.root?, 'The left child now cannot be a root.')
 
-      @root.left_child = Tree::BinaryTreeNode.new("New Left Child")
-      assert(!@root.left_child.is_root?, "The left child now cannot be a root.")
-      assert_equal("New Left Child", @root.left_child.name, "The left child should now be the new child")
-      assert_equal("B Child at Right", @root.last_child.name, "The last child should now be the right child")
+      @root.left_child = Tree::BinaryTreeNode.new('New Left Child')
+      assert(!@root.left_child.root?, 'The left child now cannot be a root.')
+      assert_equal('New Left Child', @root.left_child.name, 'The left child should now be the new child')
+      assert_equal('B Child at Right', @root.last_child.name, 'The last child should now be the right child')
 
       # Now set the left child as nil, and retest
       @root.left_child = nil
-      assert_nil(@root.left_child, "The left child should now be nil")
-      assert_nil(@root.first_child, "The first child is now nil")
-      assert_equal("B Child at Right", @root.last_child.name, "The last child should now be the right child")
+      assert_nil(@root.left_child, 'The left child should now be nil')
+      assert_nil(@root.first_child, 'The first child is now nil')
+      assert_equal('B Child at Right', @root.last_child.name, 'The last child should now be the right child')
     end
 
     # Test right_child= method.
@@ -235,19 +236,19 @@ module TestTree
       @root << @left_child1
       @root << @right_child1
       assert_same(@right_child1, @root.right_child, "The right child should be 'right_child1")
-      assert(!@right_child1.is_root?, "The right child now cannot be a root.")
+      assert(!@right_child1.root?, 'The right child now cannot be a root.')
 
-      @root.right_child = Tree::BinaryTreeNode.new("New Right Child")
-      assert(!@root.right_child.is_root?, "The right child now cannot be a root.")
-      assert_equal("New Right Child", @root.right_child.name, "The right child should now be the new child")
-      assert_equal("A Child at Left", @root.first_child.name, "The first child should now be the left child")
-      assert_equal("New Right Child", @root.last_child.name, "The last child should now be the right child")
+      @root.right_child = Tree::BinaryTreeNode.new('New Right Child')
+      assert(!@root.right_child.root?, 'The right child now cannot be a root.')
+      assert_equal('New Right Child', @root.right_child.name, 'The right child should now be the new child')
+      assert_equal('A Child at Left', @root.first_child.name, 'The first child should now be the left child')
+      assert_equal('New Right Child', @root.last_child.name, 'The last child should now be the right child')
 
       # Now set the right child as nil, and retest
       @root.right_child = nil
-      assert_nil(@root.right_child, "The right child should now be nil")
-      assert_equal("A Child at Left", @root.first_child.name, "The first child should now be the left child")
-      assert_nil(@root.last_child, "The first child is now nil")
+      assert_nil(@root.right_child, 'The right child should now be nil')
+      assert_equal('A Child at Left', @root.first_child.name, 'The first child should now be the left child')
+      assert_nil(@root.last_child, 'The first child is now nil')
     end
 
     # Test isLeft_child? method.
@@ -255,28 +256,28 @@ module TestTree
       @root << @left_child1
       @root << @right_child1
 
-      assert(@left_child1.is_left_child?, "left_child1 should be the left child")
-      assert(!@right_child1.is_left_child?, "left_child1 should be the left child")
+      assert(@left_child1.left_child?, 'left_child1 should be the left child')
+      assert(!@right_child1.left_child?, 'left_child1 should be the left child')
 
       # Now set the right child as nil, and retest
       @root.right_child = nil
-      assert(@left_child1.is_left_child?, "left_child1 should be the left child")
+      assert(@left_child1.left_child?, 'left_child1 should be the left child')
 
-      assert(!@root.is_left_child?, "Root is neither left child nor right")
+      assert(!@root.left_child?, 'Root is neither left child nor right')
     end
 
-    # Test is_right_child? method.
+    # Test right_child? method.
     def test_is_right_child_eh
       @root << @left_child1
       @root << @right_child1
 
-      assert(@right_child1.is_right_child?, "right_child1 should be the right child")
-      assert(!@left_child1.is_right_child?, "right_child1 should be the right child")
+      assert(@right_child1.right_child?, 'right_child1 should be the right child')
+      assert(!@left_child1.right_child?, 'right_child1 should be the right child')
 
       # Now set the left child as nil, and retest
       @root.left_child = nil
-      assert(@right_child1.is_right_child?, "right_child1 should be the right child")
-      assert(!@root.is_right_child?, "Root is neither left child nor right")
+      assert(@right_child1.right_child?, 'right_child1 should be the right child')
+      assert(!@root.right_child?, 'Root is neither left child nor right')
     end
 
     # Test swap_children method.
@@ -284,37 +285,17 @@ module TestTree
       @root << @left_child1
       @root << @right_child1
 
-      assert(@right_child1.is_right_child?, "right_child1 should be the right child")
-      assert(!@left_child1.is_right_child?, "right_child1 should be the right child")
+      assert(@right_child1.right_child?, 'right_child1 should be the right child')
+      assert(!@left_child1.right_child?, 'right_child1 should be the right child')
 
       @root.swap_children
 
-      assert(@right_child1.is_left_child?, "right_child1 should now be the left child")
-      assert(@left_child1.is_right_child?, "left_child1 should now be the right child")
-      assert_equal(@right_child1, @root.first_child, "right_child1 should now be the first child")
-      assert_equal(@left_child1, @root.last_child, "left_child1 should now be the last child")
-      assert_equal(@right_child1, @root[0], "right_child1 should now be the first child")
-      assert_equal(@left_child1, @root[1], "left_child1 should now be the last child")
+      assert(@right_child1.left_child?, 'right_child1 should now be the left child')
+      assert(@left_child1.right_child?, 'left_child1 should now be the right child')
+      assert_equal(@right_child1, @root.first_child, 'right_child1 should now be the first child')
+      assert_equal(@left_child1, @root.last_child, 'left_child1 should now be the last child')
+      assert_equal(@right_child1, @root[0], 'right_child1 should now be the first child')
+      assert_equal(@left_child1, @root[1], 'left_child1 should now be the last child')
     end
-
-    # Test the old CamelCase method names
-    def test_old_camelCase_method_names
-      @left_child2  = Tree::BinaryTreeNode.new("A Child at Left", "Child Node @ left")
-      @right_child2 = Tree::BinaryTreeNode.new("B Child at Right", "Child Node @ right")
-
-      require 'structured_warnings'
-
-      meth_names_for_test = %w{leftChild isLeftChild? rightChild isRightChild?}
-
-      meth_names_for_test.each do |meth_name|
-        assert_warn(DeprecatedMethodWarning) {@root.send(meth_name)}
-      end
-
-      assert_warn(DeprecatedMethodWarning) {@root.leftChild = @left_child2}
-      assert_warn(DeprecatedMethodWarning) {@root.rightChild = @right_child2}
-      assert_raise(NoMethodError) {@root.to_snake_case("ABCD")} # Make sure the right method is visible
-
-    end
-
   end
 end

data/test/test_rubytree_require.rb

@@ -2,7 +2,7 @@
 
 # test_rubytree_require.rb - This file is part of the RubyTree package.
 #
-# Copyright (c) 2012 Anupam Sengupta
+# Copyright (c) 2012, 2022 Anupam Sengupta
 #
 # All rights reserved.
 #
@@ -31,18 +31,17 @@
 # (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 'rubytree'
+require_relative '../lib/rubytree'
 
 module TestTree
-
   # Test class for checking whether require 'rubytree' works.
   class TestRequireRubytree < Test::Unit::TestCase
-
     # A simple test.  We are just checking whether the require worked.
     def test_create_a_simple_node
-      assert_not_nil(Tree::TreeNode.new("Root", "A Root node"))
+      assert_not_nil(Tree::TreeNode.new('Root', 'A Root node'))
     end
   end
 end

data/test/test_subclassed_node.rb

@@ -2,7 +2,7 @@
 
 # test_subclassed_node.rb - This file is part of the RubyTree package.
 #
-# Copyright (c) 2012 Anupam Sengupta
+# Copyright (c) 2012, 2017, 2022 Anupam Sengupta
 #
 # All rights reserved.
 #
@@ -31,44 +31,23 @@
 # (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 'json'
-require 'tree'
+require_relative '../lib/tree'
 
 module TestTree
-
   # Test class for the Tree node.
   class TestSubclassedTreeNode < Test::Unit::TestCase
-
     # A subclassed node to test various inheritance related features.
     class MyNode < Tree::TreeNode
-      # A dummy method to test the camelCasedMethod resolution
-      def my_dummy_method
-        "Hello"
-      end
     end
 
-    def test_subclassed_camelcase_methods
-      root = MyNode.new("Root")
-
-      assert_equal("Hello", root.my_dummy_method)
-
-      # We should get a warning as we are invoking the camelCase version of the dummy method.
-      assert_warn(DeprecatedMethodWarning) { root.send('MyDummyMethod') }
-
-      # Test if the structured_warnings can be disabled to call the CamelCa
-      DeprecatedMethodWarning.disable do
-        assert_equal("Hello", root.myDummyMethod)
-      end
-
-    end
-
-    def test_subclassed_detached_copy_is_same_class
-      root = MyNode.new("Root")
+    def test_detached_copy_same_clz
+      root = MyNode.new('Root')
       assert_equal(MyNode, root.detached_copy.class)
     end
-
   end
 end
 

data/test/test_thread_and_fiber.rb

@@ -2,7 +2,7 @@
 
 # test_thread_and_fiber.rb - This file is part of the RubyTree package.
 #
-# Copyright (c) 2012, 2013 Anupam Sengupta
+# Copyright (c) 2012, 2013, 2022 Anupam Sengupta
 #
 # All rights reserved.
 #
@@ -31,26 +31,25 @@
 # (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 'json'
-require 'tree'
+require_relative '../lib/tree'
 
 module TestTree
   # Test class for the Tree node.
   class TestFiberAndThreadOnNode < Test::Unit::TestCase
-
     # Test long and unbalanced trees
-    def create_long_depth_trees(depth=100)
-      tree = Tree::TreeNode.new("/")
+    def create_long_depth_trees(depth = 100)
+      tree = Tree::TreeNode.new('/')
       current = tree
       depth.times do |i|
-        new_node = Tree::TreeNode.new("#{i}")
+        new_node = Tree::TreeNode.new(i.to_s)
         current << new_node
         current = new_node
       end
 
-      tree.each { |n| nil }
       tree
     end
 
@@ -58,30 +57,28 @@ module TestTree
     # failure for very large depths on unbalanced nodes.
     def test_fiber_for_recursion
       return unless defined?(Fiber.class) # Fibers exist only from Ruby 1.9 onwards.
+
       assert_nothing_thrown do
         Fiber.new do
-          depth = 1000             # Use a reasonably large depth, which would trip a recursive stack
+          depth = 1000 # Use a reasonably large depth, which would trip a recursive stack
           root = create_long_depth_trees(depth)
-          assert_equal(depth+1, root.size)
+          assert_equal(depth + 1, root.size)
         end.resume
       end
-
-    end # test_fiber
+    end
 
     # Test the recursive methods with a thread. The stack usage is causing
     # failure for very large depths on unbalanced nodes.
     def test_thread_for_recursion
       assert_nothing_thrown do
-        depth = 1000             # Use a reasonably large depth, which would trip a recursive stack
+        depth = 1000 # Use a reasonably large depth, which would trip a recursive stack
         Thread.abort_on_exception = true
         Thread.new do
           root = create_long_depth_trees(depth)
-          assert_equal(depth+1, root.size)
+          assert_equal(depth + 1, root.size)
         end
       end
-
-    end # test_thread
-
+    end
   end
 end