rubytree 0.6.2 → 0.7.0

data/lib/tree/binarytree.rb

@@ -47,7 +47,10 @@ module Tree
   # Provides a Binary tree implementation. This node allows only two child nodes (left and right child).  It also
   # provides direct access to the left or right child, including assignment to the same.
   #
-  # This inherits from the Tree::TreeNode class.
+  # This inherits from the {Tree::TreeNode} class.
+  #
+  # @author Anupam Sengupta
+  #
   class BinaryTreeNode < TreeNode
 
     # Adds the specified child node to the receiver node.  The child node's parent is set to be the receiver.
@@ -57,14 +60,20 @@ module Tree
     #
     # If only one child is present, then this will be the left child.
     #
-    # An exception is raised if two children are already present.
+    # @param [Tree::BinaryTreeNode] child The child to add.
+    #
+    # @raise [ArgumentError] This exception is raised if two children are already present.
     def add(child)
-      raise "Already has two child nodes" if @children.size == 2
+      raise ArgumentError, "Already has two child nodes" if @children.size == 2
 
       super(child)
     end
 
     # Returns the left child of the receiver node. Note that left Child == first Child.
+    #
+    # @return [Tree::BinaryTreeNode] The left most (or first) child.
+    #
+    # @see #rightChild
     def leftChild
       children.first
     end
@@ -72,39 +81,63 @@ module Tree
     # Returns the right child of the receiver node. Note that right child == last child unless there is only one child.
     #
     # Returns +nil+ if the right child does not exist.
+    #
+    # @return [Tree::BinaryTreeNode] The right child, or +nil+ if the right side child does not exist.
+    #
+    # @see #leftChild
     def rightChild
       children[1]
     end
 
     # Sets the left child of the receiver node. If a previous child existed, it is replaced.
+    #
+    # @param [Tree::BinaryTreeNode] child The child to add as the left-side node.
+    #
+    # @return [Tree::BinaryTreeNode] The assigned child node.
+    #
+    # @see #leftChild
+    # @see #rightChild=
     def leftChild=(child)
       @children[0] = child
       @childrenHash[child.name] = child if child # Assign the name mapping
     end
 
     # Sets the right child of the receiver node. If a previous child existed, it is replaced.
+    #
+    # @param [Tree::BinaryTreeNode] child The child to add as the right-side node.
+    #
+    # @return [Tree::BinaryTreeNode] The assigned child node.
+    #
+    # @see #rightChild
+    # @see #leftChild=
     def rightChild=(child)
       @children[1] = child
       @childrenHash[child.name] = child if child # Assign the name mapping
     end
 
-    # Returns +true+ if the receiver node is the left child of its parent.  Always returns +false+ if it is a root node.
+    # Returns +true+ if the receiver node is the left child of its parent.
+    # Always returns +false+ if it is a root node.
+    #
+    # @return [Boolean] +true+ if this is the left child of its parent.
     def isLeftChild?
       return false if isRoot?
       self == parent.leftChild
     end
 
-    # Returns +true+ if the receiver node is the right child of its parent. Always returns +false+ if it is a root node.
+    # Returns +true+ if the receiver node is the right child of its parent.
+    # Always returns +false+ if it is a root node.
+    #
+    # @return [Boolean] +true+ if this is the right child of its parent.
     def isRightChild?
       return false if isRoot?
       self == parent.rightChild
     end
 
     # Swaps the left and right child nodes of the receiver node with each other.
+    #
+    # @todo Define the return value.
     def swap_children
-      tempChild       = leftChild
-      self.leftChild  = rightChild
-      self.rightChild = tempChild
+      self.leftChild, self.rightChild = self.rightChild, self.leftChild
     end
   end
 

data/test/test_binarytree.rb

@@ -41,6 +41,7 @@ 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")
 
@@ -49,16 +50,19 @@ module TestTree
 
     end
 
+    # Tear down the test data scaffolding.
     def teardown
       @root.remove!(@left_child1)
       @root.remove!(@right_child1)
       @root = nil
     end
 
