kristofer
/
JavaExercism
關注 1
收藏 0
複製 1
程式碼 問題 0 合併請求 0 版本發佈 1 Wiki 活動
瀏覽代碼

Merge pull request #638 from michaelspets/rename-sut 

Rename sut variable [Fix #621 #622 #623 #624]
Stuart Kent 9 年之前
父節點
60bf4696e7 7acd61b229
當前提交
73e66862d1
共有 4 個檔案被更改，包括 80 行新增 和 80 行删除
分割檢視 顯示文件統計
  1. 32
    32
      exercises/binary-search-tree/src/test/java/BSTTest.java
  2. 20
    20
      exercises/binary-search/src/test/java/BinarySearchTest.java
  3. 8
    8
      exercises/pythagorean-triplet/src/test/java/PythagoreanTripletTest.java
  4. 20
    20
      exercises/series/src/test/java/SeriesTest.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 
 }

+ 20
- 20
exercises/binary-search/src/test/java/BinarySearchTest.java 查看文件 

@@ -15,9 +15,9 @@ public class BinarySearchTest {
15 15 
     public void findsAValueInAnArrayWithOneElement() {
16 16 
         List<Integer> listOfUnitLength = Collections.singletonList(6);
17 17
18 
-        BinarySearch<Integer> sut = new BinarySearch<>(listOfUnitLength);
18 
+        BinarySearch<Integer> search = new BinarySearch<>(listOfUnitLength);
19 19
20 
-        assertEquals(0, sut.indexOf(6));
20 
+        assertEquals(0, search.indexOf(6));
21 21 
     }
22 22
23 23 
     @Ignore("Remove to run test")
 
@@ -27,9 +27,9 @@ public class BinarySearchTest {
27 27 
                 Arrays.asList(1, 3, 4, 6, 8, 9, 11)
28 28 
         );
29 29
30 
-        BinarySearch<Integer> sut = new BinarySearch<>(sortedList);
30 
+        BinarySearch<Integer> search = new BinarySearch<>(sortedList);
31 31
32 
-        assertEquals(3, sut.indexOf(6));
32 
+        assertEquals(3, search.indexOf(6));
33 33 
     }
34 34
35 35 
     @Ignore("Remove to run test")
 
@@ -39,9 +39,9 @@ public class BinarySearchTest {
39 39 
                 Arrays.asList(1, 3, 4, 6, 8, 9, 11)
40 40 
         );
41 41
42 
-        BinarySearch<Integer> sut = new BinarySearch<>(sortedList);
42 
+        BinarySearch<Integer> search = new BinarySearch<>(sortedList);
43 43
44 
-        assertEquals(0, sut.indexOf(1));
44 
+        assertEquals(0, search.indexOf(1));
45 45 
     }
46 46
47 47 
     @Ignore("Remove to run test")
 
@@ -51,9 +51,9 @@ public class BinarySearchTest {
51 51 
                 Arrays.asList(1, 3, 4, 6, 8, 9, 11)
52 52 
         );
53 53
54 
-        BinarySearch<Integer> sut = new BinarySearch<>(sortedList);
54 
+        BinarySearch<Integer> search = new BinarySearch<>(sortedList);
55 55
56 
-        assertEquals(6, sut.indexOf(11));
56 
+        assertEquals(6, search.indexOf(11));
57 57 
     }
58 58
59 59 
     @Ignore("Remove to run test")
 
@@ -63,9 +63,9 @@ public class BinarySearchTest {
63 63 
                 Arrays.asList(1, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 634)
64 64 
         );
65 65
66 
-        BinarySearch<Integer> sut = new BinarySearch<>(sortedListOfOddLength);
66 
+        BinarySearch<Integer> search = new BinarySearch<>(sortedListOfOddLength);
67 67
68 
-        assertEquals(9, sut.indexOf(144));
68 
+        assertEquals(9, search.indexOf(144));
69 69 
     }
70 70
71 71 
     @Ignore("Remove to run test")
 
@@ -75,9 +75,9 @@ public class BinarySearchTest {
75 75 
                 Arrays.asList(1, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377)
76 76 
         );
