rubytree 0.5.1 → 0.5.2

data/ChangeLog

@@ -1,3 +1,17 @@
+2007-12-21  Anupam Sengupta  <anupamsg@gmail.com>
+
+	* Rakefile: Added the rcov option to exclude rcov itself from
+	coverage reports.
+
+	* lib/tree.rb: Minor comment changes.
+
+	* test/test_tree.rb: Added the TestTree enclosing module, and
+	renamed tests to meet ZenTest requirements. Also added a few
+	missing test cases.
+
+	* test/test_binarytree.rb: Added the TestTree enclosing Module,
+	and renamed the tests to meet ZenTest requirements.
+
 2007-12-19  Anupam Sengupta  <anupamsg@gmail.com>
 
 	* README (Module): Modified the install instructions from source.

data/History.txt

@@ -1,3 +1,12 @@
+= 0.5.2 / 2007-12-21
+
+* Added more test cases and enabled ZenTest compatibility for the test case
+  names.
+
+= 0.5.1 / 2007-12-20
+
+* Minor code refactoring.
+
 = 0.5.0 / 2007-12-18
 
 * Fixed the marshalling code to correctly handle non-string content.

data/Manifest.txt

@@ -3,8 +3,8 @@ ChangeLog
 History.txt
 Manifest.txt
 README
-TODO
 Rakefile
+TODO
 lib/tree.rb
 lib/tree/binarytree.rb
 setup.rb

data/README

@@ -144,4 +144,4 @@ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 
-(Document Revision: $Revision: 1.15 $ by $Author: anupamsg $)
+(Document Revision: $Revision: 1.16 $ by $Author: anupamsg $)

data/Rakefile

@@ -176,6 +176,7 @@ begin
   require 'rcov/rcovtask'
   Rcov::RcovTask.new do |t|
     t.test_files = FileList['test/test*.rb']
+    t.rcov_opts << "--exclude 'rcov.rb'" # rcov itself should not be profiled
     # t.verbose = true     # uncomment to see the executed commands
   end
 rescue LoadError

data/lib/tree.rb

@@ -1,6 +1,6 @@
 # tree.rb
 #
-# $Revision: 1.28 $ by $Author: anupamsg $
+# $Revision: 1.29 $ by $Author: anupamsg $
 # $Name:  $
 #
 # = tree.rb - Generic Multi-way Tree implementation
@@ -48,7 +48,7 @@
 module Tree
 
   # Rubytree Package Version
-  VERSION = '0.5.1'
+  VERSION = '0.5.2'
 
   # == TreeNode Class Description
   #
@@ -132,13 +132,11 @@ module Tree
 
     # Print the string representation of this node.
     def to_s
-
       "Node Name: #{@name}" +
         " Content: " + (@content || "<Empty>") +
         " Parent: " + (isRoot?()  ? "<None>" : @parent.name) +
         " Children: #{@children.length}" +
         " Total Nodes: #{size()}"
-
     end
 
     # Returns an array of ancestors in reversed order (the first element is the
@@ -452,7 +450,7 @@ module Tree
           # This is the root node, hence initialize self.
           initialize(name, content)
 
-          nodes[name] = self    # Add self to the
+          nodes[name] = self    # Add self to the list of nodes
          end
       end
     end
@@ -477,6 +475,9 @@ module Tree
 end
 
 # $Log: tree.rb,v $
+# Revision 1.29  2007/12/22 00:28:59  anupamsg
+# Added more test cases, and enabled ZenTest compatibility.
+#
 # Revision 1.28  2007/12/20 03:19:33  anupamsg
 # * README (Module): Modified the install instructions from source.
 # (Module): Updated the minor version number.

data/test/test_binarytree.rb

@@ -2,7 +2,7 @@
 
 # test_binarytree.rb
 #
-# $Revision: 1.4 $ by $Author: anupamsg $
+# $Revision: 1.5 $ by $Author: anupamsg $
 # $Name:  $
 #
 # Copyright (c) 2006, 2007 Anupam Sengupta
@@ -38,138 +38,143 @@
 require 'test/unit'
 require 'tree/binarytree'
 
-# Test class for the Tree node.
-class TC_BinaryTreeTest < Test::Unit::TestCase
+module TestTree
+  # Test class for the Tree node.
+  class TestBinaryTreeNode < Test::Unit::TestCase
 
-  def setup
-    @root = Tree::BinaryTreeNode.new("ROOT", "Root Node")
+    def setup
+      @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
+    end
 
-  def teardown
-    @root.remove!(@left_child1)
-    @root.remove!(@right_child1)
-    @root = nil
-  end
+    def teardown
+      @root.remove!(@left_child1)
+      @root.remove!(@right_child1)
+      @root = nil
+    end
 
-  def test_initialize
-    assert_not_nil(@root, "Binary tree's Root should have been created")
-  end
+    def test_initialize
+      assert_not_nil(@root, "Binary tree's Root should have been created")
+    end
 
-  def test_add
-    @root.add  @left_child1
-    assert_same(@left_child1, @root.leftChild, "The left node should be left_child1")
-    assert_same(@left_child1, @root.firstChild, "The first node should be left_child1")
+    def test_add
+      @root.add  @left_child1
+      assert_same(@left_child1, @root.leftChild, "The left node should be left_child1")
+      assert_same(@left_child1, @root.firstChild, "The first node should be left_child1")
 
-    @root.add @right_child1
-    assert_same(@right_child1, @root.rightChild, "The right node should be right_child1")
-    assert_same(@right_child1, @root.lastChild, "The first node should be right_child1")
+      @root.add @right_child1
+      assert_same(@right_child1, @root.rightChild, "The right node should be right_child1")
+      assert_same(@right_child1, @root.lastChild, "The first node should be right_child1")
 
-    assert_raise RuntimeError do
-      @root.add Tree::BinaryTreeNode.new("The third child!")
-    end
+      assert_raise RuntimeError do
+        @root.add Tree::BinaryTreeNode.new("The third child!")
+      end
 
-    assert_raise RuntimeError do
-      @root << Tree::BinaryTreeNode.new("The third child!")
+      assert_raise RuntimeError do
+        @root << Tree::BinaryTreeNode.new("The third child!")
+      end
     end
-  end
 
-  def test_left
-    @root << @left_child1
-    @root << @right_child1
-    assert_same(@left_child1, @root.leftChild, "The left child should be 'left_child1")
-    assert_not_same(@right_child1, @root.leftChild, "The right_child1 is not the left child")
-  end
+    def test_leftChild
+      @root << @left_child1
+      @root << @right_child1
+      assert_same(@left_child1, @root.leftChild, "The left child should be 'left_child1")
+      assert_not_same(@right_child1, @root.leftChild, "The right_child1 is not the left child")
+    end
 