+    # Test initialization of the binary tree.
     def test_initialize
       assert_not_nil(@root, "Binary tree's Root should have been created")
     end
 
+    # Test the add method.
     def test_add
       @root.add  @left_child1
       assert_same(@left_child1, @root.leftChild, "The left node should be left_child1")
@@ -68,15 +72,16 @@ module TestTree
       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
+      assert_raise ArgumentError do
         @root.add Tree::BinaryTreeNode.new("The third child!")
       end
 
-      assert_raise RuntimeError do
+      assert_raise ArgumentError do
         @root << Tree::BinaryTreeNode.new("The third child!")
       end
     end
 
+    # Test the leftChild method.
     def test_leftChild
       @root << @left_child1
       @root << @right_child1
@@ -84,6 +89,7 @@ module TestTree
       assert_not_same(@right_child1, @root.leftChild, "The right_child1 is not the left child")
     end
 
+    # Test the rightChild method.
     def test_rightChild
       @root << @left_child1
       @root << @right_child1
@@ -91,6 +97,7 @@ module TestTree
       assert_not_same(@left_child1, @root.rightChild, "The left_child1 is not the left child")
     end
 
+    # Test leftChild= method.
     def test_leftChild_equals
       @root << @left_child1
       @root << @right_child1
@@ -107,6 +114,7 @@ module TestTree
       assert_equal("B Child at Right", @root.lastChild.name, "The last child should now be the right child")
     end
 
+    # Test rightChild= method.
     def test_rightChild_equals
       @root << @left_child1
       @root << @right_child1
@@ -124,6 +132,7 @@ module TestTree
       assert_nil(@root.lastChild, "The first child is now nil")
     end
 
+    # Test isLeftChild? method.
     def test_isLeftChild_eh
       @root << @left_child1
       @root << @right_child1
@@ -138,6 +147,7 @@ module TestTree
       assert(!@root.isLeftChild?, "Root is neither left child nor right")
     end
 
+    # Test isRightChild? method.
     def test_isRightChild_eh
       @root << @left_child1
       @root << @right_child1
@@ -151,6 +161,7 @@ module TestTree
       assert(!@root.isRightChild?, "Root is neither left child nor right")
     end
 
+    # Test swap_children method.
     def test_swap_children
       @root << @left_child1
       @root << @right_child1

data/test/test_tree.rb

@@ -35,6 +35,8 @@
 #
 
 require 'test/unit'
+require 'rubygems'
+require 'json'
 require 'tree'
 
 module TestTree
@@ -43,15 +45,6 @@ module TestTree
 
     Person = Struct::new(:First, :last) # A simple structure to use as the content for the nodes.
 
-    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")
-
-    end
 
     # Create this structure for the tests
     #
@@ -71,12 +64,25 @@ module TestTree
     #            +----+  CHILD3       +---+  CHILD4          |
     #                 +---------------+   +------------------+
     #
-    def loadChildren
+    # Some basic setup to create the nodes for the test tree.
+    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")
+
+    end
+
+    # Create the actual test tree.
+    def setup_test_tree
       @root << @child1
       @root << @child2
       @root << @child3 << @child4
     end
 
+    # Tear down the entire structure
     def teardown
       @root = nil
     end
@@ -93,21 +99,25 @@ module TestTree
       assert(@root.hasContent?   , "This root should have content")
       assert_equal(1             , @root.size, "Number of nodes should be one")
       assert_nil(@root.siblings  , "This root does not have any children")
-
+      assert_equal(0, @root.in_degree, "Root should have an in-degree of 0")
       assert_equal(0, @root.nodeHeight, "Root's height before adding any children is 0")
-      assert_raise(RuntimeError) { Tree::TreeNode.new(nil) }
+      assert_raise(ArgumentError) { Tree::TreeNode.new(nil) }
     end
 
-    # This test is for the state after the children are linked to the root
+    # This test is for the state after the children are linked to the root.
     def test_root
-      loadChildren
+      setup_test_tree
 