77 77
78 
-        BinarySearch<Integer> sut = new BinarySearch<>(sortedListOfEvenLength);
78 
+        BinarySearch<Integer> search = new BinarySearch<>(sortedListOfEvenLength);
79 79
80 
-        assertEquals(5, sut.indexOf(21));
80 
+        assertEquals(5, search.indexOf(21));
81 81 
     }
82 82
83 83 
     @Ignore("Remove to run test")
 
@@ -87,9 +87,9 @@ public class BinarySearchTest {
87 87 
                 Arrays.asList(1, 3, 4, 6, 8, 9, 11)
88 88 
         );
89 89
90 
-        BinarySearch<Integer> sut = new BinarySearch<>(sortedList);
90 
+        BinarySearch<Integer> search = new BinarySearch<>(sortedList);
91 91
92 
-        assertEquals(-1, sut.indexOf(7));
92 
+        assertEquals(-1, search.indexOf(7));
93 93 
     }
94 94
95 95 
     @Ignore("Remove to run test")
 
@@ -99,9 +99,9 @@ public class BinarySearchTest {
99 99 
                 Arrays.asList(1, 3, 4, 6, 8, 9, 11)
100 100 
         );
101 101
102 
-        BinarySearch<Integer> sut = new BinarySearch<>(sortedList);
102 
+        BinarySearch<Integer> search = new BinarySearch<>(sortedList);
103 103
104 
-        assertEquals(-1, sut.indexOf(0));
104 
+        assertEquals(-1, search.indexOf(0));
105 105 
     }
106 106
107 107 
     @Ignore("Remove to run test")
 
@@ -111,9 +111,9 @@ public class BinarySearchTest {
111 111 
                 Arrays.asList(1, 3, 4, 6, 8, 9, 11)
112 112 
         );
113 113
114 
-        BinarySearch<Integer> sut = new BinarySearch<>(sortedList);
114 
+        BinarySearch<Integer> search = new BinarySearch<>(sortedList);
115 115
116 
-        assertEquals(-1, sut.indexOf(13));
116 
+        assertEquals(-1, search.indexOf(13));
117 117 
     }
118 118
119 119 
     @Ignore("Remove to run test")
 
@@ -121,8 +121,8 @@ public class BinarySearchTest {
121 121 
     public void nothingIsIncludedInAnEmptyArray() {
122 122 
         List<Integer> emptyList = Collections.emptyList();
123 123
124 
-        BinarySearch<Integer> sut = new BinarySearch<>(emptyList);
124 
+        BinarySearch<Integer> search = new BinarySearch<>(emptyList);
125 125
126 
-        assertEquals(-1, sut.indexOf(1));
126 
+        assertEquals(-1, search.indexOf(1));
127 127 
     }
128 128 
 }

+ 8
- 8
exercises/pythagorean-triplet/src/test/java/PythagoreanTripletTest.java 查看文件 

