binary_tree_js/tree_spec.js at master · cj3kim/binary_tree_js · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

describe( "tree", function () {

  describe("initialization", function () {
    it( "initializes a node with no parameters", function () {
      var tree = new Tree();
      expect(tree.key).toEqual(null);
      expect(tree.left).toEqual(null);
      expect(tree.right).toEqual(null);
      expect(tree.parent).toEqual(null);
    });

    it (" initializes a node with single key parameter", function () {
      var tree = new Tree(1);
      expect(tree.key).toEqual(1);
      expect(tree.left).toEqual(null);
      expect(tree.right).toEqual(null);
      expect(tree.parent).toEqual(null);
    });
  });

  describe("#checkTreeValue", function () {
    var originTree;
    beforeEach(function () {
      originTree = new Tree(10);
    })

    describe("check the value of the tree's key property ", function () {
      it("is 10", function () {
        expect(originTree.key).toEqual(checkTreeProperty(originTree.key));
      });
      it("is null", function () {
        var tree = new Tree();
        expect(tree.key).toEqual(null);
        expect(tree.key).toEqual(checkTreeProperty(tree.key));
      })
    });

    describe("check the tree's left property", function () {
      it("is null", function () {
        expect(originTree.left).toEqual(null);
        expect(originTree.left).toEqual(checkTreeProperty(originTree.left));
      });
      it("is a tree", function () {
      })
    })

    describe("check the tree's right property", function () {
      it("is null", function () {
        expect(originTree.right).toEqual(null);
        expect(originTree.right).toEqual(checkTreeProperty(originTree.right));
      });
    })
  });

  describe("#insertKey", function () {
    var firstTree;
    beforeEach( function () {
      firstTree = new Tree(100);
    });

    describe("insertion if key value > key value of current tree", function () {
      describe("right property of tree is null", function () {
        it("assigns it a new tree instance", function () {
          var rightProp = insertKey(firstTree, 200);
          expect(rightProp instanceof Tree).toBe(true);
          expect(rightProp.parent).toBe(firstTree);
        });
      });

      describe("right property of tree is not null", function () {
        describe("recursive invocation of insertKey", function() {
          it("returns a new tree", function (){
            insertKey(firstTree, 250);
            var input1 =insertKey(firstTree, 300)
            var input2 = insertKey(firstTree, 400)
            expect(input2.key).toEqual(400);
            expect(input2.parent).toBe(input1);
          });
        })
      });
    });

    describe("insertion if  value < current tree", function () {
      describe("left property of tree is null", function () {
        it("assigns it a new tree instance", function () {
          var leftProp = insertKey(firstTree, 200);
          expect(leftProp instanceof Tree).toBe(true);
          expect(leftProp.parent).toBe(firstTree);
        });
      });

      describe("left property of tree is not null", function () {
        describe("recursive invocation of insertKey", function() {
          it("returns a new tree", function () {
            insertKey(firstTree, 50);
            var input1 = insertKey(firstTree, 28)
            var input2 = insertKey(firstTree, 23)
            expect(input2.key).toEqual(23);
            expect(input2.parent).toBe(input1);
          });
        })
      });
    });

    describe("insertion if key value === current tree", function () {
      it("return the passed in tree", function () {
        expect(firstTree).toEqual(insertKey(firstTree, 100));
      });
    });
  });

  describe("returnTree", function () {
    it("returns a tree based on its key value", function () {
      var originTree = new Tree(1000);
      var tree1 = insertKey(originTree, 750);
      var tree2 = insertKey(originTree, 500);
      var tree3 = insertKey(originTree, 250);

      expect(returnTree(originTree, 250)).toBe(tree3);
      expect(returnTree(originTree, 500)).toBe(tree2);
    });
  })
});