+      # TODO: Should probably change this logic.  Root's root should
+      # return nil so that the possibility of a recursive error does not exist
+      # at all.
       assert_same(@root , @root.root, "Root's root is self")
       assert_same(@root , @child1.root, "Root should be ROOT")
       assert_same(@root , @child4.root, "Root should be ROOT")
       assert_equal(2    , @root.nodeHeight, "Root's height after adding the children should be 2")
     end
 
+    # Test the presence of content in the nodes.
     def test_hasContent_eh
       aNode = Tree::TreeNode.new("A Node")
       assert_nil(aNode.content  , "The node should not have content")
@@ -118,12 +128,14 @@ module TestTree
       assert(aNode.hasContent?, "The node should now have content")
     end
 
-    def test_length
-      loadChildren
+    # Test the equivalence of size and length methods.
+    def test_length_is_size
+      setup_test_tree
       assert_equal(@root.size, @root.length, "Length and size methods should return the same result")
     end
 
-    def test_spaceship          # Test the <=> operator.
+    # Test the <=> operator.
+    def test_spaceship
       firstNode  = Tree::TreeNode.new(1)
       secondNode = Tree::TreeNode.new(2)
 
@@ -143,6 +155,7 @@ module TestTree
       assert_equal(firstNode <=> secondNode, 0)
     end
 
+    # Test the to_s method.  This is probably a little fragile right now.
     def test_to_s
       aNode = Tree::TreeNode.new("A Node", "Some Content")
 
@@ -151,9 +164,11 @@ module TestTree
       assert_equal(expectedString, aNode.to_s, "The string representation should be same")
     end
 
+    # Test the firstSibling method.
     def test_firstSibling
-      loadChildren
+      setup_test_tree
 
+      # TODO: Need to fix the firstSibling method to return nil for nodes with no siblings.
       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")
@@ -161,9 +176,11 @@ module TestTree
       assert_not_same(@child1, @child4.firstSibling, "Child4's first sibling is itself")
     end
 
+    # Test the isFirstSibling? method.
     def test_isFirstSibling_eh
-      loadChildren
+      setup_test_tree
 
+      # TODO: Need to fix the firstSibling method to return nil for nodes with no siblings.
       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")
@@ -171,9 +188,11 @@ module TestTree
       assert( @child4.isFirstSibling?, "Child4's first sibling is itself")
     end
 
+    # Test the isLastSibling? method.
     def test_isLastSibling_eh
-      loadChildren
+      setup_test_tree
 
+      # TODO: Need to fix the lastSibling method to return nil for nodes with no siblings.
       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")
@@ -181,9 +200,11 @@ module TestTree
       assert( @child4.isLastSibling?, "Child4's last sibling is itself")
     end
 
+    # Test the lastSibling method.
     def test_lastSibling
-      loadChildren
+      setup_test_tree
 
+      # TODO: Need to fix the lastSibling method to return nil for nodes with no siblings.
       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")
@@ -191,11 +212,14 @@ module TestTree
       assert_not_same(@child3, @child4.lastSibling, "Child4's last sibling is itself")
     end
 
+    # Test the siblings method, which is essentially an iterator.
     def test_siblings
-      loadChildren
+      setup_test_tree
 
+      # Lets first collect the siblings in an array.
       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")
@@ -206,37 +230,47 @@ module TestTree
 
       siblings.clear
       @child4.siblings {|sibling| siblings << sibling}
-      assert(siblings.empty?, "Should not have any children")
+      assert(siblings.empty?, "Should not have any siblings")
 
+      siblings.clear
+      siblings = @root.siblings
+      assert_nil(siblings, "Root should not have any siblings")
     end
 
+    # Test the isOnlyChild? method.
     def test_isOnlyChild_eh
-      loadChildren
+      setup_test_tree
 
+      assert( @root.isOnlyChild?  , "Root is an only child")
       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")
+      assert( @child4.isOnlyChild?, "Child4 is an only child")
     end
 
+    # Test the nextSibling method.
     def test_nextSibling
-      loadChildren
+      setup_test_tree
 
+      assert_nil(@root.nextSibling, "Root does not have any next sibling")
       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
 
+    # Test the previousSibling method.
     def test_previousSibling