@@ -14,33 +14,33 @@ public class PythagoreanTripletTest {
14 14
15 15 
     @Test
16 16 
     public void shouldCalculateSum() {
17 
-        PythagoreanTriplet sut = new PythagoreanTriplet(3, 4, 5);
17 
+        PythagoreanTriplet triplet = new PythagoreanTriplet(3, 4, 5);
18 18 
         final int expected = 12;
19 
-        final int actual = sut.calculateSum();
19 
+        final int actual = triplet.calculateSum();
20 20 
         assertEquals(expected, actual);
21 21 
     }
22 22
23 23 
     @Test
24 24 
     @Ignore("Remove to run test")
25 25 
     public void shouldCalculateProduct() {
26 
-        PythagoreanTriplet sut = new PythagoreanTriplet(3, 4, 5);
26 
+        PythagoreanTriplet triplet = new PythagoreanTriplet(3, 4, 5);
27 27 
         final long expected = 60l;
28 
-        final long actual = sut.calculateProduct();
28 
+        final long actual = triplet.calculateProduct();
29 29 
         assertEquals(expected, actual);
30 30 
     }
31 31
32 32 
     @Test
33 33 
     @Ignore("Remove to run test")
34 34 
     public void testIsPythagoreanOK() {
35 
-        PythagoreanTriplet sut = new PythagoreanTriplet(3, 4, 5);
36 
-        assertTrue(sut.isPythagorean());
35 
+        PythagoreanTriplet triplet = new PythagoreanTriplet(3, 4, 5);
36 
+        assertTrue(triplet.isPythagorean());
37 37 
     }
38 38
39 39 
     @Test
40 40 
     @Ignore("Remove to run test")
41 41 
     public void testIsPythagoreanFail() {
42 
-        PythagoreanTriplet sut = new PythagoreanTriplet(5, 6, 7);
43 
-        assertFalse(sut.isPythagorean());
42 
+        PythagoreanTriplet triplet = new PythagoreanTriplet(5, 6, 7);
43 
+        assertFalse(triplet.isPythagorean());
44 44 
     }
45 45
46 46 
     @Test

+ 20
- 20
exercises/series/src/test/java/SeriesTest.java 查看文件 

@@ -17,9 +17,9 @@ public class SeriesTest {
17 17
18 18 
     @Test
19 19 
     public void hasDigitsShort() {
20 
-        Series sut = new Series("01234");
20 
+        Series series = new Series("01234");
21 21 
         List<Integer> expected = Arrays.asList(0, 1, 2, 3, 4);
22 
-        List<Integer> actual = sut.getDigits();
22 
+        List<Integer> actual = series.getDigits();
23 23 
         assertNotNull(actual);
24 24 
         assertFalse(actual.isEmpty());
25 25 
         assertEquals(expected, actual);
 
@@ -28,9 +28,9 @@ public class SeriesTest {
28 28 
     @Test
29 29 
     @Ignore("Remove to run test")
30 30 
     public void hasDigitsLong() {
31 
-        Series sut = new Series("0123456789");
31 
+        Series series = new Series("0123456789");
32 32 
         List<Integer> expected = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
33 
-        List<Integer> actual = sut.getDigits();
33 
+        List<Integer> actual = series.getDigits();
34 34 
         assertNotNull(actual);
35 35 
         assertFalse(actual.isEmpty());
36 36 
         assertEquals(expected, actual);
 
@@ -39,9 +39,9 @@ public class SeriesTest {
39 39 
     @Test
40 40 
     @Ignore("Remove to run test")
41 41 
     public void keepsTheDigitOrderIfReversed() {
42 
-        Series sut = new Series("9876543210");
42 
+        Series series = new Series("9876543210");
43 43 
         List<Integer> expected = Arrays.asList(9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
44 
-        List<Integer> actual = sut.getDigits();
44 
+        List<Integer> actual = series.getDigits();
45 45 
         assertNotNull(actual);
46 46 
         assertFalse(actual.isEmpty());
47 47 
         assertEquals(expected, actual);
 
@@ -50,9 +50,9 @@ public class SeriesTest {
50 50 
     @Test
51 51 
     @Ignore("Remove to run test")
52 52 
     public void keepsArbitraryDigitOrder() {
53 
-        Series sut = new Series("936923468");
53 
+        Series series = new Series("936923468");
54 54 
         List<Integer> expected = Arrays.asList(9, 3, 6, 9, 2, 3, 4, 6, 8);
55 
-        List<Integer> actual = sut.getDigits();
55 
+        List<Integer> actual = series.getDigits();
56 56 
         assertNotNull(actual);
57 57 
         assertFalse(actual.isEmpty());
58 58 
         assertEquals(expected, actual);
 
@@ -61,7 +61,7 @@ public class SeriesTest {
61 61 
     @Test
62 62 
     @Ignore("Remove to run test")
63 63 
     public void canSliceByOne() {
64 
-        Series sut = new Series("01234");
64 
+        Series series = new Series("01234");
65 65 
         List<List<Integer>> expected = Arrays.asList(
66 66 
                 Arrays.asList(0),
67 67 
                 Arrays.asList(1),
 
@@ -69,7 +69,7 @@ public class SeriesTest {
69 69 
                 Arrays.asList(3),
70 70 
                 Arrays.asList(4)
71 71 
         );
72 
-        List<List<Integer>> actual = sut.slices(1);
72 
+        List<List<Integer>> actual = series.slices(1);
73 73 
         assertNotNull(actual);
74 74 
         assertFalse(actual.isEmpty());
75 75 
         assertEquals(expected, actual);
 
@@ -78,7 +78,7 @@ public class SeriesTest {
78 78 
     @Test
79 79 
     @Ignore("Remove to run test")
80 80 
     public void canSliceByTwo() {
81 
-        Series sut = new Series("98273463");
81 
+        Series series = new Series("98273463");
82 82 
         List<List<Integer>> expected = Arrays.asList(
83 83 
                 Arrays.asList(9, 8),
84 84 
                 Arrays.asList(8, 2),
 
@@ -88,7 +88,7 @@ public class SeriesTest {
88 88 
                 Arrays.asList(4, 6),
89 89 
                 Arrays.asList(6, 3)
90 90 
         );
91 
-        List<List<Integer>> actual = sut.slices(2);
91 
+        List<List<Integer>> actual = series.slices(2);
92 92 
         assertNotNull(actual);
93 93 
         assertFalse(actual.isEmpty());
94 94 
         assertEquals(expected, actual);
 
@@ -97,13 +97,13 @@ public class SeriesTest {
97 97 
     @Test
98 98 
     @Ignore("Remove to run test")
99 99 
     public void canSliceByThree() {
100 
-        Series sut = new Series("01234");
100 
+        Series series = new Series("01234");
101 101 
         List<List<Integer>> expected = Arrays.asList(
102 102 
                 Arrays.asList(0, 1, 2),
103 103 
                 Arrays.asList(1, 2, 3),
104 104 
                 Arrays.asList(2, 3, 4)
105 105 
         );
106 
-        List<List<Integer>> actual = sut.slices(3);
106 
+        List<List<Integer>> actual = series.slices(3);
107 107 
         assertNotNull(actual);
108 108 
         assertFalse(actual.isEmpty());
109 109 
         assertEquals(expected, actual);
 
@@ -112,13 +112,13 @@ public class SeriesTest {
112 112 
     @Test
113 113 
     @Ignore("Remove to run test")
114 114 
     public void canSliceByThreeWithDuplicateDigits() {
115 
-        Series sut = new Series("31001");
115 
+        Series series = new Series("31001");
116 116 
         List<List<Integer>> expected = Arrays.asList(
117 117 
                 Arrays.asList(3, 1, 0),
118 118 
                 Arrays.asList(1, 0, 0),
119 119 
                 Arrays.asList(0, 0, 1)
120 120 
         );
121 
-        List<List<Integer>> actual = sut.slices(3);
121 
+        List<List<Integer>> actual = series.slices(3);
122 122 
         assertNotNull(actual);
123 123 
         assertFalse(actual.isEmpty());
124 124 
         assertEquals(expected, actual);
 
@@ -127,12 +127,12 @@ public class SeriesTest {
127 127 
     @Test
128 128 
     @Ignore("Remove to run test")
129 129 
     public void canSliceByFour() {
130 
-        Series sut = new Series("91274");
130 
+        Series series = new Series("91274");
131 131 
         List<List<Integer>> expected = Arrays.asList(
132 132 
                 Arrays.asList(9, 1, 2, 7),
133 133 
                 Arrays.asList(1, 2, 7, 4)
134 134 
         );
135 
-        List<List<Integer>> actual = sut.slices(4);
135 
+        List<List<Integer>> actual = series.slices(4);
136 136 
         assertNotNull(actual);
137 137 
         assertFalse(actual.isEmpty());
138 138 
         assertEquals(expected, actual);
 
@@ -141,11 +141,11 @@ public class SeriesTest {
141 141 
     @Test
142 142 
     @Ignore("Remove to run test")
143 143 
     public void canSliceByFive() {
144 
-        Series sut = new Series("81228");
144 
+        Series series = new Series("81228");
145 145 
         List<List<Integer>> expected = Arrays.asList(
146 146 
                 Arrays.asList(8, 1, 2, 2, 8)
147 147 
         );
148 
-        List<List<Integer>> actual = sut.slices(5);
148 
+        List<List<Integer>> actual = series.slices(5);
149 149 
         assertNotNull(actual);
150 150 
         assertFalse(actual.isEmpty());
151 151 
         assertEquals(expected, actual);