-  def test_right
-    @root << @left_child1
-    @root << @right_child1
-    assert_same(@right_child1, @root.rightChild, "The right child should be 'right_child1")
-    assert_not_same(@left_child1, @root.rightChild, "The left_child1 is not the left child")
-  end
+    def test_rightChild
+      @root << @left_child1
+      @root << @right_child1
+      assert_same(@right_child1, @root.rightChild, "The right child should be 'right_child1")
+      assert_not_same(@left_child1, @root.rightChild, "The left_child1 is not the left child")
+    end
 
-  def test_left_assignment
-    @root << @left_child1
-    @root << @right_child1
-    assert_same(@left_child1, @root.leftChild, "The left child should be 'left_child1")
+    def test_leftChild_equals
+      @root << @left_child1
+      @root << @right_child1
+      assert_same(@left_child1, @root.leftChild, "The left child should be 'left_child1")
 
-    @root.leftChild = Tree::BinaryTreeNode.new("New Left Child")
-    assert_equal("New Left Child", @root.leftChild.name, "The left child should now be the new child")
-    assert_equal("B Child at Right", @root.lastChild.name, "The last child should now be the right child")
+      @root.leftChild = Tree::BinaryTreeNode.new("New Left Child")
+      assert_equal("New Left Child", @root.leftChild.name, "The left child should now be the new child")
+      assert_equal("B Child at Right", @root.lastChild.name, "The last child should now be the right child")
 
-    # Now set the left child as nil, and retest
-    @root.leftChild = nil
-    assert_nil(@root.leftChild, "The left child should now be nil")
-    assert_nil(@root.firstChild, "The first child is now nil")
-    assert_equal("B Child at Right", @root.lastChild.name, "The last child should now be the right child")
-  end
+      # Now set the left child as nil, and retest
+      @root.leftChild = nil
+      assert_nil(@root.leftChild, "The left child should now be nil")
+      assert_nil(@root.firstChild, "The first child is now nil")
+      assert_equal("B Child at Right", @root.lastChild.name, "The last child should now be the right child")
+    end
 
-  def test_right_assignment
-    @root << @left_child1
-    @root << @right_child1
-    assert_same(@right_child1, @root.rightChild, "The right child should be 'right_child1")
-
-    @root.rightChild = Tree::BinaryTreeNode.new("New Right Child")
-    assert_equal("New Right Child", @root.rightChild.name, "The right child should now be the new child")
-    assert_equal("A Child at Left", @root.firstChild.name, "The first child should now be the left child")
-    assert_equal("New Right Child", @root.lastChild.name, "The last child should now be the right child")
-
-    # Now set the right child as nil, and retest
-    @root.rightChild = nil
-    assert_nil(@root.rightChild, "The right child should now be nil")
-    assert_equal("A Child at Left", @root.firstChild.name, "The first child should now be the left child")
-    assert_nil(@root.lastChild, "The first child is now nil")
-  end
+    def test_rightChild_equals
+      @root << @left_child1
+      @root << @right_child1
+      assert_same(@right_child1, @root.rightChild, "The right child should be 'right_child1")
+
+      @root.rightChild = Tree::BinaryTreeNode.new("New Right Child")
+      assert_equal("New Right Child", @root.rightChild.name, "The right child should now be the new child")
+      assert_equal("A Child at Left", @root.firstChild.name, "The first child should now be the left child")
+      assert_equal("New Right Child", @root.lastChild.name, "The last child should now be the right child")
+
+      # Now set the right child as nil, and retest
+      @root.rightChild = nil
+      assert_nil(@root.rightChild, "The right child should now be nil")
+      assert_equal("A Child at Left", @root.firstChild.name, "The first child should now be the left child")
+      assert_nil(@root.lastChild, "The first child is now nil")
+    end
 
-  def test_isLeftChild?
-    @root << @left_child1
-    @root << @right_child1
+    def test_isLeftChild_eh
+      @root << @left_child1
+      @root << @right_child1
 
-    assert(@left_child1.isLeftChild?, "left_child1 should be the left child")
-    assert(!@right_child1.isLeftChild?, "left_child1 should be the left child")
+      assert(@left_child1.isLeftChild?, "left_child1 should be the left child")
+      assert(!@right_child1.isLeftChild?, "left_child1 should be the left child")
 
-    # Now set the right child as nil, and retest
-    @root.rightChild = nil
-    assert(@left_child1.isLeftChild?, "left_child1 should be the left child")
+      # Now set the right child as nil, and retest
+      @root.rightChild = nil
+      assert(@left_child1.isLeftChild?, "left_child1 should be the left child")
 
-    assert(!@root.isLeftChild?, "Root is neither left child nor right")
-  end
+      assert(!@root.isLeftChild?, "Root is neither left child nor right")
+    end
 
-  def test_isRightChild?
-    @root << @left_child1
-    @root << @right_child1
+    def test_isRightChild_eh
+      @root << @left_child1
+      @root << @right_child1
 
-    assert(@right_child1.isRightChild?, "right_child1 should be the right child")
-    assert(!@left_child1.isRightChild?, "right_child1 should be the right child")
+      assert(@right_child1.isRightChild?, "right_child1 should be the right child")
+      assert(!@left_child1.isRightChild?, "right_child1 should be the right child")
 
-    # Now set the left child as nil, and retest
-    @root.leftChild = nil
-    assert(@right_child1.isRightChild?, "right_child1 should be the right child")
-    assert(!@root.isRightChild?, "Root is neither left child nor right")
-  end
+      # Now set the left child as nil, and retest
+      @root.leftChild = nil
+      assert(@right_child1.isRightChild?, "right_child1 should be the right child")
+      assert(!@root.isRightChild?, "Root is neither left child nor right")
+    end
 
-  def test_swap_children
-    @root << @left_child1
-    @root << @right_child1
+    def test_swap_children
+      @root << @left_child1
+      @root << @right_child1
 
-    assert(@right_child1.isRightChild?, "right_child1 should be the right child")
-    assert(!@left_child1.isRightChild?, "right_child1 should be the right child")
+      assert(@right_child1.isRightChild?, "right_child1 should be the right child")
+      assert(!@left_child1.isRightChild?, "right_child1 should be the right child")
 
