Merge pull request #638 from michaelspets/rename-sut

Rename sut variable [Fix #621 #622 #623 #624]

exercises/binary-search-tree/src/test/java/BSTTest.java

 
     @Test
     public void dataIsRetained() {
-        BST<Integer> sut = new BST();
+        BST<Integer> bst = new BST();
         final int actual = 4;
-        sut.insert(actual);
-        final BST.Node<Integer> root = sut.getRoot();
+        bst.insert(actual);
+        final BST.Node<Integer> root = bst.getRoot();
         assertNotNull(root);
         final int expected = root.getData();
         assertEquals(expected, actual);
     @Test
     @Ignore("Remove to run test")
     public void insertsLess() {
-        BST<Integer> sut = new BST();
+        BST<Integer> bst = new BST();
         final int expectedRoot = 4;
         final int expectedLeft = 2;
 
-        sut.insert(expectedRoot);
-        sut.insert(expectedLeft);
+        bst.insert(expectedRoot);
+        bst.insert(expectedLeft);
 
-        final BST.Node<Integer> root = sut.getRoot();
+        final BST.Node<Integer> root = bst.getRoot();
         assertNotNull(root);
         final BST.Node<Integer> left = root.getLeft();
         assertNotNull(left);
     @Test
     @Ignore("Remove to run test")
     public void insertsSame() {
-        BST<Integer> sut = new BST();
+        BST<Integer> bst = new BST();
         final int expectedRoot = 4;
         final int expectedLeft = 4;
 
-        sut.insert(expectedRoot);
-        sut.insert(expectedLeft);
+        bst.insert(expectedRoot);
+        bst.insert(expectedLeft);
 
-        final BST.Node<Integer> root = sut.getRoot();
+        final BST.Node<Integer> root = bst.getRoot();
         assertNotNull(root);
         final BST.Node<Integer> left = root.getLeft();
         assertNotNull(left);
     @Test
     @Ignore("Remove to run test")
     public void insertsRight() {
-        BST<Integer> sut = new BST();
+        BST<Integer> bst = new BST();
         final int expectedRoot = 4;
         final int expectedRight = 5;
 
-        sut.insert(expectedRoot);
-        sut.insert(expectedRight);
+        bst.insert(expectedRoot);
+        bst.insert(expectedRight);
 
-        final BST.Node<Integer> root = sut.getRoot();
+        final BST.Node<Integer> root = bst.getRoot();
         assertNotNull(root);
         final BST.Node<Integer> right = root.getRight();
         assertNotNull(right);
     @Test
     @Ignore("Remove to run test")
     public void createsComplexTree() {
-        BST<Integer> sut = new BST<>();
+        BST<Integer> bst = new BST<>();
         List<Integer> expected = Collections.unmodifiableList(
                 Arrays.asList(4, 2, 6, 1, 3, 5, 7)
         );
         List<Integer> treeData = Collections.unmodifiableList(
                 Arrays.asList(4, 2, 6, 1, 3, 7, 5)
         );
-        treeData.forEach(sut::insert);
+        treeData.forEach(bst::insert);
 
-        List<Integer> actual = sut.getAsLevelOrderList();
+        List<Integer> actual = bst.getAsLevelOrderList();
         assertEquals(expected, actual);
     }
 
     @Test
     @Ignore("Remove to run test")
     public void sortsSingleElement() {
-        BST<Integer> sut = new BST<>();
+        BST<Integer> bst = new BST<>();
         List<Integer> expected = Collections.unmodifiableList(
                 Collections.singletonList(4)
         );
 
-        sut.insert(4);
+        bst.insert(4);
 
-        List<Integer> actual = sut.getAsSortedList();
+        List<Integer> actual = bst.getAsSortedList();
         assertEquals(expected, actual);
     }
 
     @Test
     @Ignore("Remove to run test")
     public void sortsCollectionOfTwoIfSecondInsertedIsSmallerThanFirst() {
-        BST<Integer> sut = new BST<>();
+        BST<Integer> bst = new BST<>();
         List<Integer> expected = Collections.unmodifiableList(
                 Arrays.asList(2, 4)
         );
 
-        sut.insert(4);
-        sut.insert(2);
+        bst.insert(4);
+        bst.insert(2);
 
-        List<Integer> actual = sut.getAsSortedList();
+        List<Integer> actual = bst.getAsSortedList();
         assertEquals(expected, actual);
     }
 
     @Test
     @Ignore("Remove to run test")
     public void sortsCollectionOfTwoIfSecondInsertedIsBiggerThanFirst() {
-        BST<Integer> sut = new BST<>();
+        BST<Integer> bst = new BST<>();
         List<Integer> expected = Collections.unmodifiableList(
                 Arrays.asList(4, 5)
         );
 
-        sut.insert(4);
-        sut.insert(5);
+        bst.insert(4);
+        bst.insert(5);
 
-        List<Integer> actual = sut.getAsSortedList();
+        List<Integer> actual = bst.getAsSortedList();
         assertEquals(expected, actual);
     }
 
     @Test
     @Ignore("Remove to run test")
     public void iteratesOverComplexTree() {
-        BST<Integer> sut = new BST<>();
+        BST<Integer> bst = new BST<>();
         List<Integer> expected = Collections.unmodifiableList(
                 Arrays.asList(1, 2, 3, 4, 5, 6, 7)
         );
         List<Integer> treeData = Collections.unmodifiableList(
                 Arrays.asList(4, 2, 1, 3, 6, 7, 5)
         );
-        treeData.forEach(sut::insert);
+        treeData.forEach(bst::insert);
 
-        List<Integer> actual = sut.getAsSortedList();
+        List<Integer> actual = bst.getAsSortedList();
         assertEquals(expected, actual);
     }
 }

exercises/binary-search/src/test/java/BinarySearchTest.java

     public void findsAValueInAnArrayWithOneElement() {
         List<Integer> listOfUnitLength = Collections.singletonList(6);
 
-        BinarySearch<Integer> sut = new BinarySearch<>(listOfUnitLength);
+        BinarySearch<Integer> search = new BinarySearch<>(listOfUnitLength);
 
-        assertEquals(0, sut.indexOf(6));
+        assertEquals(0, search.indexOf(6));
     }
 
     @Ignore("Remove to run test")
                 Arrays.asList(1, 3, 4, 6, 8, 9, 11)
         );
 
-        BinarySearch<Integer> sut = new BinarySearch<>(sortedList);
+        BinarySearch<Integer> search = new BinarySearch<>(sortedList);
 
-        assertEquals(3, sut.indexOf(6));
+        assertEquals(3, search.indexOf(6));
     }
 
     @Ignore("Remove to run test")
                 Arrays.asList(1, 3, 4, 6, 8, 9, 11)
         );
 
-        BinarySearch<Integer> sut = new BinarySearch<>(sortedList);
+        BinarySearch<Integer> search = new BinarySearch<>(sortedList);
 
-        assertEquals(0, sut.indexOf(1));
+        assertEquals(0, search.indexOf(1));
     }
 
     @Ignore("Remove to run test")
                 Arrays.asList(1, 3, 4, 6, 8, 9, 11)
         );
 
