Bladeren bron

removed from tests grade-school and binary-search-tree

Kulkarni, AadityaArvind 6 jaren geleden
bovenliggende
commit
5d31a90fc5

+ 22
- 22
exercises/binary-search-tree/src/test/java/BinarySearchTreeTest.java Bestand weergeven

13
     public void dataIsRetained() {
13
     public void dataIsRetained() {
14
         BinarySearchTree<Integer> binarySearchTree = new BinarySearchTree<>();
14
         BinarySearchTree<Integer> binarySearchTree = new BinarySearchTree<>();
15
 
15
 
16
-        final int expected = 4;
16
+        int expected = 4;
17
         binarySearchTree.insert(expected);
17
         binarySearchTree.insert(expected);
18
 
18
 
19
-        final BinarySearchTree.Node<Integer> root = binarySearchTree.getRoot();
19
+        BinarySearchTree.Node<Integer> root = binarySearchTree.getRoot();
20
         assertNotNull(root);
20
         assertNotNull(root);
21
 
21
 
22
-        final int actual = root.getData();
22
+        int actual = root.getData();
23
         assertEquals(expected, actual);
23
         assertEquals(expected, actual);
24
     }
24
     }
25
 
25
 
27
     @Test
27
     @Test
28
     public void insertsLess() {
28
     public void insertsLess() {
29
         BinarySearchTree<Character> binarySearchTree = new BinarySearchTree<>();
29
         BinarySearchTree<Character> binarySearchTree = new BinarySearchTree<>();
30
-        final char expectedRoot = '4';
31
-        final char expectedLeft = '2';
30
+        char expectedRoot = '4';
31
+        char expectedLeft = '2';
32
 
32
 
33
         binarySearchTree.insert(expectedRoot);
33
         binarySearchTree.insert(expectedRoot);
34
         binarySearchTree.insert(expectedLeft);
34
         binarySearchTree.insert(expectedLeft);
35
 
35
 
36
-        final BinarySearchTree.Node<Character> root = binarySearchTree.getRoot();
36
+        BinarySearchTree.Node<Character> root = binarySearchTree.getRoot();
37
         assertNotNull(root);
37
         assertNotNull(root);
38
-        final BinarySearchTree.Node<Character> left = root.getLeft();
38
+        BinarySearchTree.Node<Character> left = root.getLeft();
39
         assertNotNull(left);
39
         assertNotNull(left);
40
 
40
 
41
-        final char actualRoot = root.getData();
42
-        final char actualLeft = left.getData();
41
+        char actualRoot = root.getData();
42
+        char actualLeft = left.getData();
43
         assertEquals(expectedLeft, actualLeft);
43
         assertEquals(expectedLeft, actualLeft);
44
         assertEquals(expectedRoot, actualRoot);
44
         assertEquals(expectedRoot, actualRoot);
45
     }
45
     }
48
     @Test
48
     @Test
49
     public void insertsSame() {
49
     public void insertsSame() {
50
         BinarySearchTree<String> binarySearchTree = new BinarySearchTree<>();
50
         BinarySearchTree<String> binarySearchTree = new BinarySearchTree<>();
51
-        final String expectedRoot = "4";
52
-        final String expectedLeft = "4";
51
+        String expectedRoot = "4";
52
+        String expectedLeft = "4";
53
 
53
 
54
         binarySearchTree.insert(expectedRoot);
54
         binarySearchTree.insert(expectedRoot);
55
         binarySearchTree.insert(expectedLeft);
55
         binarySearchTree.insert(expectedLeft);
56
 
56
 
57
-        final BinarySearchTree.Node<String> root = binarySearchTree.getRoot();
57
+        BinarySearchTree.Node<String> root = binarySearchTree.getRoot();
58
         assertNotNull(root);
58
         assertNotNull(root);
59
-        final BinarySearchTree.Node<String> left = root.getLeft();
59
+        BinarySearchTree.Node<String> left = root.getLeft();
60
         assertNotNull(left);
60
         assertNotNull(left);
61
 
61
 
62
-        final String actualRoot = root.getData();
63
-        final String actualLeft = left.getData();
62
+        String actualRoot = root.getData();
63
+        String actualLeft = left.getData();
64
         assertEquals(expectedLeft, actualLeft);
64
         assertEquals(expectedLeft, actualLeft);
65
         assertEquals(expectedRoot, actualRoot);
65
         assertEquals(expectedRoot, actualRoot);
66
     }
66
     }
69
     @Test
69
     @Test
70
     public void insertsRight() {
70
     public void insertsRight() {
71
         BinarySearchTree<Integer> binarySearchTree = new BinarySearchTree<>();
71
         BinarySearchTree<Integer> binarySearchTree = new BinarySearchTree<>();
72
-        final int expectedRoot = 4;
73
-        final int expectedRight = 5;
72
+        int expectedRoot = 4;
73
+        int expectedRight = 5;
74
 
74
 
75
         binarySearchTree.insert(expectedRoot);
75
         binarySearchTree.insert(expectedRoot);
76
         binarySearchTree.insert(expectedRight);
76
         binarySearchTree.insert(expectedRight);
77
 
77
 
78
-        final BinarySearchTree.Node<Integer> root = binarySearchTree.getRoot();
78
+        BinarySearchTree.Node<Integer> root = binarySearchTree.getRoot();
79
         assertNotNull(root);
79
         assertNotNull(root);
80
-        final BinarySearchTree.Node<Integer> right = root.getRight();
80
+        BinarySearchTree.Node<Integer> right = root.getRight();
81
         assertNotNull(right);
81
         assertNotNull(right);
82
 
82
 
83
-        final int actualRoot = root.getData();
84
-        final int actualRight = right.getData();
83
+        int actualRoot = root.getData();
84
+        int actualRight = right.getData();
85
         assertEquals(expectedRight, actualRight);
85
         assertEquals(expectedRight, actualRight);
86
         assertEquals(expectedRoot, actualRoot);
86
         assertEquals(expectedRoot, actualRoot);
87
     }
87
     }
131
         List<Integer> actual = binarySearchTree.getAsSortedList();
131
         List<Integer> actual = binarySearchTree.getAsSortedList();
132
         assertEquals(expected, actual);
132
         assertEquals(expected, actual);
133
     }
133
     }
134
-    
134
+
135
     @Ignore("Remove to run test")
135
     @Ignore("Remove to run test")
136
     @Test
136
     @Test
137
     public void sortsCollectionOfTwoIfSecondNumberisSameAsFirst() {
137
     public void sortsCollectionOfTwoIfSecondNumberisSameAsFirst() {

+ 1
- 1
exercises/grade-school/src/test/java/SchoolTest.java Bestand weergeven

38
   @Ignore("Remove to run test")
38
   @Ignore("Remove to run test")
39
   @Test
39
   @Test
40
   public void addsMoreStudentsInSameGrade() {
40
   public void addsMoreStudentsInSameGrade() {
41
-    final int grade = 2;
41
+    int grade = 2;
42
     school.add("James", grade);
42
     school.add("James", grade);
43
     school.add("Blair", grade);
43
     school.add("Blair", grade);
44
     school.add("Paul", grade);
44
     school.add("Paul", grade);