exercism-moonscript/exercises/practice/binary-search-tree/binary_search_tree_spec.moon at 9db4420eb8085387c3d41a11912695408dc7fbf7 · glennj/exercism-moonscript · 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
BinarySearchTree = require 'binary_search_tree'

describe 'binary-search-tree', ->
  it 'data is retained', ->
    tree = BinarySearchTree {'4'}
    result = tree\data!
    expected = {
        left: nil
        right: nil
        data: "4"
    }
    assert.are.same expected, result

  describe 'insert data at proper node', ->
    pending 'smaller number at left node', ->
      tree = BinarySearchTree {'4', '2'}
      result = tree\data!
      expected = {
          left: {
              left: nil
              right: nil
              data: "2"
          }
          right: nil
          data: "4"
      }
      assert.are.same expected, result

    pending 'same number at left node', ->
      tree = BinarySearchTree {'4', '4'}
      result = tree\data!
      expected = {
          left: {
              left: nil
              right: nil
              data: "4"
          }
          right: nil
          data: "4"
      }
      assert.are.same expected, result

    pending 'greater number at right node', ->
      tree = BinarySearchTree {'4', '5'}
      result = tree\data!
      expected = {
          left: nil
          right: {
              left: nil
              right: nil
              data: "5"
          }
          data: "4"
      }
      assert.are.same expected, result

  pending 'can create complex tree', ->
    tree = BinarySearchTree {'4', '2', '6', '1', '3', '5', '7'}
    result = tree\data!
    expected = {
        left: {
            left: {
                left: nil
                right: nil
                data: "1"
            }
            right: {
                left: nil
                right: nil
                data: "3"
            }
            data: "2"
        }
        right: {
            left: {
                left: nil
                right: nil
                data: "5"
            }
            right: {
                left: nil
                right: nil
                data: "7"
            }
            data: "6"
        }
        data: "4"
    }
    assert.are.same expected, result

  describe 'can sort data', ->
    pending 'can sort single number', ->
      tree = BinarySearchTree {'2'}
      result = tree\sorted!
      expected = {'2'}
      assert.are.same expected, result

    pending 'can sort if second number is smaller than first', ->
      tree = BinarySearchTree {'2', '1'}
      result = tree\sorted!
      expected = {'1', '2'}
      assert.are.same expected, result

    pending 'can sort if second number is same as first', ->
      tree = BinarySearchTree {'2', '2'}
      result = tree\sorted!
      expected = {'2', '2'}
      assert.are.same expected, result

    pending 'can sort if second number is greater than first', ->
      tree = BinarySearchTree {'2', '3'}
      result = tree\sorted!
      expected = {'2', '3'}
      assert.are.same expected, result

    pending 'can sort complex tree', ->
      tree = BinarySearchTree {'2', '1', '3', '6', '7', '5'}
      result = tree\sorted!
      expected = {'1', '2', '3', '5', '6', '7'}
      assert.are.same expected, result