-    @root.swap_children
-    assert(@right_child1.isLeftChild?, "right_child1 should now be the left child")
-    assert(@left_child1.isRightChild?, "left_child1 should now be the right child")
-    assert_equal(@right_child1, @root.firstChild, "right_child1 should now be the first child")
-    assert_equal(@left_child1, @root.lastChild, "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")
+      @root.swap_children
 
+      assert(@right_child1.isLeftChild?, "right_child1 should now be the left child")
+      assert(@left_child1.isRightChild?, "left_child1 should now be the right child")
+      assert_equal(@right_child1, @root.firstChild, "right_child1 should now be the first child")
+      assert_equal(@left_child1, @root.lastChild, "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
   end
 end
 
 # $Log: test_binarytree.rb,v $
+# Revision 1.5  2007/12/22 00:28:59  anupamsg
+# Added more test cases, and enabled ZenTest compatibility.
+#
 # Revision 1.4  2007/12/18 23:11:29  anupamsg
 # Minor documentation changes in the binarytree class.
 #

data/test/test_tree.rb

@@ -2,7 +2,7 @@
 
 # testtree.rb
 #
-# $Revision: 1.5 $ by $Author: anupamsg $
+# $Revision: 1.6 $ by $Author: anupamsg $
 # $Name:  $
 #
 # Copyright (c) 2006, 2007 Anupam Sengupta
@@ -38,591 +38,652 @@
 require 'test/unit'
 require 'tree'
 
-# Test class for the Tree node.
-class TC_TreeTest < Test::Unit::TestCase
+module TestTree
+  # Test class for the Tree node.
+  class TestTreeNode < Test::Unit::TestCase
 
-  Person = Struct::new(:First, :last)
+    Person = Struct::new(:First, :last)
 
-  def setup
-    @root = Tree::TreeNode.new("ROOT", "Root Node")
+    def setup
+      @root = Tree::TreeNode.new("ROOT", "Root Node")
 
-    @child1 = Tree::TreeNode.new("Child1", "Child Node 1")
-    @child2 = Tree::TreeNode.new("Child2", "Child Node 2")
-    @child3 = Tree::TreeNode.new("Child3", "Child Node 3")
-    @child4 = Tree::TreeNode.new("Child31", "Grand Child 1")
+      @child1 = Tree::TreeNode.new("Child1", "Child Node 1")
+      @child2 = Tree::TreeNode.new("Child2", "Child Node 2")
+      @child3 = Tree::TreeNode.new("Child3", "Child Node 3")
+      @child4 = Tree::TreeNode.new("Child31", "Grand Child 1")
 
-  end
+    end
 
-  # Create this structure for the tests
-  #
-  #          +----------+
-  #          |  ROOT    |
-  #          +-+--------+
-  #            |
-  #            |    +---------------+
-  #            +----+  CHILD1       |
-  #            |    +---------------+
-  #            |
-  #            |    +---------------+
-  #            +----+  CHILD2       |
-  #            |    +---------------+
-  #            |
-  #            |    +---------------+   +------------------+
-  #            +----+  CHILD3       +---+  CHILD4          |
-  #                 +---------------+   +------------------+
-  #
-  def loadChildren
-    @root << @child1
-    @root << @child2
-    @root << @child3 << @child4
-  end
+    # Create this structure for the tests
+    #
+    #          +----------+
+    #          |  ROOT    |
+    #          +-+--------+
+    #            |
+    #            |    +---------------+
+    #            +----+  CHILD1       |
+    #            |    +---------------+
+    #            |
+    #            |    +---------------+
+    #            +----+  CHILD2       |
+    #            |    +---------------+
+    #            |
+    #            |    +---------------+   +------------------+
+    #            +----+  CHILD3       +---+  CHILD4          |
+    #                 +---------------+   +------------------+
+    #
+    def loadChildren
+      @root << @child1
+      @root << @child2
+      @root << @child3 << @child4
+    end
 
-  def teardown
-    @root = nil
-  end
+    def teardown
+      @root = nil
+    end
 
-  def test_root_setup
-    assert_not_nil(@root, "Root cannot be nil")
-    assert_nil(@root.parent, "Parent of root node should be nil")
-    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.isRoot?, "Should identify as root")
-    assert(!@root.hasChildren?, "Cannot have any children")
-    assert(@root.hasContent?, "This root should have content")
-    assert_equal(1, @root.size, "Number of nodes should be one")
-    assert_nil(@root.siblings, "Root cannot have any children")
-
-    assert_raise(RuntimeError) { Tree::TreeNode.new(nil) }
-  end
+    def test_root_setup
+      assert_not_nil(@root, "Root cannot be nil")
+      assert_nil(@root.parent, "Parent of root node should be nil")
+      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.isRoot?, "Should identify as root")
+      assert(!@root.hasChildren?, "Cannot have any children")
+      assert(@root.hasContent?, "This root should have content")
+      assert_equal(1, @root.size, "Number of nodes should be one")
+      assert_nil(@root.siblings, "Root cannot have any children")
+
+      assert_raise(RuntimeError) { Tree::TreeNode.new(nil) }
+    end
 
-  def test_root
-    loadChildren
+    def test_root
+      loadChildren
 
-    assert_same(@root, @root.root, "Root's root is self")
-    assert_same(@root, @child1.root, "Root should be ROOT")
-    assert_same(@root, @child4.root, "Root should be ROOT")
-  end
+      assert_same(@root, @root.root, "Root's root is self")
+      assert_same(@root, @child1.root, "Root should be ROOT")
+      assert_same(@root, @child4.root, "Root should be ROOT")
+    end
 
-  def test_hasContent
-    aNode = Tree::TreeNode.new("A Node")
-    assert_nil(aNode.content, "The node should not have content")
-    assert(!aNode.hasContent?, "The node should not have content")
+    def test_hasContent_eh
+      aNode = Tree::TreeNode.new("A Node")
+      assert_nil(aNode.content, "The node should not have content")
+      assert(!aNode.hasContent?, "The node should not have content")
 
-    aNode.content = "Something"
-    assert_not_nil(aNode.content, "The node should now have content")
-    assert(aNode.hasContent?, "The node should now have content")
-  end
+      aNode.content = "Something"
+      assert_not_nil(aNode.content, "The node should now have content")
+      assert(aNode.hasContent?, "The node should now have content")
+    end
 
-  def test_length
-    loadChildren
+    def test_length
+      loadChildren
+      assert_equal(@root.size, @root.length, "Length and size methods should return the same result")
+    end
 
