binary-search-tree: use generics

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

 import org.junit.Before;
 
 public class BinarySearchTreeTest {
-    private BinarySearchTree<Integer> binarySearchTree;
-
-    @Before
-    public void setUp() {
-        binarySearchTree = new BinarySearchTree<>();
-    }
 
     @Test
     public void dataIsRetained() {
-        final int actual = 4;
-        binarySearchTree.insert(actual);
+        BinarySearchTree<Integer> binarySearchTree = new BinarySearchTree<>();
+
+        final int expected = 4;
+        binarySearchTree.insert(expected);
+
         final BinarySearchTree.Node<Integer> root = binarySearchTree.getRoot();
         assertNotNull(root);
-        final int expected = root.getData();
+
+        final int actual = root.getData();
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void insertsLess() {
-        final int expectedRoot = 4;
-        final int expectedLeft = 2;
+        BinarySearchTree<Character> binarySearchTree = new BinarySearchTree<>();
+        final char expectedRoot = '4';
+        final char expectedLeft = '2';
 
         binarySearchTree.insert(expectedRoot);
         binarySearchTree.insert(expectedLeft);
 
-        final BinarySearchTree.Node<Integer> root = binarySearchTree.getRoot();
+        final BinarySearchTree.Node<Character> root = binarySearchTree.getRoot();
         assertNotNull(root);
-        final BinarySearchTree.Node<Integer> left = root.getLeft();
+        final BinarySearchTree.Node<Character> left = root.getLeft();
         assertNotNull(left);
 
-        final int actualRoot = root.getData();
-        final int actualLeft = left.getData();
+        final char actualRoot = root.getData();
+        final char actualLeft = left.getData();
         assertEquals(expectedLeft, actualLeft);
         assertEquals(expectedRoot, actualRoot);
     }
     @Ignore("Remove to run test")
     @Test
     public void insertsSame() {
-        final int expectedRoot = 4;
-        final int expectedLeft = 4;
+        BinarySearchTree<String> binarySearchTree = new BinarySearchTree<>();
+        final String expectedRoot = "4";
+        final String expectedLeft = "4";
 
         binarySearchTree.insert(expectedRoot);
         binarySearchTree.insert(expectedLeft);
 
-        final BinarySearchTree.Node<Integer> root = binarySearchTree.getRoot();
+        final BinarySearchTree.Node<String> root = binarySearchTree.getRoot();
         assertNotNull(root);
-        final BinarySearchTree.Node<Integer> left = root.getLeft();
+        final BinarySearchTree.Node<String> left = root.getLeft();
         assertNotNull(left);
 
-        final int actualRoot = root.getData();
-        final int actualLeft = left.getData();
+        final String actualRoot = root.getData();
+        final String actualLeft = left.getData();
         assertEquals(expectedLeft, actualLeft);
         assertEquals(expectedRoot, actualRoot);
     }
     @Ignore("Remove to run test")
     @Test
     public void insertsRight() {
+        BinarySearchTree<Integer> binarySearchTree = new BinarySearchTree<>();
         final int expectedRoot = 4;
         final int expectedRight = 5;
 
     @Ignore("Remove to run test")
     @Test
     public void createsComplexTree() {
+        BinarySearchTree<Integer> binarySearchTree = new BinarySearchTree<>();
         List<Integer> expected = Collections.unmodifiableList(
                 Arrays.asList(4, 2, 6, 1, 3, 5, 7)
         );
     @Ignore("Remove to run test")
     @Test
     public void sortsSingleElement() {
-        List<Integer> expected = Collections.unmodifiableList(
-                Collections.singletonList(4)
+        BinarySearchTree<Character> binarySearchTree = new BinarySearchTree<>();
+        List<Character> expected = Collections.unmodifiableList(
+                Collections.singletonList('4')
         );
 
-        binarySearchTree.insert(4);
+        binarySearchTree.insert('4');
 
-        List<Integer> actual = binarySearchTree.getAsSortedList();
+        List<Character> actual = binarySearchTree.getAsSortedList();
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void sortsCollectionOfTwoIfSecondInsertedIsSmallerThanFirst() {
-        List<Integer> expected = Collections.unmodifiableList(
-                Arrays.asList(2, 4)
+        BinarySearchTree<String> binarySearchTree = new BinarySearchTree<>();
+        List<String> expected = Collections.unmodifiableList(
+                Arrays.asList("2", "4")
         );
 
-        binarySearchTree.insert(4);
-        binarySearchTree.insert(2);
+        binarySearchTree.insert("4");
+        binarySearchTree.insert("2");
 
-        List<Integer> actual = binarySearchTree.getAsSortedList();
+        List<String> actual = binarySearchTree.getAsSortedList();
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void sortsCollectionOfTwoIfSecondInsertedIsBiggerThanFirst() {
+        BinarySearchTree<Integer> binarySearchTree = new BinarySearchTree<>();
         List<Integer> expected = Collections.unmodifiableList(
                 Arrays.asList(4, 5)
         );
     @Ignore("Remove to run test")
     @Test
     public void iteratesOverComplexTree() {
+        BinarySearchTree<Integer> binarySearchTree = new BinarySearchTree<>();
         List<Integer> expected = Collections.unmodifiableList(
                 Arrays.asList(1, 2, 3, 4, 5, 6, 7)
         );