rubytree 0.8.3 → 0.9.0

data/lib/tree/utils/tree_merge_handler.rb

@@ -0,0 +1,118 @@
+#!/usr/bin/env ruby
+#
+# tree_merge_handler.rb
+#
+# Author:  Anupam Sengupta
+# Time-stamp: <2013-12-31 21:52:59 anupam>
+#
+# Copyright (C) 2013 Anupam Sengupta (anupamsg@gmail.com)
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# - Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+#
+# - Redistributions in binary form must reproduce the above copyright notice, this
+#   list of conditions and the following disclaimer in the documentation and/or
+#   other materials provided with the distribution.
+#
+# - Neither the name of the organization nor the names of its contributors may
+#   be used to endorse or promote products derived from this software without
+#   specific prior written permission.
+#
+#   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+# Provides utility methods to merge two {Tree::TreeNode} based trees.
+# @since 0.9.0
+module Tree::Utils::TreeMergeHandler
+
+  # @!group Merging Trees
+
+  # Merge two trees that share the same root node and returns <em>a new tree</em>.
+  #
+  # The new tree contains the contents of the merge between _other_tree_ and
+  # self. Duplicate nodes (coming from _other_tree_) will *NOT* be overwritten
+  # in self.
+  #
+  # @author Darren Oakley (https://github.com/dazoakley)
+  #
+  # @param [Tree::TreeNode] other_tree The other tree to merge with.
+  # @return [Tree::TreeNode] the resulting tree following the merge.
+  #
+  # @raise [TypeError] This exception is raised if _other_tree_ is not a {Tree::TreeNode}.
+  # @raise [ArgumentError] This exception is raised if _other_tree_ does not have the same root node as self.
+  def merge(other_tree)
+    check_merge_prerequisites(other_tree)
+    new_tree = merge_trees( self.root.dup, other_tree.root )
+  end
+
+  # Merge in another tree (that shares the same root node) into +this+ tree.
+  # Duplicate nodes (coming from _other_tree_) will NOT be overwritten in
+  # self.
+  #
+  # @author Darren Oakley (https://github.com/dazoakley)
+  #
+  # @param [Tree::TreeNode] other_tree The other tree to merge with.
+  #
+  # @raise [TypeError] This exception is raised if _other_tree_ is not a {Tree::TreeNode}.
+  # @raise [ArgumentError] This exception is raised if _other_tree_ does not have the same root node as self.
+  def merge!(other_tree)
+    check_merge_prerequisites( other_tree )
+    merge_trees( self.root, other_tree.root )
+  end
+
+  private
+
+  # Utility function to check that the conditions for a tree merge are met.
+  #
+  # @author Darren Oakley (https://github.com/dazoakley)
+  #
+  # @see #merge
+  # @see #merge!
+  def check_merge_prerequisites(other_tree)
+    unless other_tree.is_a?(Tree::TreeNode)
+      raise TypeError, 'You can only merge in another instance of Tree::TreeNode'
+    end
+
+    unless self.root.name == other_tree.root.name
+      raise ArgumentError, 'Unable to merge trees as they do not share the same root'
+    end
+  end
+
+  # Utility function to recursivley merge two subtrees.
+  #
+  # @author Darren Oakley (https://github.com/dazoakley)
+  #
+  # @param [Tree::TreeNode] tree1 The target tree to merge into.
+  # @param [Tree::TreeNode] tree2 The donor tree (that will be merged into target).
+  # @raise [Tree::TreeNode] The merged tree.
+  def merge_trees(tree1, tree2)
+    names1 = tree1.has_children? ? tree1.children.map { |child| child.name } : []
+    names2 = tree2.has_children? ? tree2.children.map { |child| child.name } : []
+
+    names_to_merge = names2 - names1
+    names_to_merge.each do |name|
+      tree1 << tree2[name].detached_subtree_copy
+    end
+
+    tree1.children.each do |child|
+      merge_trees( child, tree2[child.name] ) unless tree2[child.name].nil?
+    end
+
+    return tree1
+  end
+
+end

