Renamed classes and added @Before method to test class

changed variable name and made it private

exercises/binary-search-tree/.meta/src/reference/java/BST.java → exercises/binary-search-tree/.meta/src/reference/java/BinarySearchTree.java

 import java.util.List;
 import java.util.Queue;
 
-public class BST<T extends Comparable<T>> {
+public class BinarySearchTree<T extends Comparable<T>> {
 
     public static class Node<T> {
 

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

 import static org.junit.Assert.assertNotNull;
 import org.junit.Ignore;
 import org.junit.Test;
+import org.junit.Before;
 
-public class BSTTest {
+public class BinarySearchTreeTest {
+    private BinarySearchTree<Integer> binarySearchTree;
+
+    @Before
+    public void setUp() {
+        binarySearchTree = new BinarySearchTree<>();
+    }
 
     @Test
     public void dataIsRetained() {
-        BST<Integer> bst = new BST<>();
         final int actual = 4;
-        bst.insert(actual);
-        final BST.Node<Integer> root = bst.getRoot();
+        binarySearchTree.insert(actual);
+        final BinarySearchTree.Node<Integer> root = binarySearchTree.getRoot();
         assertNotNull(root);
         final int expected = root.getData();
         assertEquals(expected, actual);
     @Ignore("Remove to run test")
     @Test
     public void insertsLess() {
-        BST<Integer> bst = new BST<>();
         final int expectedRoot = 4;
         final int expectedLeft = 2;
 
-        bst.insert(expectedRoot);
-        bst.insert(expectedLeft);
+        binarySearchTree.insert(expectedRoot);
+        binarySearchTree.insert(expectedLeft);
 
-        final BST.Node<Integer> root = bst.getRoot();
+        final BinarySearchTree.Node<Integer> root = binarySearchTree.getRoot();
         assertNotNull(root);
-        final BST.Node<Integer> left = root.getLeft();
+        final BinarySearchTree.Node<Integer> left = root.getLeft();
         assertNotNull(left);
 
         final int actualRoot = root.getData();
     @Ignore("Remove to run test")
     @Test
     public void insertsSame() {
-        BST<Integer> bst = new BST<>();
         final int expectedRoot = 4;
         final int expectedLeft = 4;
 
-        bst.insert(expectedRoot);
-        bst.insert(expectedLeft);
+        binarySearchTree.insert(expectedRoot);
+        binarySearchTree.insert(expectedLeft);
 
-        final BST.Node<Integer> root = bst.getRoot();
+        final BinarySearchTree.Node<Integer> root = binarySearchTree.getRoot();
         assertNotNull(root);
-        final BST.Node<Integer> left = root.getLeft();
+        final BinarySearchTree.Node<Integer> left = root.getLeft();
         assertNotNull(left);
 
         final int actualRoot = root.getData();
     @Ignore("Remove to run test")
     @Test
     public void insertsRight() {
-        BST<Integer> bst = new BST<>();
         final int expectedRoot = 4;
         final int expectedRight = 5;
 
-        bst.insert(expectedRoot);
-        bst.insert(expectedRight);
+        binarySearchTree.insert(expectedRoot);
+        binarySearchTree.insert(expectedRight);
 
-        final BST.Node<Integer> root = bst.getRoot();
+        final BinarySearchTree.Node<Integer> root = binarySearchTree.getRoot();
         assertNotNull(root);
-        final BST.Node<Integer> right = root.getRight();
+        final BinarySearchTree.Node<Integer> right = root.getRight();
         assertNotNull(right);
 
         final int actualRoot = root.getData();
     @Ignore("Remove to run test")
     @Test
     public void createsComplexTree() {
-        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(bst::insert);
+        treeData.forEach(binarySearchTree::insert);
 
-        List<Integer> actual = bst.getAsLevelOrderList();
+        List<Integer> actual = binarySearchTree.getAsLevelOrderList();
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void sortsSingleElement() {
-        BST<Integer> bst = new BST<>();
         List<Integer> expected = Collections.unmodifiableList(
                 Collections.singletonList(4)
         );
 
-        bst.insert(4);
+        binarySearchTree.insert(4);
 
-        List<Integer> actual = bst.getAsSortedList();
+        List<Integer> actual = binarySearchTree.getAsSortedList();
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void sortsCollectionOfTwoIfSecondInsertedIsSmallerThanFirst() {
-        BST<Integer> bst = new BST<>();
         List<Integer> expected = Collections.unmodifiableList(
                 Arrays.asList(2, 4)
         );
 
-        bst.insert(4);
-        bst.insert(2);
+        binarySearchTree.insert(4);
+        binarySearchTree.insert(2);
 
-        List<Integer> actual = bst.getAsSortedList();
+        List<Integer> actual = binarySearchTree.getAsSortedList();
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void sortsCollectionOfTwoIfSecondInsertedIsBiggerThanFirst() {
-        BST<Integer> bst = new BST<>();
         List<Integer> expected = Collections.unmodifiableList(
                 Arrays.asList(4, 5)
         );
 
-        bst.insert(4);
-        bst.insert(5);
+        binarySearchTree.insert(4);
+        binarySearchTree.insert(5);
 
-        List<Integer> actual = bst.getAsSortedList();
+        List<Integer> actual = binarySearchTree.getAsSortedList();
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void iteratesOverComplexTree() {
-        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(bst::insert);
+        treeData.forEach(binarySearchTree::insert);
 
-        List<Integer> actual = bst.getAsSortedList();
+        List<Integer> actual = binarySearchTree.getAsSortedList();
         assertEquals(expected, actual);
     }
 }