-        BinarySearch<Integer> sut = new BinarySearch<>(sortedList);
+        BinarySearch<Integer> search = new BinarySearch<>(sortedList);
 
-        assertEquals(6, sut.indexOf(11));
+        assertEquals(6, search.indexOf(11));
     }
 
     @Ignore("Remove to run test")
                 Arrays.asList(1, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 634)
         );
 
-        BinarySearch<Integer> sut = new BinarySearch<>(sortedListOfOddLength);
+        BinarySearch<Integer> search = new BinarySearch<>(sortedListOfOddLength);
 
-        assertEquals(9, sut.indexOf(144));
+        assertEquals(9, search.indexOf(144));
     }
 
     @Ignore("Remove to run test")
                 Arrays.asList(1, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377)
         );
 
-        BinarySearch<Integer> sut = new BinarySearch<>(sortedListOfEvenLength);
+        BinarySearch<Integer> search = new BinarySearch<>(sortedListOfEvenLength);
 
-        assertEquals(5, sut.indexOf(21));
+        assertEquals(5, search.indexOf(21));
     }
 
     @Ignore("Remove to run test")
                 Arrays.asList(1, 3, 4, 6, 8, 9, 11)
         );
 
-        BinarySearch<Integer> sut = new BinarySearch<>(sortedList);
+        BinarySearch<Integer> search = new BinarySearch<>(sortedList);
 