data/lib/tree/utils/utils.rb

@@ -0,0 +1,41 @@
+# utils.rb - This file is part of the RubyTree package.
+#
+# = utils.rb - Provides utility functions and mixins for RubyTree.
+#
+# Author::  Anupam Sengupta (anupamsg@gmail.com)
+#
+# Time-stamp: <2012-08-25 22:01:17 anupam>
+#
+# Copyright (C) 2012 Anupam Sengupta <anupamsg@gmail.com>
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# - Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+#
+# - Redistributions in binary form must reproduce the above copyright notice, this
+#   list of conditions and the following disclaimer in the documentation and/or
+#   other materials provided with the distribution.
+#
+# - Neither the name of the organization nor the names of its contributors may
+#   be used to endorse or promote products derived from this software without
+#   specific prior written permission.
+#
+#   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# Provides utilities and mixin modules for RubyTree.
+module Tree::Utils
+  # Empty module.  Being used as a namespace.
+end

data/lib/tree/version.rb

@@ -1,11 +1,10 @@
-#--
 # version.rb - This file is part of the RubyTree package.
 #
 # This file provides the version number for Rubytree.
 #
 # Author:: Anupam Sengupta (anupamsg@gmail.com)
 #
-# Copyright (c) 2012 Anupam Sengupta
+# Copyright (c) 2012, 2013 Anupam Sengupta
 #
 # All rights reserved.
 #
@@ -35,7 +34,8 @@
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
 
+#
 module Tree
   # Rubytree Package Version
-  VERSION = '0.8.3'
+  VERSION = '0.9.0'
 end

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 Anupam Sengupta
+# Copyright (c) 2006, 2007, 2008, 2009, 2010, 2012, 2013 Anupam Sengupta
 #
 # All rights reserved.
 #
@@ -86,6 +86,50 @@ module TestTree
       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")