-    assert_equal(@root.size, @root.length, "Length and size methods should return the same result")
-  end
+    def test_spaceship          # Test the <=> operator.
+      firstNode  = Tree::TreeNode.new(1)
+      secondNode = Tree::TreeNode.new(2)
 
-  def test_comparator
-    firstNode  = Tree::TreeNode.new(1)
-    secondNode = Tree::TreeNode.new(2)
+      assert_equal(firstNode <=> nil, +1)
+      assert_equal(firstNode <=> secondNode, -1)
 
-    assert_equal(firstNode <=> nil, +1)
-    assert_equal(firstNode <=> secondNode, -1)
+      secondNode = Tree::TreeNode.new(1)
+      assert_equal(firstNode <=> secondNode, 0)
 
-    secondNode = Tree::TreeNode.new(1)
-    assert_equal(firstNode <=> secondNode, 0)
+      firstNode  = Tree::TreeNode.new("ABC")
+      secondNode = Tree::TreeNode.new("XYZ")
 
-    firstNode  = Tree::TreeNode.new("ABC")
-    secondNode = Tree::TreeNode.new("XYZ")
+      assert_equal(firstNode <=> nil, +1)
+      assert_equal(firstNode <=> secondNode, -1)
 
-    assert_equal(firstNode <=> nil, +1)
-    assert_equal(firstNode <=> secondNode, -1)
+      secondNode = Tree::TreeNode.new("ABC")
+      assert_equal(firstNode <=> secondNode, 0)
+    end
 
-    secondNode = Tree::TreeNode.new("ABC")
-    assert_equal(firstNode <=> secondNode, 0)
-  end
+    def test_to_s
+      aNode = Tree::TreeNode.new("A Node", "Some Content")
 
-  def test_to_s
-    aNode = Tree::TreeNode.new("A Node", "Some Content")
+      expectedString = "Node Name: A Node Content: Some Content Parent: <None> Children: 0 Total Nodes: 1"
 
-    expectedString = "Node Name: A Node Content: Some Content Parent: <None> Children: 0 Total Nodes: 1"
+      assert_equal(expectedString, aNode.to_s, "The string representation should be same")
+    end
 
-    assert_equal(expectedString, aNode.to_s, "The string representation should be same")
-  end
+    def test_firstSibling
+      loadChildren
 
-  def test_firstSibling
-    loadChildren
+      assert_same(@root, @root.firstSibling, "Root's first sibling is itself")
+      assert_same(@child1, @child1.firstSibling, "Child1's first sibling is itself")
+      assert_same(@child1, @child2.firstSibling, "Child2's first sibling should be child1")
+      assert_same(@child1, @child3.firstSibling, "Child3's first sibling should be child1")
+      assert_not_same(@child1, @child4.firstSibling, "Child4's first sibling is itself")
+    end
 
-    assert_same(@root, @root.firstSibling, "Root's first sibling is itself")
-    assert_same(@child1, @child1.firstSibling, "Child1's first sibling is itself")
-    assert_same(@child1, @child2.firstSibling, "Child2's first sibling should be child1")
-    assert_same(@child1, @child3.firstSibling, "Child3's first sibling should be child1")
-    assert_not_same(@child1, @child4.firstSibling, "Child4's first sibling is itself")
-  end
+    def test_isFirstSibling_eh
+      loadChildren
 
-  def test_isFirstSibling
-    loadChildren
+      assert(@root.isFirstSibling?, "Root's first sibling is itself")
+      assert( @child1.isFirstSibling?, "Child1's first sibling is itself")
+      assert(!@child2.isFirstSibling?, "Child2 is not the first sibling")
+      assert(!@child3.isFirstSibling?, "Child3 is not the first sibling")
+      assert( @child4.isFirstSibling?, "Child4's first sibling is itself")
+    end
 
-    assert(@root.isFirstSibling?, "Root's first sibling is itself")
-    assert( @child1.isFirstSibling?, "Child1's first sibling is itself")
-    assert(!@child2.isFirstSibling?, "Child2 is not the first sibling")
-    assert(!@child3.isFirstSibling?, "Child3 is not the first sibling")
-    assert( @child4.isFirstSibling?, "Child4's first sibling is itself")
-  end
+    def test_isLastSibling_eh
+      loadChildren
+
+      assert(@root.isLastSibling?, "Root's last sibling is itself")
+      assert(!@child1.isLastSibling?, "Child1 is not the last sibling")
+      assert(!@child2.isLastSibling?, "Child2 is not the last sibling")
+      assert( @child3.isLastSibling?, "Child3's last sibling is itself")
+      assert( @child4.isLastSibling?, "Child4's last sibling is itself")
+    end
 
-  def test_isLastSibling
-    loadChildren
+    def test_lastSibling
+      loadChildren
 
-    assert(@root.isLastSibling?, "Root's last sibling is itself")
-    assert(!@child1.isLastSibling?, "Child1 is not the last sibling")
-    assert(!@child2.isLastSibling?, "Child2 is not the last sibling")
-    assert( @child3.isLastSibling?, "Child3's last sibling is itself")
-    assert( @child4.isLastSibling?, "Child4's last sibling is itself")
-  end
+      assert_same(@root, @root.lastSibling, "Root's last sibling is itself")
+      assert_same(@child3, @child1.lastSibling, "Child1's last sibling should be child3")
+      assert_same(@child3, @child2.lastSibling, "Child2's last sibling should be child3")
+      assert_same(@child3, @child3.lastSibling, "Child3's last sibling should be itself")
+      assert_not_same(@child3, @child4.lastSibling, "Child4's last sibling is itself")
+    end
 
-  def test_lastSibling
-    loadChildren
+    def test_siblings
+      loadChildren
 
-    assert_same(@root, @root.lastSibling, "Root's last sibling is itself")
-    assert_same(@child3, @child1.lastSibling, "Child1's last sibling should be child3")
-    assert_same(@child3, @child2.lastSibling, "Child2's last sibling should be child3")
-    assert_same(@child3, @child3.lastSibling, "Child3's last sibling should be itself")
-    assert_not_same(@child3, @child4.lastSibling, "Child4's last sibling is itself")
-  end
+      siblings = []
+      @child1.siblings { |sibling| siblings << sibling}
+      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")
 
-  def test_siblings
-    loadChildren
+      siblings.clear
+      siblings = @child1.siblings
+      assert_equal(2, siblings.length, "Should have two siblings")
 
-    siblings = []
-    @child1.siblings { |sibling| siblings << sibling}
-    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
+      @child4.siblings {|sibling| siblings << sibling}
+      assert(siblings.empty?, "Should not have any children")
 