-        assertEquals(-1, sut.indexOf(7));
+        assertEquals(-1, search.indexOf(7));
     }
 
     @Ignore("Remove to run test")
                 Arrays.asList(1, 3, 4, 6, 8, 9, 11)
         );
 
-        BinarySearch<Integer> sut = new BinarySearch<>(sortedList);
+        BinarySearch<Integer> search = new BinarySearch<>(sortedList);
 
-        assertEquals(-1, sut.indexOf(0));
+        assertEquals(-1, search.indexOf(0));
     }
 
     @Ignore("Remove to run test")
                 Arrays.asList(1, 3, 4, 6, 8, 9, 11)
         );
 
-        BinarySearch<Integer> sut = new BinarySearch<>(sortedList);
+        BinarySearch<Integer> search = new BinarySearch<>(sortedList);
 
-        assertEquals(-1, sut.indexOf(13));
+        assertEquals(-1, search.indexOf(13));
     }
 
     @Ignore("Remove to run test")
     public void nothingIsIncludedInAnEmptyArray() {
         List<Integer> emptyList = Collections.emptyList();
 
-        BinarySearch<Integer> sut = new BinarySearch<>(emptyList);
+        BinarySearch<Integer> search = new BinarySearch<>(emptyList);
 
-        assertEquals(-1, sut.indexOf(1));
+        assertEquals(-1, search.indexOf(1));
     }
 }

exercises/pythagorean-triplet/src/test/java/PythagoreanTripletTest.java

 
     @Test
     public void shouldCalculateSum() {
-        PythagoreanTriplet sut = new PythagoreanTriplet(3, 4, 5);
+        PythagoreanTriplet triplet = new PythagoreanTriplet(3, 4, 5);
         final int expected = 12;
-        final int actual = sut.calculateSum();
+        final int actual = triplet.calculateSum();
         assertEquals(expected, actual);
     }
 
     @Test
     @Ignore("Remove to run test")
     public void shouldCalculateProduct() {
-        PythagoreanTriplet sut = new PythagoreanTriplet(3, 4, 5);
+        PythagoreanTriplet triplet = new PythagoreanTriplet(3, 4, 5);
         final long expected = 60l;
-        final long actual = sut.calculateProduct();
+        final long actual = triplet.calculateProduct();
         assertEquals(expected, actual);
     }
 
     @Test
     @Ignore("Remove to run test")
     public void testIsPythagoreanOK() {
-        PythagoreanTriplet sut = new PythagoreanTriplet(3, 4, 5);
-        assertTrue(sut.isPythagorean());
+        PythagoreanTriplet triplet = new PythagoreanTriplet(3, 4, 5);
+        assertTrue(triplet.isPythagorean());
     }
 
     @Test
     @Ignore("Remove to run test")
     public void testIsPythagoreanFail() {
-        PythagoreanTriplet sut = new PythagoreanTriplet(5, 6, 7);
-        assertFalse(sut.isPythagorean());
+        PythagoreanTriplet triplet = new PythagoreanTriplet(5, 6, 7);
+        assertFalse(triplet.isPythagorean());
     }
 
     @Test