+
+      # Create the following Tree
+      #        f         <-- level 0 (Root)
+      #      /   \
+      #     b      g     <-- level 1
+      #   /   \      \
+      #  a     d      i  <-- level 2
+      #       / \    /
+      #      c  e   h    <-- level 3
+      f << b << a
+      f << g
+      b << d << c
+      d << e
+      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}
+
+      assert_equal(result, f)   # each should return the original object
+
+      expected_array.each_index do |i|
+        # Match only the names.
+        assert_equal(expected_array[i].name, result_array[i].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
+    end
+
     # Test the left_child method.
     def test_left_child
       @root << @left_child1
@@ -203,6 +247,7 @@ module TestTree
 
       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
 

data/test/test_subclassed_node.rb

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+
+# test_subclassed_node.rb - This file is part of the RubyTree package.
+#
+# Copyright (c) 2012 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:
+#
+# - Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+#
+# - Redistributions in binary form must reproduce the above copyright notice, this
+#   list of conditions and the following disclaimer in the documentation and/or
+#   other materials provided with the distribution.
+#
+# - Neither the name of the organization nor the names of its contributors may
+#   be used to endorse or promote products derived from this software without
+#   specific prior written permission.
+#
+#   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+require 'test/unit'
+require 'json'
+require '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
+
+  end
+end
+
+__END__

data/test/test_thread_and_fiber.rb

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+
+# test_thread_and_fiber.rb - This file is part of the RubyTree package.
+#
+# Copyright (c) 2012, 2013 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:
+#
+# - Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+#
+# - Redistributions in binary form must reproduce the above copyright notice, this
+#   list of conditions and the following disclaimer in the documentation and/or
+#   other materials provided with the distribution.
+#
+# - Neither the name of the organization nor the names of its contributors may
+#   be used to endorse or promote products derived from this software without
+#   specific prior written permission.
+#
+#   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+require 'test/unit'
+require 'json'
+require '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("/")
+      current = tree
+      depth.times do |i|
+        new_node = Tree::TreeNode.new("#{i}")
+        current << new_node
+        current = new_node
+      end
+
+      tree.each { |n| nil }
+      tree
+    end
+
+    # Test the recursive methods with a fiber. The stack usage is causing
+    # 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
+          root = create_long_depth_trees(depth)
+          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
+        Thread.abort_on_exception = true
+        Thread.new do
+          root = create_long_depth_trees(depth)
+          assert_equal(depth+1, root.size)
+        end
+      end
+
+    end # test_thread
+
+  end
+end
+
+__END__

data/test/test_tree.rb

@@ -2,7 +2,7 @@
 
 # test_tree.rb - This file is part of the RubyTree package.
 #
-# Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Anupam Sengupta
+# Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Anupam Sengupta
 #
 # All rights reserved.
 #
@@ -145,7 +145,6 @@ module TestTree
       first_node  = Tree::TreeNode.new(1)
       second_node = Tree::TreeNode.new(2)
 
-
       assert_equal(first_node <=> nil, +1)
       assert_equal(first_node <=> second_node, -1)
 
@@ -164,6 +163,24 @@ module TestTree
       StandardWarning.enable
     end
 
+    # Test the inclusion of Comparable
+    def test_is_comparable
+      nodeA = Tree::TreeNode.new("NodeA", "Some Content")
+      nodeB = Tree::TreeNode.new("NodeB", "Some Content")
+      nodeC = Tree::TreeNode.new("NodeC", "Some Content")
+
+      # Check if the nodes compare correctly
+      assert(nodeA <  nodeB, "Node A is lexically 'less than' node B")
+      assert(nodeA <= nodeB, "Node A is lexically 'less than' node B")
+      assert(nodeB >  nodeA, "Node B is lexically 'greater than' node A")
+      assert(nodeB >= nodeA, "Node B is lexically 'greater than' node A")
+
+      assert(!(nodeA == nodeB), "Node A and Node B are not equal")
+      assert(nodeB.between?(nodeA, nodeC), "Node B is lexically between node A and node C")
+
+
+    end
+
     # Test the to_s method.  This is probably a little fragile right now.
     def test_to_s
       a_node = Tree::TreeNode.new("A Node", "Some Content")
@@ -250,14 +267,16 @@ module TestTree
 
       # Lets first collect the siblings in an array.
       siblings = []
-      @child1.siblings { |sibling| siblings << sibling}
+      result = @child1.siblings { |sibling| siblings << sibling}
 
+      assert_equal(@child1, result)
       assert_equal(2, siblings.length, "Should have two siblings")
       assert(siblings.include?(@child2), "Should have 2nd child as sibling")
       assert(siblings.include?(@child3), "Should have 3rd child as sibling")
 
       siblings.clear
       siblings = @child1.siblings
+      assert_equal(Array, siblings.class)
       assert_equal(2, siblings.length, "Should have two siblings")
 
       siblings.clear
@@ -267,6 +286,7 @@ module TestTree
       siblings.clear
       siblings = @root.siblings
       assert_equal(0, siblings.length, "Root should not have any siblings")
+
     end
 
     # Test the is_only_child? method.
@@ -465,21 +485,26 @@ module TestTree
         assert_equal(0, child.node_height, "The subtree at #{child.name} should have a height of 0")
       end
 
-      children = []
-      for child in @root.children
-        children << child
-      end
+      result_array = @root.children
+
+      assert_equal(3, result_array.length, "Should have three direct children")
+      assert(!result_array.include?(@root), "Should not have root")
+      assert_equal(result_array[0], @child1, "Should have child 1")
+      assert_equal(result_array[1], @child2, "Should have child 2")
+      assert_equal(result_array[2], @child3, "Should have child 3")
+      assert(!result_array.include?(@child4), "Should not have child 4")
+
+      # Lets try the block version of the method.
+      result_array.clear
+      result = @root.children {|child| result_array << child}
+      assert_equal(@root, result)
+      result_array.length
+      assert_equal(3, result_array.length, "Should have three children")
+      assert_equal(result_array[0], @child1, "Should have child 1")
+      assert_equal(result_array[1], @child2, "Should have child 2")
+      assert_equal(result_array[2], @child3, "Should have child 3")
+      assert(!result_array.include?(@child4), "Should not have child 4")
 
-      assert_equal(3, children.length, "Should have three direct children")
-      assert(!children.include?(@root), "Should not have root")
-      assert(children.include?(@child1), "Should have child 1")
-      assert(children.include?(@child2), "Should have child 2")
-      assert(children.include?(@child3), "Should have child 3")
-      assert(!children.include?(@child4), "Should not have child 4")
-
-      children.clear
-      children = @root.children
-      assert_equal(3, children.length, "Should have three children")
     end
 
     # Test the first_child method.
@@ -547,15 +572,27 @@ module TestTree
     def test_each_leaf
       setup_test_tree
 
-      nodes = []
-      @root.each_leaf { |node| nodes << node }
+      result_array = []
+      result = @root.each_leaf { |node| result_array << node }
+      assert_equal(@root, result)
+      assert_equal(3, result_array.length, "Should have THREE LEAF NODES")
+      assert(!result_array.include?(@root), "Should not have root")
+      assert(result_array.include?(@child1), "Should have child 1")
+      assert(result_array.include?(@child2), "Should have child 2")
+      assert(!result_array.include?(@child3), "Should not have child 3")
+      assert(result_array.include?(@child4), "Should have child 4")
+
+      # Now lets try without the block
+      result_array.clear
+      result_array = @root.each_leaf
+      assert_equal(Array, result_array.class)
+      assert_equal(3, result_array.length, "Should have THREE LEAF NODES")
+      assert(!result_array.include?(@root), "Should not have root")
+      assert(result_array.include?(@child1), "Should have child 1")
+      assert(result_array.include?(@child2), "Should have child 2")
+      assert(!result_array.include?(@child3), "Should not have child 3")
+      assert(result_array.include?(@child4), "Should have child 4")
 
-      assert_equal(3, nodes.length, "Should have THREE LEAF NODES")
-      assert(!nodes.include?(@root), "Should not have root")
-      assert(nodes.include?(@child1), "Should have child 1")
-      assert(nodes.include?(@child2), "Should have child 2")
-      assert(!nodes.include?(@child3), "Should not have child 3")
-      assert(nodes.include?(@child4), "Should have child 4")
     end
 
     # Test the parent method.
@@ -795,11 +832,15 @@ module TestTree
 
       # Create the response
       result_array = Array.new
-      j.breadth_each { |node| result_array << node.detached_copy }
+      result = j.breadth_each { |node| result_array << node.detached_copy }
 
+      assert_equal(j, result)
       expected_array.each_index do |i|
         assert_equal(expected_array[i].name, result_array[i].name)      # Match only the names.
       end
+
+      assert_equal(Enumerator, j.breadth_each.class) if defined?(Enumerator.class )# Without a block
+      assert_equal(Enumerable::Enumerator, j.breadth_each.class) if defined?(Enumerable::Enumerator.class )# Without a block
     end
 
     # Test the preordered_each method.
@@ -828,12 +869,56 @@ module TestTree
       j << k << z
 
       result_array = []
-      j.preordered_each { |node| result_array << node.detached_copy}
+      result = j.preordered_each { |node| result_array << node.detached_copy}
+
+      assert_equal(j, result)   # Each returns the invocation target
 
       expected_array.each_index do |i|
         # Match only the names.
         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
+      assert_equal(Enumerable::Enumerator, j.preordered_each.class) if defined?(Enumerable::Enumerator.class )# Without a block
+    end
+
+    # Test the postordered_each method.
+    def test_postordered_each
+      j = Tree::TreeNode.new("j")
+      f = Tree::TreeNode.new("f")
+      k = Tree::TreeNode.new("k")
+      a = Tree::TreeNode.new("a")
+      d = Tree::TreeNode.new("d")
+      h = Tree::TreeNode.new("h")
+      z = Tree::TreeNode.new("z")
+
+      # The expected order of response
+      expected_array = [d, a, h, f, z, k, j]
+
+      # Create the following Tree
+      #        j         <-- level 0 (Root)
+      #      /   \
+      #     f      k     <-- level 1
+      #   /   \      \
+      #  a     h      z  <-- level 2
+      #   \
+      #    d             <-- level 3
+      j << f << a << d
+      f << h
+      j << k << z
+
+      result_array = []
+      result = j.postordered_each { |node| result_array << node.detached_copy}
+
+      assert_equal(j, result)   # Each returns the invocation target
+
+      expected_array.each_index do |i|
+        # Match only the names.
+        assert_equal(expected_array[i].name, result_array[i].name)
+      end
+
+      assert_equal(Enumerator, j.postordered_each.class) if defined?(Enumerator.class )# Without a block
+      assert_equal(Enumerable::Enumerator, j.postordered_each.class) if defined?(Enumerable::Enumerator.class )# Without a block
     end
 
     # test the detached_copy method.
@@ -1021,7 +1106,7 @@ module TestTree
         ]
       }.to_json
 
