Everything extending Stack works, combiner stubs

src/main/java/ArrayListCombiner/ArrayListCombiner.java

@@ -9,4 +9,9 @@ import java.util.ArrayList;
  * The second method should be called superCombiner and should use ? super E
  */
 public class ArrayListCombiner {
+    public static <E> void superCombiner(ArrayList<? super E> parent, ArrayList<E> child) {
+    }
+
+    public static <E> void extendCombiner(ArrayList<E> parent, ArrayList<? extends E> child) {
+    }
 }

src/main/java/Pair/Arrays.java

@@ -1,7 +1,6 @@
 package Pair;
 
 import java.util.ArrayList;
-import java.util.Collections;
 
 /**
  * In here you must make firstLast, which will return a pair of the first element in the array list and the last
@@ -11,7 +10,22 @@ import java.util.Collections;
  * And a minmax method that returns a pair containing the largest and smallest items from the array list
  */
 public class Arrays {
-    public static <E> Pair<E> firstLast(ArrayList<?> a) {
+    public static <E> Pair<E> firstLast(ArrayList<E> a) {
+        E first = a.get(0);
+        E second = a.get(a.size() - 1);
+
+        return new Pair<>(first, second);
+    }
+
+    public <E> E max(ArrayList<E> a) {
+        return null;
+    }
+
+    public <E> E min(ArrayList<E> a) {
+        return null;
+    }
+
+    public <E> Pair<E> minmax(ArrayList<E> a) {
         return null;
     }
 }

src/main/java/Pair/Pair.java

@@ -8,5 +8,27 @@ package Pair;
  * max -> returns the maximum of the pair
  */
 public class Pair<E> {
+    private E first;
+    private E second;
 
+    public Pair(E first, E second) {
+        this.first = first;
+        this.second = second;
+    }
+
+    public E getFirst() {
+        return first;
+    }
+
+    public E getSecond() {
+        return second;
+    }
+
+    public E min() {
+        return null;
+    }
+
+    public E max() {
+        return null;
+    }
 }

src/main/java/StackArray/ObjectStack.java

@@ -11,7 +11,5 @@ import StackArrayList.Stack;
 public class ObjectStack<E> extends Stack<E> {
     private Object[] elements;
 
-    public ObjectStack() {
-
-    }
+    public ObjectStack() {}
 }

src/test/java/ArrayListCombiner/ArrayListCombinerTest.java

@@ -2,47 +2,47 @@ package ArrayListCombiner;
 
 import Employee.Employee;
 import Employee.Manager;
-import org.junit.Test;
-
 import org.junit.Assert;
+import org.junit.Test;
 
 import java.util.ArrayList;
 
 public class ArrayListCombinerTest {
-//    Employee foo = new Employee("FOO", 100);
-//    Manager bar = new Manager("BAR", 100);
-//    @Test
-//    public void testExtendCombiner() throws Exception {
-//        // Given an array list with employees
-//        ArrayList<Employee> first = new ArrayList<>();
-//        first.add(foo);
-//        // An an array list with managers
-//        ArrayList<Manager> second = new ArrayList<>();
-//        second.add(bar);
-//        // When  I combine them
-//        ArrayListCombiner.extendCombiner(first, second);
-//        // Then I should get an arrayList with both
-//        ArrayList<Employee> expected = new ArrayList<>();
-//        expected.add(foo);
-//        expected.add(bar);
-//        Assert.assertEquals(expected, first);
-//    }
-//
-//    @Test
-//    public void testSuperCombiner() throws Exception {
-//        // Given an array list with employees
-//        ArrayList<Employee> first = new ArrayList<>();
-//        first.add(foo);
-//        // An an array list with managers
-//        ArrayList<Manager> second = new ArrayList<>();
-//        second.add(bar);
-//        // When  I combine them
-//        ArrayListCombiner.superCombiner(first, second);
-//        // Then I should get an arrayList with both
-//        ArrayList<Employee> expected = new ArrayList<>();
-//        expected.add(foo);
-//        expected.add(bar);
-//        Assert.assertEquals(expected, first);
-//    }
+    Employee foo = new Employee("FOO", 100);
+    Manager bar = new Manager("BAR", 100);
+
+    @Test
+    public void testExtendCombiner() throws Exception {
+        // Given an array list with employees
+        ArrayList<Employee> first = new ArrayList<>();
+        first.add(foo);
+        // An an array list with managers
+        ArrayList<Manager> second = new ArrayList<>();
+        second.add(bar);
+        // When  I combine them
+        ArrayListCombiner.extendCombiner(first, second);
+        // Then I should get an arrayList with both
+        ArrayList<Employee> expected = new ArrayList<>();
+        expected.add(foo);
+        expected.add(bar);
+        Assert.assertEquals(expected, first);
+    }
+
+    @Test
+    public void testSuperCombiner() throws Exception {
+        // Given an array list with employees
+        ArrayList<Employee> first = new ArrayList<>();
+        first.add(foo);
+        // An an array list with managers
+        ArrayList<Manager> second = new ArrayList<>();
+        second.add(bar);
+        // When  I combine them
+        ArrayListCombiner.superCombiner(first, second);
+        // Then I should get an arrayList with both
+        ArrayList<Employee> expected = new ArrayList<>();
+        expected.add(foo);
+        expected.add(bar);
+        Assert.assertEquals(expected, first);
+    }
 
 }