-      loadChildren
+      setup_test_tree
 
+      assert_nil(@root.previousSibling, "Root does not have any previous sibling")
       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
 
+    # Test the add method.
     def test_add
       assert(!@root.hasChildren?, "Should not have any children")
 
@@ -253,10 +287,14 @@ module TestTree
       assert_equal(5, @root.size, "Should have five nodes")
       assert_equal(2, @child3.size, "Should have two nodes")
 
+      # Test the addition of a duplicate node (duplicate being defined as a node with the same name).
       assert_raise(RuntimeError) { @root.add(Tree::TreeNode.new(@child1.name)) }
 
+      # Test the addition of a nil node.
+      assert_raise(ArgumentError) { @root.add(nil) }
     end
 
+    # Test the remove! and removeAll! methods.
     def test_remove_bang
       @root << @child1
       @root << @child2
@@ -282,10 +320,16 @@ module TestTree
       assert(!@root.hasChildren?, "Should have no children")
       assert_equal(1, @root.size, "Should have one node")
 
+      # Some negative testing
+      @root.remove!(nil)
+      assert(!@root.hasChildren?, "Should have no children")
+      assert_equal(1, @root.size, "Should have one node")
     end
 
+    # Test the removeAll! method.
     def test_removeAll_bang
-      loadChildren
+      setup_test_tree
+
       assert(@root.hasChildren?, "Should have children")
       @root.removeAll!
 
@@ -293,8 +337,9 @@ module TestTree
       assert_equal(1, @root.size, "Should have one node")
     end
 
+    # Test the removeFromParent! method.
     def test_removeFromParent_bang
-      loadChildren
+      setup_test_tree
       assert(@root.hasChildren?, "Should have children")
       assert(!@root.isLeaf?, "Root is not a leaf here")
 
@@ -310,8 +355,9 @@ module TestTree
       assert_same(child1, child1.root, "Child 1's root should still be self")
     end
 
+    # Test the children method.
     def test_children
-      loadChildren
+      setup_test_tree
 
       assert(@root.hasChildren?, "Should have children")
       assert_equal(5, @root.size, "Should have five nodes")
@@ -341,8 +387,9 @@ module TestTree
 
     end
 
+    # Test the firstChild method.
     def test_firstChild
-      loadChildren
+      setup_test_tree
 
       assert_equal(@child1, @root.firstChild, "Root's first child is Child1")
       assert_nil(@child1.firstChild, "Child1 does not have any children")
@@ -350,8 +397,9 @@ module TestTree
 
     end
 
+    # Test the lastChild method.
     def test_lastChild
-      loadChildren
+      setup_test_tree
 
       assert_equal(@child3, @root.lastChild, "Root's last child is Child3")
       assert_nil(@child1.lastChild, "Child1 does not have any children")
@@ -359,8 +407,9 @@ module TestTree
 
     end
 
+    # Test the find method.
     def test_find
-      loadChildren
+      setup_test_tree
       foundNode = @root.find { |node| node == @child2}
       assert_same(@child2, foundNode, "The node should be Child 2")
 
@@ -373,16 +422,18 @@ module TestTree
       assert_nil(foundNode, "The node should not be found")
     end
 
+    # Test the parentage method.
     def test_parentage
-      loadChildren
+      setup_test_tree
 
       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
 
+    # Test the each method.
     def test_each
-      loadChildren
+      setup_test_tree
       assert(@root.hasChildren?, "Should have children")
       assert_equal(5, @root.size, "Should have five nodes")
       assert(@child3.hasChildren?, "Should have children")
@@ -398,8 +449,9 @@ module TestTree
       assert(nodes.include?(@child4), "Should have child 4")
     end
 
+    # Test the each_leaf method.
     def test_each_leaf
-      loadChildren
+      setup_test_tree
 
       nodes = []
       @root.each_leaf { |node| nodes << node }
@@ -412,8 +464,9 @@ module TestTree
       assert(nodes.include?(@child4), "Should have child 4")
     end
 
+    # Test the parent method.
     def test_parent
-      loadChildren
+      setup_test_tree
       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")