-      tree = JSON.parse(tree_as_json)
+      tree = JSON.parse(tree_as_json, :create_additions => true)
 
       assert_equal(@root.name, tree.root.name, "Root should be returned")
       assert_equal(@child1.name, tree[0].name, "Child 1 should be returned")
@@ -1037,7 +1122,7 @@ module TestTree
 
       j = root_node.to_json
 
-      k = JSON.parse(j)
+      k = JSON.parse(j, :create_additions => true)
 
       assert_equal(k.name, root_node.name, "Root should be returned")
       assert_equal(k[0].name, root_node[0].name, "Child 1 should be returned")
@@ -1050,10 +1135,10 @@ module TestTree
       setup_test_tree
 
       meth_names_to_test = %w{isRoot? isLeaf? hasContent?
-                              hasChildren? setAsRoot! firstChild lastChild
+                              hasChildren? firstChild lastChild
                               firstSibling isFirstSibling? lastSibling isLastSibling?
                               isOnlyChild? nextSibling previousSibling nodeHeight nodeDepth
-                              createDumpRep removeFromParent! removeAll! freezeTree! }
+                              removeFromParent! removeAll! freezeTree! }
 
       require 'structured_warnings'
 
@@ -1065,7 +1150,7 @@ module TestTree
         assert_warn(DeprecatedMethodWarning) {@root.send(meth_name)}
       end
 