-    siblings.clear
-    siblings = @child1.siblings
-    assert_equal(2, siblings.length, "Should have two siblings")
+    end
 
-    siblings.clear
-    @child4.siblings {|sibling| siblings << sibling}
-    assert(siblings.empty?, "Should not have any children")
+    def test_isOnlyChild_eh
+      loadChildren
 
-  end
+      assert(!@child1.isOnlyChild?, "Child1 is not the only child")
+      assert(!@child2.isOnlyChild?, "Child2 is not the only child")
+      assert(!@child3.isOnlyChild?, "Child3 is not the only child")
+      assert( @child4.isOnlyChild?, "Child4 is not the only child")
+    end
 
-  def test_isOnlyChild?
-    loadChildren
+    def test_nextSibling
+      loadChildren
 
-    assert(!@child1.isOnlyChild?, "Child1 is not the only child")
-    assert(!@child2.isOnlyChild?, "Child2 is not the only child")
-    assert(!@child3.isOnlyChild?, "Child3 is not the only child")
-    assert( @child4.isOnlyChild?, "Child4 is not the only child")
-  end
+      assert_equal(@child2, @child1.nextSibling, "Child1's next sibling is Child2")
+      assert_equal(@child3, @child2.nextSibling, "Child2's next sibling is Child3")
+      assert_nil(@child3.nextSibling, "Child3 does not have a next sibling")
+      assert_nil(@child4.nextSibling, "Child4 does not have a next sibling")
+    end
 
-  def test_nextSibling
-    loadChildren
+    def test_previousSibling
+      loadChildren
 
-    assert_equal(@child2, @child1.nextSibling, "Child1's next sibling is Child2")
-    assert_equal(@child3, @child2.nextSibling, "Child2's next sibling is Child3")
-    assert_nil(@child3.nextSibling, "Child3 does not have a next sibling")
-    assert_nil(@child4.nextSibling, "Child4 does not have a next sibling")
-  end
+      assert_nil(@child1.previousSibling, "Child1 does not have previous sibling")
+      assert_equal(@child1, @child2.previousSibling, "Child2's previous sibling is Child1")
+      assert_equal(@child2, @child3.previousSibling, "Child3's previous sibling is Child2")
+      assert_nil(@child4.previousSibling, "Child4 does not have a previous sibling")
+    end
 
-  def test_previousSibling
-    loadChildren
+    def test_add
+      assert(!@root.hasChildren?, "Should not have any children")
 
-    assert_nil(@child1.previousSibling, "Child1 does not have previous sibling")
-    assert_equal(@child1, @child2.previousSibling, "Child2's previous sibling is Child1")
-    assert_equal(@child2, @child3.previousSibling, "Child3's previous sibling is Child2")
-    assert_nil(@child4.previousSibling, "Child4 does not have a previous sibling")
-  end
+      @root.add(@child1)
 
-  def test_add
-    assert(!@root.hasChildren?, "Should not have any children")
+      @root << @child2
 
-    @root.add(@child1)
+      assert(@root.hasChildren?, "Should have children")
+      assert_equal(3, @root.size, "Should have three nodes")
 
-    @root << @child2
+      @root << @child3 << @child4
 
-    assert(@root.hasChildren?, "Should have children")
-    assert_equal(3, @root.size, "Should have three nodes")
+      assert_equal(5, @root.size, "Should have five nodes")
+      assert_equal(2, @child3.size, "Should have two nodes")
 
-    @root << @child3 << @child4
+      assert_raise(RuntimeError) { @root.add(Tree::TreeNode.new(@child1.name)) }
 
-    assert_equal(5, @root.size, "Should have five nodes")
-    assert_equal(2, @child3.size, "Should have two nodes")
+    end
 
-    assert_raise(RuntimeError) { @root.add(Tree::TreeNode.new(@child1.name)) }
+    def test_remove_bang
+      @root << @child1
+      @root << @child2
 
-  end
+      assert(@root.hasChildren?, "Should have children")
+      assert_equal(3, @root.size, "Should have three nodes")
 
-  def test_remove
-    @root << @child1
-    @root << @child2
+      @root.remove!(@child1)
+      assert_equal(2, @root.size, "Should have two nodes")
+      @root.remove!(@child2)
 
-    assert(@root.hasChildren?, "Should have children")
-    assert_equal(3, @root.size, "Should have three nodes")
+      assert(!@root.hasChildren?, "Should have no children")
+      assert_equal(1, @root.size, "Should have one node")
 
-    @root.remove!(@child1)
-    assert_equal(2, @root.size, "Should have two nodes")
-    @root.remove!(@child2)
+      @root << @child1
+      @root << @child2
 
-    assert(!@root.hasChildren?, "Should have no children")
-    assert_equal(1, @root.size, "Should have one node")
+      assert(@root.hasChildren?, "Should have children")
+      assert_equal(3, @root.size, "Should have three nodes")
 
-    @root << @child1
-    @root << @child2
+      @root.removeAll!
 
-    assert(@root.hasChildren?, "Should have children")
-    assert_equal(3, @root.size, "Should have three nodes")
+      assert(!@root.hasChildren?, "Should have no children")
+      assert_equal(1, @root.size, "Should have one node")
 
-    @root.removeAll!
+    end
 
-    assert(!@root.hasChildren?, "Should have no children")
-    assert_equal(1, @root.size, "Should have one node")
+    def test_removeAll_bang
+      loadChildren
+      assert(@root.hasChildren?, "Should have children")
+      @root.removeAll!
 
-  end
+      assert(!@root.hasChildren?, "Should have no children")
+      assert_equal(1, @root.size, "Should have one node")
+    end
 
-  def test_removeAll
-    loadChildren
-    assert(@root.hasChildren?, "Should have children")
-    @root.removeAll!
+    def test_removeFromParent_bang
+      loadChildren
+      assert(@root.hasChildren?, "Should have children")
+      assert(!@root.isLeaf?, "Root is not a leaf here")
+
+      child1 = @root[0]
+      assert_not_nil(child1, "Child 1 should exist")
+      assert_same(@root, child1.root, "Child 1's root should be ROOT")
+      assert(@root.include?(child1), "root should have child1")
+      child1.removeFromParent!
+      assert_same(child1, child1.root, "Child 1's root should be self")
+      assert(!@root.include?(child1), "root should not have child1")
+
+      child1.removeFromParent!
+      assert_same(child1, child1.root, "Child 1's root should still be self")
+    end
 