@@ -421,16 +474,19 @@ module TestTree
       assert_equal(@root, @child4.parent.parent, "Parent should be root")
     end
 
+    # Test the [] method.
     def test_indexed_access
-      loadChildren
+      setup_test_tree
       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] }
+      assert_nil(@root[99], "Should be nil")
+      assert_raise(ArgumentError) { @root[nil] }
     end
 
+    # Test the printTree method.
     def test_printTree
-      loadChildren
+      setup_test_tree
       #puts
       #@root.printTree
     end
@@ -482,7 +538,7 @@ module TestTree
 
     # Test the collect method from the mixed-in Enumerable functionality.
     def test_collect
-      loadChildren
+      setup_test_tree
       collectArray = @root.collect do |node|
         node.content = "abc"
         node
@@ -492,7 +548,7 @@ module TestTree
 
     # Test freezing the tree
     def test_freezeTree_bang
-      loadChildren
+      setup_test_tree
       @root.content = "ABC"
       assert_equal("ABC", @root.content, "Content should be 'ABC'")
       @root.freezeTree!
@@ -569,7 +625,7 @@ module TestTree
     def test_nodeDepth
       assert_equal(0, @root.nodeDepth, "A root node's depth is 0")
 
-      loadChildren
+      setup_test_tree
       for child in [@child1, @child2, @child3]
         assert_equal(1, child.nodeDepth, "Node #{child.name} should have depth 1")
       end
@@ -577,6 +633,21 @@ module TestTree
       assert_equal(2, @child4.nodeDepth, "Child 4 should have depth 2")
     end
 
+    # Test the level method.  Since this is an alias of nodeDepth, we just test for equivalence
+    def test_level
+      assert_equal(0, @root.level, "A root node's level is 0")
+
+      assert_equal(@root.nodeDepth, @root.level, "Level and depth should be the same")
+
+      setup_test_tree
+      for child in [@child1, @child2, @child3]
+        assert_equal(1, child.level, "Node #{child.name} should have level 1")
+        assert_equal(@root.nodeDepth, @root.level, "Level and depth should be the same")
+      end
+
+      assert_equal(2, @child4.level, "Child 4 should have level 2")
+    end
+
     # Test the breadth computation algorithm
     def test_breadth
       assert_equal(1, @root.breadth, "A single node's breadth is 1")
@@ -633,7 +704,7 @@ module TestTree
       end
     end
 
-
+    # Test the preordered_each method.
     def test_preordered_each
       j = Tree::TreeNode.new("j")
       f = Tree::TreeNode.new("f")
@@ -667,8 +738,9 @@ module TestTree
       end
     end
 
+    # test the detached_copy method.
     def test_detached_copy
-      loadChildren
+      setup_test_tree
 
       assert(@root.hasChildren?, "The root should have children")
       copy_of_root = @root.detached_copy
@@ -683,22 +755,26 @@ module TestTree
       assert(!copy_of_child3.hasChildren?, "Child 3's copy does not have children")
     end
 
+    # Test the hasChildren? method.
     def test_hasChildren_eh
-      loadChildren
+      setup_test_tree
       assert(@root.hasChildren?, "The Root node MUST have children")
     end
 
+    # test the isLeaf? method.
     def test_isLeaf_eh
-      loadChildren
+      setup_test_tree
       assert(!@child3.isLeaf?, "Child 3 is not a leaf node")
       assert(@child4.isLeaf?, "Child 4 is a leaf node")
     end
 
+    # Test the isRoot? method.
     def test_isRoot_eh
-      loadChildren
+      setup_test_tree
       assert(@root.isRoot?, "The ROOT node must respond as the root node")
     end
 
+    # Test the content= method.
     def test_content_equals
       @root.content = nil
       assert_nil(@root.content, "Root's content should be nil")
@@ -706,13 +782,15 @@ module TestTree
       assert_equal("ABCD", @root.content, "Root's content should now be 'ABCD'")
     end
 
+    # Test the size method.
     def test_size
       assert_equal(1, @root.size, "Root's size should be 1")
