rubytree 0.9.5 → 1.0.2

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+#
+# spec_helper.rb
+#
+# Author:  Anupam Sengupta
+# Time-stamp: <2015-12-31 21:00:36 anupam>
+# Copyright (C) 2015 Anupam Sengupta <anupamsg@gmail.com>
+#
+
+require 'tree'

data/spec/tree_spec.rb

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+#
+# tree_spec.rb
+#
+# Author:  Anupam Sengupta
+# Time-stamp: <2015-12-31 22:57:59 anupam>
+# Copyright (C) 2015 Anupam Sengupta <anupamsg@gmail.com>
+#
+
+require 'rspec'
+require 'spec_helper'
+
+describe Tree do
+  shared_examples_for 'any detached node' do
+    it 'should not equal "Object.new"' do
+      expect(@tree).not_to eq(Object.new)
+    end
+    it 'should not equal 1 or any other fixnum' do
+      expect(@tree).not_to eq(1)
+    end
+    it 'identifies itself as a root node' do
+      expect(@tree.is_root?).to eq(true)
+    end
+    it 'does not have a parent node' do
+      expect(@tree.parent).to eq(nil)
+    end
+  end
+  context '#initialize', 'with empty name and nil content' do
+    before(:each) do
+      @tree = Tree::TreeNode.new('')
+    end
+    it 'creates the tree node with name as ""' do
+      expect(@tree.name).to eq('')
+    end
+    it "has 'nil' content" do
+      expect(@tree.content).to eq(nil)
+    end
+
+    it_behaves_like 'any detached node'
+  end
+
+  context '#initialize', "with name 'A' and nil content" do
+    before(:each) do
+      @tree = Tree::TreeNode.new('A')
+    end
+
+    it 'creates the tree node with name as "A"' do
+      expect(@tree.name).to eq('A')
+    end
+    it "has 'nil' content" do
+      expect(@tree.content).to eq(nil)
+    end
+
+    it_behaves_like 'any detached node'
+  end
+
+  context '#initialize', "with node name 'A' and some content" do
+    before(:each) do
+      @sample = 'sample'
+      @tree = Tree::TreeNode.new('A', @sample)
+    end
+
+    it 'creates the tree node with name as "A"' do
+      expect(@tree.name).to eq('A')
+    end
+    it "has some content #{@sample}" do
+      expect(@tree.content).to eq(@sample)
+    end
+
+    it_behaves_like 'any detached node'
+  end
+end

data/test/run_test.rb

@@ -32,13 +32,13 @@
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
 
-base_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
-lib_dir  = File.join(base_dir, "lib")
-test_dir = File.join(base_dir, "test")
+base_dir = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+lib_dir  = File.join(base_dir, 'lib')
+test_dir = File.join(base_dir, 'test')
 
 $LOAD_PATH.unshift(lib_dir)
 
-if ENV["COVERAGE"]
+if ENV['COVERAGE']
   begin
     require 'simplecov'
     require 'coveralls'
@@ -51,10 +51,10 @@ if ENV["COVERAGE"]
       add_group 'Internal Utilities', '/lib/tree/utils/.*.rb'
     end
   rescue LoadError => e
-    puts "Could not load simplecov; continuing without code coverage"
+    puts 'Could not load simplecov; continuing without code coverage' + e.cause
   end
 end
 
 require 'test/unit'
 
-exit Test::Unit::AutoRunner.run(true, test_dir)
+Test::Unit::AutoRunner.run(true, test_dir)

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 Anupam Sengupta
 #
 # All rights reserved.
 #
@@ -34,18 +34,17 @@
 #
 
 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 +57,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
       #   / \
@@ -88,19 +87,19 @@ module TestTree
       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 +107,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 +119,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.is_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.is_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 +174,26 @@ 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
+      if defined?(Enumerable::Enumerator.class)
+        assert_equal(Enumerable::Enumerator, f.inordered_each.class)
+      end # Without a block
     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.is_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.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')
 
       # 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.is_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.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')
 
       # 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,14 +256,14 @@ 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.is_left_child?, 'left_child1 should be the left child')
+      assert(!@right_child1.is_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.is_left_child?, 'left_child1 should be the left child')
 
-      assert(!@root.is_left_child?, "Root is neither left child nor right")
+      assert(!@root.is_left_child?, 'Root is neither left child nor right')
     end
 
     # Test is_right_child? method.
@@ -270,13 +271,13 @@ 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.is_right_child?, 'right_child1 should be the right child')
+      assert(!@left_child1.is_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.is_right_child?, 'right_child1 should be the right child')
+      assert(!@root.is_right_child?, 'Root is neither left child nor right')
     end
 
     # Test swap_children method.
@@ -284,37 +285,37 @@ 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.is_right_child?, 'right_child1 should be the right child')
+      assert(!@left_child1.is_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.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')
     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")
+    def test_old_camel_case_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 = %w[leftChild isLeftChild? rightChild isRightChild?]
 
       meth_names_for_test.each do |meth_name|
-        assert_warn(DeprecatedMethodWarning) {@root.send(meth_name)}
+        assert_warn(StructuredWarnings::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
-
+      # noinspection RubyResolve
+      assert_warn(StructuredWarnings::DeprecatedMethodWarning) { @root.leftChild = @left_child2 }
+      # noinspection RubyResolve
+      assert_warn(StructuredWarnings::DeprecatedMethodWarning) { @root.rightChild = @right_child2 }
+      assert_raise(NoMethodError) { @root.DummyMethodDoesNotExist } # Make sure the right method is visible
     end
-
   end
 end

data/test/test_rubytree_require.rb

@@ -33,16 +33,14 @@
 #
 
 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 Anupam Sengupta
 #
 # All rights reserved.
 #
@@ -34,41 +34,38 @@
 
 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"
+        'Hello'
       end
     end
 
-    def test_subclassed_camelcase_methods
-      root = MyNode.new("Root")
+    def test_camelcase_methods
+      root = MyNode.new('Root')
 
-      assert_equal("Hello", root.my_dummy_method)
+      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') }
+      assert_warn(StructuredWarnings::DeprecatedMethodWarning) { root.send('MyDummyMethod') }
 
-      # Test if the structured_warnings can be disabled to call the CamelCa
-      DeprecatedMethodWarning.disable do
-        assert_equal("Hello", root.myDummyMethod)
+      # Test if the structured_warnings can be disabled to call the CamelCase methods.
+      StructuredWarnings::DeprecatedMethodWarning.disable do
+        # noinspection RubyResolve
+        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

@@ -34,23 +34,22 @@
 
 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.each { |_| 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
 
     # 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