-    assert(!@root.hasChildren?, "Should have no children")
-    assert_equal(1, @root.size, "Should have one node")
-  end
+    def test_children
+      loadChildren
 
-  def test_removeFromParent
-    loadChildren
-    assert(@root.hasChildren?, "Should have children")
-    assert(!@root.isLeaf?, "Root is not a leaf here")
-
-    child1 = @root[0]
-    assert_not_nil(child1, "Child 1 should exist")
-    assert_same(@root, child1.root, "Child 1's root should be ROOT")
-    assert(@root.include?(child1), "root should have child1")
-    child1.removeFromParent!
-    assert_same(child1, child1.root, "Child 1's root should be self")
-    assert(!@root.include?(child1), "root should not have child1")
-
-    child1.removeFromParent!
-    assert_same(child1, child1.root, "Child 1's root should still be self")
-  end
+      assert(@root.hasChildren?, "Should have children")
+      assert_equal(5, @root.size, "Should have four nodes")
+      assert(@child3.hasChildren?, "Should have children")
+      assert(!@child3.isLeaf?, "Should not be a leaf")
+
+      children = []
+      for child in @root.children
+        children << child
+      end
 
-  def test_children
-    loadChildren
+      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")
 
-    assert(@root.hasChildren?, "Should have children")
-    assert_equal(5, @root.size, "Should have four nodes")
-    assert(@child3.hasChildren?, "Should have children")
-    assert(!@child3.isLeaf?, "Should not be a leaf")
+      children.clear
+      children = @root.children
+      assert_equal(3, children.length, "Should have three children")
 
-    children = []
-    for child in @root.children
-      children << child
     end
 
-    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")
+    def test_firstChild
+      loadChildren
 
-    children.clear
-    children = @root.children
-    assert_equal(3, children.length, "Should have three children")
+      assert_equal(@child1, @root.firstChild, "Root's first child is Child1")
+      assert_nil(@child1.firstChild, "Child1 does not have any children")
+      assert_equal(@child4, @child3.firstChild, "Child3's first child is Child4")
 
-  end
+    end
 
-  def test_firstChild
-    loadChildren
+    def test_lastChild
+      loadChildren
 
-    assert_equal(@child1, @root.firstChild, "Root's first child is Child1")
-    assert_nil(@child1.firstChild, "Child1 does not have any children")
-    assert_equal(@child4, @child3.firstChild, "Child3's first child is Child4")
+      assert_equal(@child3, @root.lastChild, "Root's last child is Child3")
+      assert_nil(@child1.lastChild, "Child1 does not have any children")
+      assert_equal(@child4, @child3.lastChild, "Child3's last child is Child4")
 
-  end
+    end
 
-  def test_lastChild
-    loadChildren
+    def test_find
+      loadChildren
+      foundNode = @root.find { |node| node == @child2}
+      assert_same(@child2, foundNode, "The node should be Child 2")
 
-    assert_equal(@child3, @root.lastChild, "Root's last child is Child3")
-    assert_nil(@child1.lastChild, "Child1 does not have any children")
-    assert_equal(@child4, @child3.lastChild, "Child3's last child is Child4")
+      foundNode = @root.find { |node| node == @child4}
+      assert_same(@child4, foundNode, "The node should be Child 4")
 
-  end
+      foundNode = @root.find { |node| node.name == "Child31" }
+      assert_same(@child4, foundNode, "The node should be Child 4")
+      foundNode = @root.find { |node| node.name == "NOT PRESENT" }
+      assert_nil(foundNode, "The node should not be found")
+    end
 
-  def test_find
-    loadChildren
-    foundNode = @root.find { |node| node == @child2}
-    assert_same(@child2, foundNode, "The node should be Child 2")
+    def test_parentage
+      loadChildren
 
-    foundNode = @root.find { |node| node == @child4}
-    assert_same(@child4, foundNode, "The node should be Child 4")
+      assert_nil(@root.parentage, "Root does not have any parentage")
+      assert_equal([@root], @child1.parentage, "Child1 has Root as its parent")
+      assert_equal([@child3, @root], @child4.parentage, "Child4 has Child3 and Root as ancestors")
+    end
 
-    foundNode = @root.find { |node| node.name == "Child31" }
-    assert_same(@child4, foundNode, "The node should be Child 4")
-    foundNode = @root.find { |node| node.name == "NOT PRESENT" }
-    assert_nil(foundNode, "The node should not be found")
-  end
+    def test_each
+      loadChildren
+      assert(@root.hasChildren?, "Should have children")
+      assert_equal(5, @root.size, "Should have five nodes")
+      assert(@child3.hasChildren?, "Should have children")
+
+      nodes = []
+      @root.each { |node| nodes << node }
+
+      assert_equal(5, nodes.length, "Should have FIVE NODES")
+      assert(nodes.include?(@root), "Should have root")
+      assert(nodes.include?(@child1), "Should have child 1")
+      assert(nodes.include?(@child2), "Should have child 2")
+      assert(nodes.include?(@child3), "Should have child 3")
+      assert(nodes.include?(@child4), "Should have child 4")
+    end
 
-  def test_parentage
-    loadChildren
+    def test_each_leaf
+      loadChildren
 
-    assert_nil(@root.parentage, "Root does not have any parentage")
-    assert_equal([@root], @child1.parentage, "Child1 has Root as its parent")
-    assert_equal([@child3, @root], @child4.parentage, "Child4 has Child3 and Root as ancestors")
-  end
+      nodes = []
+      @root.each_leaf { |node| nodes << node }
 
-  def test_each
-    loadChildren
-    assert(@root.hasChildren?, "Should have children")
-    assert_equal(5, @root.size, "Should have five nodes")
-    assert(@child3.hasChildren?, "Should have children")
-
-    nodes = []
-    @root.each { |node| nodes << node }
-
-    assert_equal(5, nodes.length, "Should have FIVE NODES")
-    assert(nodes.include?(@root), "Should have root")
-    assert(nodes.include?(@child1), "Should have child 1")
-    assert(nodes.include?(@child2), "Should have child 2")
-    assert(nodes.include?(@child3), "Should have child 3")
-    assert(nodes.include?(@child4), "Should have child 4")
-  end
+      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
 
-  def test_each_leaf
-    loadChildren
+    def test_parent
+      loadChildren
+      assert_nil(@root.parent, "Root's parent should be nil")
+      assert_equal(@root, @child1.parent, "Parent should be root")
+      assert_equal(@root, @child3.parent, "Parent should be root")
+      assert_equal(@child3, @child4.parent, "Parent should be child3")
+      assert_equal(@root, @child4.parent.parent, "Parent should be root")
+    end
 