exercises/series/src/test/java/SeriesTest.java

     
     @Test
     public void hasDigitsShort() {
-        Series sut = new Series("01234");
+        Series series = new Series("01234");
         List<Integer> expected = Arrays.asList(0, 1, 2, 3, 4);
-        List<Integer> actual = sut.getDigits();
+        List<Integer> actual = series.getDigits();
         assertNotNull(actual);
         assertFalse(actual.isEmpty());
         assertEquals(expected, actual);
     @Test
     @Ignore("Remove to run test")
     public void hasDigitsLong() {
-        Series sut = new Series("0123456789");
+        Series series = new Series("0123456789");
         List<Integer> expected = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
-        List<Integer> actual = sut.getDigits();
+        List<Integer> actual = series.getDigits();
         assertNotNull(actual);
         assertFalse(actual.isEmpty());
         assertEquals(expected, actual);
     @Test
     @Ignore("Remove to run test")
     public void keepsTheDigitOrderIfReversed() {
-        Series sut = new Series("9876543210");
+        Series series = new Series("9876543210");
         List<Integer> expected = Arrays.asList(9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
-        List<Integer> actual = sut.getDigits();
+        List<Integer> actual = series.getDigits();
         assertNotNull(actual);
         assertFalse(actual.isEmpty());
         assertEquals(expected, actual);
     @Test
     @Ignore("Remove to run test")
     public void keepsArbitraryDigitOrder() {
-        Series sut = new Series("936923468");
+        Series series = new Series("936923468");
         List<Integer> expected = Arrays.asList(9, 3, 6, 9, 2, 3, 4, 6, 8);
-        List<Integer> actual = sut.getDigits();
+        List<Integer> actual = series.getDigits();
         assertNotNull(actual);
         assertFalse(actual.isEmpty());
         assertEquals(expected, actual);
     @Test
     @Ignore("Remove to run test")
     public void canSliceByOne() {
-        Series sut = new Series("01234");
+        Series series = new Series("01234");
         List<List<Integer>> expected = Arrays.asList(
                 Arrays.asList(0),
                 Arrays.asList(1),
                 Arrays.asList(3),
                 Arrays.asList(4)
         );
-        List<List<Integer>> actual = sut.slices(1);
+        List<List<Integer>> actual = series.slices(1);
         assertNotNull(actual);
         assertFalse(actual.isEmpty());
         assertEquals(expected, actual);
     @Test
     @Ignore("Remove to run test")
     public void canSliceByTwo() {
-        Series sut = new Series("98273463");
+        Series series = new Series("98273463");
         List<List<Integer>> expected = Arrays.asList(
                 Arrays.asList(9, 8),
                 Arrays.asList(8, 2),
                 Arrays.asList(4, 6),
                 Arrays.asList(6, 3)
         );
-        List<List<Integer>> actual = sut.slices(2);
+        List<List<Integer>> actual = series.slices(2);
         assertNotNull(actual);
         assertFalse(actual.isEmpty());
         assertEquals(expected, actual);
     @Test
     @Ignore("Remove to run test")
     public void canSliceByThree() {
-        Series sut = new Series("01234");
+        Series series = new Series("01234");
         List<List<Integer>> expected = Arrays.asList(
                 Arrays.asList(0, 1, 2),
                 Arrays.asList(1, 2, 3),
                 Arrays.asList(2, 3, 4)
         );
-        List<List<Integer>> actual = sut.slices(3);
+        List<List<Integer>> actual = series.slices(3);
         assertNotNull(actual);
         assertFalse(actual.isEmpty());
         assertEquals(expected, actual);
     @Test
     @Ignore("Remove to run test")
     public void canSliceByThreeWithDuplicateDigits() {
-        Series sut = new Series("31001");
+        Series series = new Series("31001");
         List<List<Integer>> expected = Arrays.asList(
                 Arrays.asList(3, 1, 0),
                 Arrays.asList(1, 0, 0),
                 Arrays.asList(0, 0, 1)
         );
-        List<List<Integer>> actual = sut.slices(3);
+        List<List<Integer>> actual = series.slices(3);
         assertNotNull(actual);
         assertFalse(actual.isEmpty());
         assertEquals(expected, actual);
     @Test
     @Ignore("Remove to run test")
     public void canSliceByFour() {
-        Series sut = new Series("91274");
+        Series series = new Series("91274");
         List<List<Integer>> expected = Arrays.asList(
                 Arrays.asList(9, 1, 2, 7),
                 Arrays.asList(1, 2, 7, 4)
         );
-        List<List<Integer>> actual = sut.slices(4);
+        List<List<Integer>> actual = series.slices(4);
         assertNotNull(actual);
         assertFalse(actual.isEmpty());
         assertEquals(expected, actual);
     @Test
     @Ignore("Remove to run test")
     public void canSliceByFive() {
-        Series sut = new Series("81228");
+        Series series = new Series("81228");
         List<List<Integer>> expected = Arrays.asList(
                 Arrays.asList(8, 1, 2, 2, 8)
         );
-        List<List<Integer>> actual = sut.slices(5);
+        List<List<Integer>> actual = series.slices(5);
         assertNotNull(actual);
         assertFalse(actual.isEmpty());
         assertEquals(expected, actual);