kristofer
/
JavaExercism
Прати 1
Волим 0
Креирај огранак 1
Код Дискусије 0 Захтеви за спајање 0 Издања 1 Вики Activity
Преглед изворни кода

binary-search-tree: rename variable

MichaelSpets пре 9 година
родитељ
0fece3e237
комит
cc8ac2d7ad
1 измењених фајлова са 32 додато и 32 уклоњено
Подељен поглед Покажи статистику Diff
  1. 32
    32
      exercises/binary-search-tree/src/test/java/BSTTest.java

+ 32
- 32
exercises/binary-search-tree/src/test/java/BSTTest.java Прегледај датотеку 

@@ -11,10 +11,10 @@ public class BSTTest {
11 11
12 12 
     @Test
13 13 
     public void dataIsRetained() {
14 
-        BST<Integer> sut = new BST();
14 
+        BST<Integer> bst = new BST();
15 15 
         final int actual = 4;
16 
-        sut.insert(actual);
17 
-        final BST.Node<Integer> root = sut.getRoot();
16 
+        bst.insert(actual);
17 
+        final BST.Node<Integer> root = bst.getRoot();
18 18 
         assertNotNull(root);
19 19 
         final int expected = root.getData();
20 20 
         assertEquals(expected, actual);
 
@@ -23,14 +23,14 @@ public class BSTTest {
23 23 
     @Test
24 24 
     @Ignore("Remove to run test")
25 25 
     public void insertsLess() {
26 
-        BST<Integer> sut = new BST();
26 
+        BST<Integer> bst = new BST();
27 27 
         final int expectedRoot = 4;
28 28 
         final int expectedLeft = 2;
29 29
30 
-        sut.insert(expectedRoot);
31 
-        sut.insert(expectedLeft);
30 
+        bst.insert(expectedRoot);
31 
+        bst.insert(expectedLeft);
32 32
33 
-        final BST.Node<Integer> root = sut.getRoot();
33 
+        final BST.Node<Integer> root = bst.getRoot();
34 34 
         assertNotNull(root);
35 35 
         final BST.Node<Integer> left = root.getLeft();
36 36 
         assertNotNull(left);
 
@@ -44,14 +44,14 @@ public class BSTTest {
44 44 
     @Test
45 45 
     @Ignore("Remove to run test")
46 46 
     public void insertsSame() {
47 
-        BST<Integer> sut = new BST();
47 
+        BST<Integer> bst = new BST();
48 48 
         final int expectedRoot = 4;
49 49 
         final int expectedLeft = 4;
50 50
51 
-        sut.insert(expectedRoot);
52 
-        sut.insert(expectedLeft);
51 
+        bst.insert(expectedRoot);
52 
+        bst.insert(expectedLeft);
53 53
54 
-        final BST.Node<Integer> root = sut.getRoot();
54 
+        final BST.Node<Integer> root = bst.getRoot();
55 55 
         assertNotNull(root);
56 56 
         final BST.Node<Integer> left = root.getLeft();
57 57 
         assertNotNull(left);
 
@@ -65,14 +65,14 @@ public class BSTTest {
65 65 
     @Test
66 66 
     @Ignore("Remove to run test")
67 67 
     public void insertsRight() {
68 
-        BST<Integer> sut = new BST();
68 
+        BST<Integer> bst = new BST();
69 69 
         final int expectedRoot = 4;
70 70 
         final int expectedRight = 5;
71 71
72 
-        sut.insert(expectedRoot);
73 
-        sut.insert(expectedRight);
72 
+        bst.insert(expectedRoot);
73 
+        bst.insert(expectedRight);
74 74
75 
-        final BST.Node<Integer> root = sut.getRoot();
75 
+        final BST.Node<Integer> root = bst.getRoot();
76 76 
         assertNotNull(root);
77 77 
         final BST.Node<Integer> right = root.getRight();
78 78 
         assertNotNull(right);
 
@@ -86,7 +86,7 @@ public class BSTTest {
86 86 
     @Test
87 87 
     @Ignore("Remove to run test")
88 88 
     public void createsComplexTree() {
89 
-        BST<Integer> sut = new BST<>();
89 
+        BST<Integer> bst = new BST<>();
90 90 
         List<Integer> expected = Collections.unmodifiableList(
91 91 
                 Arrays.asList(4, 2, 6, 1, 3, 5, 7)
92 92 
         );
 
@@ -94,60 +94,60 @@ public class BSTTest {
94 94 
         List<Integer> treeData = Collections.unmodifiableList(
95 95 
                 Arrays.asList(4, 2, 6, 1, 3, 7, 5)
96 96 
         );
97 
-        treeData.forEach(sut::insert);
97 
+        treeData.forEach(bst::insert);
98 98
99 
-        List<Integer> actual = sut.getAsLevelOrderList();
99 
+        List<Integer> actual = bst.getAsLevelOrderList();
100 100 
         assertEquals(expected, actual);
101 101 
     }
102 102
103 103 
     @Test
104 104 
     @Ignore("Remove to run test")
105 105 
     public void sortsSingleElement() {
106 
-        BST<Integer> sut = new BST<>();
106 
+        BST<Integer> bst = new BST<>();
107 107 
         List<Integer> expected = Collections.unmodifiableList(
108 108 
                 Collections.singletonList(4)
109 109 
         );
110 110
111 
-        sut.insert(4);
111 
+        bst.insert(4);
112 112
113 
-        List<Integer> actual = sut.getAsSortedList();
113 
+        List<Integer> actual = bst.getAsSortedList();
114 114 
         assertEquals(expected, actual);
115 115 
     }
116 116
117 117 
     @Test
118 118 
     @Ignore("Remove to run test")
119 119 
     public void sortsCollectionOfTwoIfSecondInsertedIsSmallerThanFirst() {
120 
-        BST<Integer> sut = new BST<>();
120 
+        BST<Integer> bst = new BST<>();
121 121 
         List<Integer> expected = Collections.unmodifiableList(
122 122 
                 Arrays.asList(2, 4)
123 123 
         );
124 124
125 
-        sut.insert(4);
126 
-        sut.insert(2);
125 
+        bst.insert(4);
126 
+        bst.insert(2);
127 127
128 
-        List<Integer> actual = sut.getAsSortedList();
128 
+        List<Integer> actual = bst.getAsSortedList();
129 129 
         assertEquals(expected, actual);
130 130 
     }
131 131
132 132 
     @Test
133 133 
     @Ignore("Remove to run test")
134 134 
     public void sortsCollectionOfTwoIfSecondInsertedIsBiggerThanFirst() {
135 
-        BST<Integer> sut = new BST<>();
135 
+        BST<Integer> bst = new BST<>();
136 136 
         List<Integer> expected = Collections.unmodifiableList(
137 137 
                 Arrays.asList(4, 5)
138 138 
         );
139 139
140 
-        sut.insert(4);
141 
-        sut.insert(5);
140 
+        bst.insert(4);
141 
+        bst.insert(5);
142 142
143 
-        List<Integer> actual = sut.getAsSortedList();
143 
+        List<Integer> actual = bst.getAsSortedList();
144 144 
         assertEquals(expected, actual);
145 145 
     }
146 146
147 147 
     @Test
148 148 
     @Ignore("Remove to run test")
149 149 
     public void iteratesOverComplexTree() {
150 
-        BST<Integer> sut = new BST<>();
150 
+        BST<Integer> bst = new BST<>();
151 151 
         List<Integer> expected = Collections.unmodifiableList(
152 152 
                 Arrays.asList(1, 2, 3, 4, 5, 6, 7)
153 153 
         );
 
@@ -155,9 +155,9 @@ public class BSTTest {
155 155 
         List<Integer> treeData = Collections.unmodifiableList(
156 156 
                 Arrays.asList(4, 2, 1, 3, 6, 7, 5)
157 157 
         );
158 
-        treeData.forEach(sut::insert);
158 
+        treeData.forEach(bst::insert);
159 159
160 
-        List<Integer> actual = sut.getAsSortedList();
160 
+        List<Integer> actual = bst.getAsSortedList();
161 161 
         assertEquals(expected, actual);
162 162 
     }
163 163 
 }