-    nodes = []
-    @root.each_leaf { |node| nodes << node }
+    def test_indexed_access
+      loadChildren
+      assert_equal(@child1, @root[0], "Should be the first child")
+      assert_equal(@child4, @root[2][0], "Should be the grandchild")
+      assert_nil(@root["TEST"], "Should be nil")
+      assert_raise(RuntimeError) { @root[nil] }
+    end
 
-    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
+    def test_printTree
+      loadChildren
+      #puts
+      #@root.printTree
+    end
 
-  def test_parent
-    loadChildren
-    assert_nil(@root.parent, "Root's parent should be nil")
-    assert_equal(@root, @child1.parent, "Parent should be root")
-    assert_equal(@root, @child3.parent, "Parent should be root")
-    assert_equal(@child3, @child4.parent, "Parent should be child3")
-    assert_equal(@root, @child4.parent.parent, "Parent should be root")
-  end
+    # Tests the binary dumping mechanism with an Object content node
+    def test_marshal_dump
+      # Setup Test Data
+      test_root = Tree::TreeNode.new("ROOT", "Root Node")
+      test_content = {"KEY1" => "Value1", "KEY2" => "Value2" }
+      test_child      = Tree::TreeNode.new("Child", test_content)
+      test_content2 = ["AValue1", "AValue2", "AValue3"]
+      test_grand_child = Tree::TreeNode.new("Grand Child 1", test_content2)
+      test_root << test_child << test_grand_child
+
+      # Perform the test operation
+      data = Marshal.dump(test_root) # Marshal
+      new_root = Marshal.load(data)  # And unmarshal
+
+      # 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.isRoot?, "Must be the ROOT node")
+      assert(new_root.hasChildren?, "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.hasContent?, "Child must have content")
+      assert(new_child.isOnlyChild?, "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")
+      assert_equal(test_child.content.size, new_child_content.size, "The content should have same size")
+
+      # 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.hasContent?, "Grand-child must have content")
+      assert(new_grand_child.isOnlyChild?, "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")
+      assert_equal(test_grand_child.content.size, new_grand_child_content.size, "The content should have same size")
+    end
 
-  def test_indexed_access
-    loadChildren
-    assert_equal(@child1, @root[0], "Should be the first child")
-    assert_equal(@child4, @root[2][0], "Should be the grandchild")
-    assert_nil(@root["TEST"], "Should be nil")
-    assert_raise(RuntimeError) { @root[nil] }
-  end
+    # marshal_load and marshal_dump are symmetric methods
+    # This alias is for satisfying ZenTest
+    alias test_marshal_load test_marshal_dump
+
+    # Test the collect method from the mixed-in Enumerable functionality.
+    def test_collect
+      loadChildren
+      collectArray = @root.collect do |node|
+        node.content = "abc"
+        node
+      end
+      collectArray.each {|node| assert_equal("abc", node.content, "Should be 'abc'")}
+    end
 
-  def test_printTree
-    loadChildren
-    #puts
-    #@root.printTree
-  end
+    # Test freezing the tree
+    def test_freezeTree_bang
+      loadChildren
+      @root.content = "ABC"
+      assert_equal("ABC", @root.content, "Content should be 'ABC'")
+      @root.freezeTree!
+      assert_raise(TypeError) {@root.content = "123"}
+      assert_raise(TypeError) {@root[0].content = "123"}
+    end
 
-  # Tests the binary dumping mechanism with an Object content node
-  def test_marshalling
-    # Setup Test Data
-    test_root = Tree::TreeNode.new("ROOT", "Root Node")
-    test_content = {"KEY1" => "Value1", "KEY2" => "Value2" }
-    test_child      = Tree::TreeNode.new("Child", test_content)
-    test_content2 = ["AValue1", "AValue2", "AValue3"]
-    test_grand_child = Tree::TreeNode.new("Grand Child 1", test_content2)
-    test_root << test_child << test_grand_child
-
-    # Perform the test operation
-    data = Marshal.dump(test_root) # Marshal
-    new_root = Marshal.load(data)  # And unmarshal
-
-    # 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.isRoot?, "Must be the ROOT node")
-    assert(new_root.hasChildren?, "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.hasContent?, "Child must have content")
-    assert(new_child.isOnlyChild?, "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")
-    assert_equal(test_child.content.size, new_child_content.size, "The content should have same size")
-
-    # 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.hasContent?, "Grand-child must have content")
-    assert(new_grand_child.isOnlyChild?, "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")
-    assert_equal(test_grand_child.content.size, new_grand_child_content.size, "The content should have same size")
-  end
+    # Test whether the content is accesible
+    def test_content
+      pers = Person::new("John", "Doe")
+      @root.content = pers
+      assert_same(pers, @root.content, "Content should be the same")
+    end
+
+    # Test the depth computation algorithm
+    def test_depth
+      assert_equal(1, @root.depth, "A single node's depth is 1")
 
-  # Test the collect method from the mixed-in Enumerable functionality.
-  def test_collect
-    loadChildren
-    collectArray = @root.collect do |node|
-      node.content = "abc"
-      node
+      @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
-    collectArray.each {|node| assert_equal("abc", node.content, "Should be 'abc'")}
-  end
 
-  # Test freezing the tree
-  def test_freezeTree
-    loadChildren
-    @root.content = "ABC"
-    assert_equal("ABC", @root.content, "Content should be 'ABC'")
-    @root.freezeTree!
-    assert_raise(TypeError) {@root.content = "123"}
-    assert_raise(TypeError) {@root[0].content = "123"}
-  end
+    # Test the breadth computation algorithm
+    def test_breadth
+      assert_equal(1, @root.breadth, "A single node's breadth is 1")
 
-  # Test whether the content is accesible
-  def test_content
-    pers = Person::new("John", "Doe")
-    @root.content = pers
-    assert_same(pers, @root.content, "Content should be the same")
-  end
+      @root << @child1
+      assert_equal(1, @root.breadth, "This should be of breadth 1")
 
-  # Test the depth computation algorithm
-  def test_depth
-    assert_equal(1, @root.depth, "A single node's depth is 1")
+      @root << @child2
+      assert_equal(2, @child1.breadth, "This should be of breadth 2")
+      assert_equal(2, @child2.breadth, "This should be of breadth 2")
 
-    @root << @child1
-    assert_equal(2, @root.depth, "This should be of depth 2")
+      @root << @child3
+      assert_equal(3, @child1.breadth, "This should be of breadth 3")
+      assert_equal(3, @child2.breadth, "This should be of breadth 3")
 
-    @root << @child2
-    assert_equal(2, @root.depth, "This should be of depth 2")
+      @child3 << @child4
+      assert_equal(1, @child4.breadth, "This should be of breadth 1")
+    end
 
-    @child2 << @child3
-    assert_equal(3, @root.depth, "This should be of depth 3")
-    assert_equal(2, @child2.depth, "This should be of depth 2")
+    # Test the breadth for each
+    def test_breadth_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 = [j,
+                        f, k,
+                        a, h, z,
+                        d]
+
+      # 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
+
+      # Create the response
+      result_array = Array.new
+      j.breadth_each { |node| result_array << node.detached_copy }
+
+      expected_array.each_index do |i|
+        assert_equal(expected_array[i].name, result_array[i].name)      # Match only the names.
+      end
+    end
 
-    @child3 << @child4
-    assert_equal(4, @root.depth, "This should be of depth 4")
-  end
 
-  # Test the breadth computation algorithm
-  def test_breadth
-    assert_equal(1, @root.breadth, "A single node's breadth is 1")
+    def test_preordered_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 = [j, f, a, d, h, k, z]
+
+      # 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 = []
+      j.preordered_each { |node| result_array << node.detached_copy}
+
+      expected_array.each_index do |i|
+        # Match only the names.
+        assert_equal(expected_array[i].name, result_array[i].name)
+      end
+    end
 
-    @root << @child1
-    assert_equal(1, @root.breadth, "This should be of breadth 1")
+    def test_detached_copy
+      loadChildren
 
-    @root << @child2
-    assert_equal(2, @child1.breadth, "This should be of breadth 2")
-    assert_equal(2, @child2.breadth, "This should be of breadth 2")
+      assert(@root.hasChildren?, "The root should have children")
+      copy_of_root = @root.detached_copy
+      assert(!copy_of_root.hasChildren?, "The copy should not have children")
+      assert_equal(@root.name, copy_of_root.name, "The names should be equal")
 
-    @root << @child3
-    assert_equal(3, @child1.breadth, "This should be of breadth 3")
-    assert_equal(3, @child2.breadth, "This should be of breadth 3")
+      # Try the same test with a child node
+      assert(!@child3.isRoot?, "Child 3 is not a root")
+      assert(@child3.hasChildren?, "Child 3 has children")
+      copy_of_child3 = @child3.detached_copy
+      assert(copy_of_child3.isRoot?, "Child 3's copy is a root")
+      assert(!copy_of_child3.hasChildren?, "Child 3's copy does not have children")
+    end
 
-    @child3 << @child4
-    assert_equal(1, @child4.breadth, "This should be of breadth 1")
-  end
+    def test_hasChildren_eh
+      loadChildren
+      assert(@root.hasChildren?, "The Root node MUST have children")
+    end
 
-  # Test the breadth for each
-  def test_breadth_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 = [j,
-                      f, k,
-                      a, h, z,
-                      d]
-
-    # 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
-
-    # Create the response
-    result_array = Array.new
-    j.breadth_each { |node| result_array << node.detached_copy }
-
-    expected_array.each_index do |i|
-      assert_equal(expected_array[i].name, result_array[i].name)      # Match only the names.
+    def test_isLeaf_eh
+      loadChildren
+      assert(!@child3.isLeaf?, "Child 3 is not a leaf node")
+      assert(@child4.isLeaf?, "Child 4 is a leaf node")
     end
-  end
 
+    def test_isRoot_eh
+      loadChildren
+      assert(@root.isRoot?, "The ROOT node must respond as the root node")
+    end
 
-  def test_preordered_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 = [j, f, a, d, h, k, z]
-
-    # 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 = []
-    j.preordered_each { |node| result_array << node.detached_copy}
-
-    expected_array.each_index do |i|
-      # Match only the names.
-      assert_equal(expected_array[i].name, result_array[i].name)
+    def test_content_equals
+      @root.content = nil
+      assert_nil(@root.content, "Root's content should be nil")
+      @root.content = "ABCD"
+      assert_equal("ABCD", @root.content, "Root's content should now be 'ABCD'")
     end
-  end
 
-  def test_detached_copy
-    loadChildren
+    def test_size
+      assert_equal(1, @root.size, "Root's size should be 1")
+      loadChildren
+      assert_equal(5, @root.size, "Root's size should be 5")
+      assert_equal(2, @child3.size, "Child 3's size should be 2")
+    end
 
-    assert(@root.hasChildren?, "The root should have children")
-    copy_of_root = @root.detached_copy
-    assert(!copy_of_root.hasChildren?, "The copy should not have children")
-    assert_equal(@root.name, copy_of_root.name, "The names should be equal")
+    def test_lt2                # Test the << method
+      @root << @child1
+      @root << @child2
+      @root << @child3 << @child4
+      assert_not_nil(@root['Child1'], "Child 1 should have been added to Root")
+      assert_not_nil(@root['Child2'], "Child 2 should have been added to Root")
+      assert_not_nil(@root['Child3'], "Child 3 should have been added to Root")
+      assert_not_nil(@child3['Child31'], "Child 31 should have been added to Child3")
+    end
 
-    # Try the same test with a child node
-    assert(!@child3.isRoot?, "Child 3 is not a root")
-    assert(@child3.hasChildren?, "Child 3 has children")
-    copy_of_child3 = @child3.detached_copy
-    assert(copy_of_child3.isRoot?, "Child 3's copy is a root")
-    assert(!copy_of_child3.hasChildren?, "Child 3's copy does not have children")
-  end
+    def test_index              #  Test the [] method
+      assert_raise(RuntimeError) {@root[nil]}
+
+      @root << @child1
+      @root << @child2
+      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(@child2.name, @root['Child2'].name, "Child 2 should be returned")
+      assert_equal(@child2.name, @root[1].name, "Child 2 should be returned")
 
+      assert_nil(@root['Some Random Name'], "Should return nil")
+      assert_nil(@root[99], "Should return nil")
+    end
+  end
 end
 
 __END__
 
 # $Log: test_tree.rb,v $
+# Revision 1.6  2007/12/22 00:28:59  anupamsg
+# Added more test cases, and enabled ZenTest compatibility.
+#
 # Revision 1.5  2007/12/19 02:24:18  anupamsg
 # Updated the marshalling logic to handle non-string contents on the nodes.
 #