-      loadChildren
+      setup_test_tree
       assert_equal(5, @root.size, "Root's size should be 5")
       assert_equal(2, @child3.size, "Child 3's size should be 2")
     end
 
+    # Test the << method.
     def test_lt2                # Test the << method
       @root << @child1
       @root << @child2
@@ -723,8 +801,9 @@ module TestTree
       assert_not_nil(@child3['Child31'], "Child 31 should have been added to Child3")
     end
 
+    # Test the [] method.
     def test_index              #  Test the [] method
-      assert_raise(RuntimeError) {@root[nil]}
+      assert_raise(ArgumentError) {@root[nil]}
 
       @root << @child1
       @root << @child2
@@ -736,6 +815,81 @@ module TestTree
       assert_nil(@root['Some Random Name'], "Should return nil")
       assert_nil(@root[99], "Should return nil")
     end
+
+    # Test the in_degree method.
+    def test_in_degree
+      setup_test_tree
+
+      assert_equal(0, @root.in_degree, "Root's in-degree should be zero")
+      assert_equal(1, @child1.in_degree, "Child 1's in-degree should be 1")
+      assert_equal(1, @child2.in_degree, "Child 2's in-degree should be 1")
+      assert_equal(1, @child3.in_degree, "Child 3's in-degree should be 1")
+      assert_equal(1, @child4.in_degree, "Child 4's in-degree should be 1")
+    end
+
+    # Test the out_degree method.
+    def test_out_degree
+      setup_test_tree
+
+      assert_equal(3, @root.out_degree, "Root's out-degree should be 3")
+      assert_equal(0, @child1.out_degree, "Child 1's out-degree should be 0")
+      assert_equal(0, @child2.out_degree, "Child 2's out-degree should be 0")
+      assert_equal(1, @child3.out_degree, "Child 3's out-degree should be 1")
+      assert_equal(0, @child4.out_degree, "Child 4's out-degree should be 0")
+    end
+
+    # Test the new JSON serialization method.
+    def test_json_serialization
+      setup_test_tree
+
+      expected_json = {
+        "name"         => "ROOT",
+        "content"      => "Root Node",
+        JSON.create_id => "Tree::TreeNode",
+        "children" => [
+          {"name" => "Child1", "content" => "Child Node 1", JSON.create_id => "Tree::TreeNode"},
+          {"name" => "Child2", "content" => "Child Node 2", JSON.create_id => "Tree::TreeNode"},
+          {
+            "name"         => "Child3",
+            "content"      => "Child Node 3",
+            JSON.create_id => "Tree::TreeNode",
+            "children" => [
+              {"name" => "Child31", "content" => "Grand Child 1", JSON.create_id => "Tree::TreeNode"}
+            ]
+          }
+        ]
+      }.to_json
+
+      assert_equal(expected_json, @root.to_json)
+    end
+
+    def test_json_deserialization
+      tree_as_json = {
+        "name"         => "ROOT",
+        "content"      => "Root Node",
+        JSON.create_id => "Tree::TreeNode",
+        "children" => [
+          {"name" => "Child1", "content" => "Child Node 1", JSON.create_id => "Tree::TreeNode"},
+          {"name" => "Child2", "content" => "Child Node 2", JSON.create_id => "Tree::TreeNode"},
+          {
+            "name"         => "Child3",
+            "content"      => "Child Node 3",
+            JSON.create_id => "Tree::TreeNode",
+            "children" => [
+              {"name" => "Child31", "content" => "Grand Child 1", JSON.create_id => "Tree::TreeNode"}
+            ]
+          }
+        ]
+      }.to_json
+
+      tree = JSON.parse(tree_as_json)
+
+      assert_equal(@root.name, tree.root.name, "Root should be returned")
+      assert_equal(@child1.name, tree[0].name, "Child 1 should be returned")
+      assert_equal(@child2.name, tree[1].name, "Child 2 should be returned")
+      assert_equal(@child3.name, tree[2].name, "Child 3 should be returned")
+      assert_equal(@child4.name, tree[2][0].name, "Grand Child 1 should be returned")
+    end
   end
 end