-        # Special Case for printTree to avoid putting stuff on the STDOUT during the unit test.
+      # Special Case for printTree to avoid putting stuff on the STDOUT during the unit test.
       begin
         require 'stringio'
         $stdout = StringIO.new
@@ -1115,10 +1200,8 @@ module TestTree
       assert_raise(ArgumentError) {root << root}
 
       # And now a scenario where the node addition is done down the hierarchy
-      # @todo This scenario is not yet fixed.
       child =  Tree::TreeNode.new("child")
-      root << child << root
-      # puts root                 # This will throw a stack trace
+      assert_raise(RuntimeError) { root << child << root }
     end
 
     # Test whether the tree_leaf method works correctly
@@ -1132,6 +1215,97 @@ module TestTree
 
     end
 
+    # Test if node names are really unique in the whole tree
+    def test_unique_node_names
+      setup_test_tree
+
+      assert_raise(RuntimeError) { @root << @child1 }
+      assert_raise(RuntimeError) { @root.first_child << @child2 }
+    end
+
+    # Setup function to build some extra trees to play with.
+    def setup_other_test_tree
+      # Build up another tree
+      #
+      # ROOT
+      #  |
+      #  |-- Child1
+      #  |    |
+      #  |    |-- Child1a
+      #  |    |-- Child1b
+      #  |
+      #  |-- Child3
+      #       |
+      #       |-- Child3a -- Child3a1
+      #
+      @other_tree = @root.detached_copy
+      @other_tree << @child1.detached_copy
+      @other_tree["Child1"] << Tree::TreeNode.new("Child1a", "GrandChild Node 1a")
+      @other_tree["Child1"] << Tree::TreeNode.new("Child1b", "GrandChild Node 1b")
+      @other_tree << @child3.detached_copy
+      @other_tree["Child3"] << Tree::TreeNode.new("Child3a", "GrandChild Node 3a")
+      @other_tree["Child3"]["Child3a"] << Tree::TreeNode.new("Child3a1", "GreatGrandChild Node 3a1")
+
+      # And another (different) one so we can test exceptions...
+      @other_tree2 = Tree::TreeNode.new("ROOTIE", "A different root")
+      @other_tree2 << Tree::TreeNode.new("new_child1", "New Child 1")
+    end
+
+    # Test tree merging.
+    def test_merge
+      setup_test_tree
+      setup_other_test_tree
+
+      merged_tree = @root.merge(@other_tree)
+
+      # puts "\n\ntest_merge:\n\n"
+      # @root.print_tree
+      # puts "\n"
+      # @other_tree.print_tree
+      # puts "\n"
+      # merged_tree.print_tree
+
+      assert( @root["Child1"]["Child1a"].nil?, ".merge() has altered self." )
+      assert( @root["Child1"]["Child1b"].nil?, ".merge() has altered self." )
+      assert( @root["Child3"]["Child3a"].nil?, ".merge() has altered self." )
+      assert( merged_tree.is_a?(Tree::TreeNode) )
+      assert( !merged_tree["Child1"]["Child1a"].nil?, ".merge() has not included ['Child1']['Child1a'] from other_tree." )
+      assert( !merged_tree["Child1"]["Child1b"].nil?, ".merge() has not included ['Child1']['Child1b'] from other_tree." )
+      assert( !merged_tree["Child3"]["Child3a"].nil?, ".merge() has not included ['Child3']['Child3a'] from other_tree." )
+      assert( !merged_tree["Child2"].nil?, ".merge() has not included ['Child2'] from self." )
+      assert( !merged_tree["Child3"]["Child3a"]["Child3a1"].nil?, ".merge() has not included ['Child3']['Child3a']['Child3a1'] from other_tree." )
+      assert( !merged_tree["Child3"]["Child4"].nil?, ".merge() has not included ['Child3']['Child4'] from self." )
+
+      assert_raise(ArgumentError) { @root.merge(@other_tree2) }
+      assert_raise(TypeError) { @root.merge('ROOT') }
+    end
+
+    # Test tree merging.
+    def test_merge_bang
+      setup_test_tree
+      setup_other_test_tree
+
+      # puts "\n\ntest_merge_bang:\n\n"
+      # @root.print_tree
+      # puts "\n"
+      # @other_tree.print_tree
+
+      @root.merge!(@other_tree)
+
+      # puts "\n"
+      # @root.print_tree
+
+      assert( !@root["Child1"]["Child1a"].nil?, ".merge() has not included ['Child1']['Child1a'] from other_tree." )
+      assert( !@root["Child1"]["Child1b"].nil?, ".merge() has not included ['Child1']['Child1b'] from other_tree." )
+      assert( !@root["Child3"]["Child3a"].nil?, ".merge() has not included ['Child3']['Child3a'] from other_tree." )
+      assert( !@root["Child2"].nil?, ".merge() has not included ['Child2'] from self." )
+      assert( !@root["Child3"]["Child3a"]["Child3a1"].nil?, ".merge() has not included ['Child3']['Child3a']['Child3a1'] from other_tree." )
+      assert( !@root["Child3"]["Child4"].nil?, ".merge() has not included ['Child3']['Child4'] from self." )
+
+      assert_raise(ArgumentError) { @root.merge!(@other_tree2) }
+      assert_raise(TypeError) { @root.merge!('ROOT') }
+    end
+
   end
 end