Lab completed.

src/main/java/ArrayListCombiner/ArrayListCombiner.java

@@ -1,5 +1,7 @@
 package ArrayListCombiner;
 
+import Employee.Employee;
+
 import java.util.ArrayList;
 
 /**
@@ -8,5 +10,14 @@ import java.util.ArrayList;
  * The first method should be called extendCombiner and should use ? extends E
  * The second method should be called superCombiner and should use ? super E
  */
-public class ArrayListCombiner {
+public class ArrayListCombiner<E> {
+
+    public static <E> void extendCombiner(ArrayList<E> first, ArrayList< ? extends E> second) {
+        first.addAll(second);
+
+    }
+
+    public static <E> void superCombiner(ArrayList< ? super E> first, ArrayList<E> second) {
+        first.addAll(second);
+    }
 }

src/main/java/MapFunc/MapFunc.java

@@ -9,4 +9,11 @@ import java.util.function.Function;
  */
 public class MapFunc {
 
+    public static <T,R> ArrayList map(ArrayList<T> arrayList, Function<T,R> function) {
+        ArrayList<T> newArrayList = new ArrayList<T>();
+            for(int i =0; i< arrayList.size(); i++) {
+                newArrayList.add((T) function.apply(arrayList.get(i)));
+            }
+            return newArrayList;
+    }
 }

src/main/java/Pair/Arrays.java

@@ -10,7 +10,20 @@ import java.util.Collections;
  * A max method that returns the largest item in the arraylist
  * And a minmax method that returns a pair containing the largest and smallest items from the array list
  */
-//public class Arrays {
-//    public static <___> Pair<E> firstLast(ArrayList<___> a) {
-//    }
-//}
+public class Arrays {
+    public static <E extends Comparable> Pair<E> firstLast(ArrayList<E> a) {
+        return new Pair(a.get(0),a.get(a.size()-1));
+    }
+
+    public static <E extends Comparable> Comparable min(ArrayList<E> al) {
+        return Collections.min(al);
+    }
+
+    public static <E extends Comparable> Comparable max(ArrayList<E> al) {
+        return Collections.max(al);
+    }
+
+    public static <E extends Comparable> Pair minMax(ArrayList<E> al) {
+        return new Pair(min(al),max(al));
+    }
+}

src/main/java/Pair/Pair.java

@@ -7,6 +7,37 @@ package Pair;
  * min -> returns the minimum of the pair
  * max -> returns the maximum of the pair
  */
-public class Pair {
+public class Pair <E extends Comparable>  {
 
-}
+   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() {
+        if(first.compareTo(second) < 0) {
+            return first;
+        } else {
+            return second;
+        }
+    }
+
+    public E max() {
+        if(first.compareTo(second) > 0) {
+            return first;
+        } else {
+            return second;
+        }
+    }
+}

src/main/java/TableNested/TableNested.java

@@ -1,5 +1,7 @@
 package TableNested;
 
+import Table.Entry;
+
 import java.util.ArrayList;
 
 /**
@@ -8,4 +10,71 @@ import java.util.ArrayList;
  */
 public class TableNested<K, V> {
 
+    private ArrayList<Entry> entries;
+
+    public TableNested() {
+        entries = new ArrayList<Entry>();
+    }
+
+    public V get(K key) {
+        for (int i = 0; i < entries.size(); i++) {
+            if (entries.get(i).getKey().equals(key)) {
+                return (V) entries.get(i).getValue();
+            }
+        }
+        return null;
+    }
+
+    public boolean containsKey(K key) {
+        for (int i = 0; i < entries.size(); i++) {
+            if (entries.get(i).getKey().equals(key)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public void put(K key, V value) {
+        if (containsKey(key)) {
+            for (int i = 0; i < entries.size(); i++) {
+                if (entries.get(i).getKey().equals(key)) {
+                    entries.remove(i);
+                    entries.add(i, new Entry(key, value));
+                }
+            }
+        } else {
+            entries.add(new Entry(key, value));
+        }
+    }
+
+    public void remove(K key) {
+        if (containsKey(key)) {
+            for (int i = 0; i < entries.size(); i++) {
+                if (entries.get(i).getKey().equals(key)) {
+                    entries.remove(i);
+                }
+            }
+        }
+    }
+
+     class Entry<K, V> {
+        private K key;
+        private V value;
+
+        public Entry(K key, V value) {
+            this.key = key;
+            this.value = value;
+        }
+
+        public K getKey() {
+            return key;
+        }
+
+        public V getValue() {
+            return value;
+        }
+
+    }
+
+
 }

src/test/java/ArrayListCombiner/ArrayListCombinerTest.java

@@ -9,40 +9,39 @@ import org.junit.Assert;
 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);
+    }
 }

src/test/java/MapFunc/MapFuncTest.java

@@ -1,36 +1,36 @@
-//package MapFunc;
-//
-//import MapFunc.MapFunc;
-//import org.junit.Test;
-//
-//import java.util.ArrayList;
-//import org.junit.Assert;
-//
-//public class MapFuncTest {
-//    @Test
-//    public void testSingleTypeMap() throws Exception {
-//        // Given an integer array list
-//        ArrayList<Integer> intList = new ArrayList<>();
-//        intList.add(1);
-//        intList.add(2);
-//        // When it's mapped with a function to double the value
-//        ArrayList<Integer> mappedList = MapFunc.map(intList, num -> num*2);
-//        // Then all the values are doubled
-//        Assert.assertEquals(new Integer(2), mappedList.get(0));
-//        Assert.assertEquals(new Integer(4), mappedList.get(1));
-//    }
-//
-//    @Test
-//    public void testMultipleTypeMap() throws Exception {
-//        // Given an integer array list
-//        ArrayList<Integer> intList = new ArrayList<>();
-//        intList.add(1);
-//        intList.add(2);
-//        // When it's mapped with to string
-//        ArrayList<String> mappedList = MapFunc.map(intList, num -> num.toString());
-//        // Then all the values are doubled
-//        Assert.assertEquals("1", mappedList.get(0));
-//        Assert.assertEquals("2", mappedList.get(1));
-//    }
-//
-//}
+package MapFunc;
+
+import MapFunc.MapFunc;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import org.junit.Assert;
+
+public class MapFuncTest {
+    @Test
+    public void testSingleTypeMap() throws Exception {
+        // Given an integer array list
+        ArrayList<Integer> intList = new ArrayList<>();
+        intList.add(1);
+        intList.add(2);
+        // When it's mapped with a function to double the value
+        ArrayList<Integer> mappedList = MapFunc.map(intList, num -> num*2);
+        // Then all the values are doubled
+        Assert.assertEquals(new Integer(2), mappedList.get(0));
+        Assert.assertEquals(new Integer(4), mappedList.get(1));
+    }
+
+    @Test
+    public void testMultipleTypeMap() throws Exception {
+        // Given an integer array list
+        ArrayList<Integer> intList = new ArrayList<>();
+        intList.add(1);
+        intList.add(2);
+        // When it's mapped with to string
+        ArrayList<String> mappedList = MapFunc.map(intList, num -> num.toString());
+        // Then all the values are doubled
+        Assert.assertEquals("1", mappedList.get(0));
+        Assert.assertEquals("2", mappedList.get(1));
+    }
+
+}

src/test/java/Pair/ArraysTest.java

@@ -1,74 +1,74 @@
-//package Pair;
-//
-//import org.junit.Assert;
-//import org.junit.Test;
-//
-//import java.util.ArrayList;
-//
-//public class ArraysTest {
-//    @Test
-//    public void firstLast() throws Exception {
-//        // Given an ArrayList of Integers
-//        ArrayList<Integer> al = new ArrayList<>();
-//        al.add(1);
-//        al.add(5);
-//        al.add(3);
-//        al.add(4);
-//        al.add(2);
-//        al.add(0);
-//        al.add(1000);
-//        // When firstLast is called
-//        Pair<Integer> result = Arrays.firstLast(al);
-//        // Then it should return the first and last items
-//        Assert.assertEquals(new Integer(1), result.getFirst());
-//        Assert.assertEquals(new Integer(1000), result.getSecond());
-//    }
-//
-//    @Test
-//    public void testMin() throws Exception {
-//        // Given an ArrayList of Integers
-//        ArrayList<Integer> al = new ArrayList<>();
-//        al.add(1);
-//        al.add(5);
-//        al.add(3);
-//        al.add(4);
-//        al.add(2);
-//        al.add(0);
-//        al.add(1000);
-//        // When min is called assert that it gets the smallest item
-//        Assert.assertEquals(new Integer(0), Arrays.min(al));
-//    }
-//
-//    @Test
-//    public void testMax() throws Exception {
-//        // Given an ArrayList of Integers
-//        ArrayList<Integer> al = new ArrayList<>();
-//        al.add(1);
-//        al.add(5);
-//        al.add(3);
-//        al.add(4);
-//        al.add(2);
-//        al.add(0);
-//        al.add(1000);
-//        // When min is called assert that it gets the largest item
-//        Assert.assertEquals(new Integer(1000), Arrays.max(al));
-//    }
-//
-//    @Test
-//    public void testMinMax() throws Exception {
-//        // Given an ArrayList of Integers
-//        ArrayList<Integer> al = new ArrayList<>();
-//        al.add(1);
-//        al.add(5);
-//        al.add(3);
-//        al.add(4);
-//        al.add(2);
-//        al.add(0);
-//        al.add(1000);
-//        // When minMax is called
-//        Pair<Integer> result = Arrays.minMax(al);
-//        // Then it should return the first and last items
-//        Assert.assertEquals(new Integer(0), result.min());
-//        Assert.assertEquals(new Integer(1000), result.max());
-//    }
-//}
+package Pair;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+public class ArraysTest {
+    @Test
+    public void firstLast() throws Exception {
+        // Given an ArrayList of Integers
+        ArrayList<Integer> al = new ArrayList<>();
+        al.add(1);
+        al.add(5);
+        al.add(3);
+        al.add(4);
+        al.add(2);
+        al.add(0);
+        al.add(1000);
+        // When firstLast is called
+        Pair<Integer> result = Arrays.firstLast(al);
+        // Then it should return the first and last items
+        Assert.assertEquals(new Integer(1), result.getFirst());
+        Assert.assertEquals(new Integer(1000), result.getSecond());
+    }
+
+    @Test
+    public void testMin() throws Exception {
+        // Given an ArrayList of Integers
+        ArrayList<Integer> al = new ArrayList<>();
+        al.add(1);
+        al.add(5);
+        al.add(3);
+        al.add(4);
+        al.add(2);
+        al.add(0);
+        al.add(1000);
+        // When min is called assert that it gets the smallest item
+        Assert.assertEquals(new Integer(0), Arrays.min(al));
+    }
+
+    @Test
+    public void testMax() throws Exception {
+        // Given an ArrayList of Integers
+        ArrayList<Integer> al = new ArrayList<>();
+        al.add(1);
+        al.add(5);
+        al.add(3);
+        al.add(4);
+        al.add(2);
+        al.add(0);
+        al.add(1000);
+        // When min is called assert that it gets the largest item
+        Assert.assertEquals(new Integer(1000), Arrays.max(al));
+    }
+
+    @Test
+    public void testMinMax() throws Exception {
+        // Given an ArrayList of Integers
+        ArrayList<Integer> al = new ArrayList<>();
+        al.add(1);
+        al.add(5);
+        al.add(3);
+        al.add(4);
+        al.add(2);
+        al.add(0);
+        al.add(1000);
+        // When minMax is called
+        Pair<Integer> result = Arrays.minMax(al);
+        // Then it should return the first and last items
+        Assert.assertEquals(new Integer(0), result.min());
+        Assert.assertEquals(new Integer(1000), result.max());
+    }
+}

src/test/java/Pair/PairTest.java

@@ -1,32 +1,32 @@
-//package Pair;
-//
-//import org.junit.Test;
-//import org.junit.Assert;
-//
-//public class PairTest {
-//
-//    @Test
-//    public void testGetters() throws Exception {
-//        // Given a pair with "Foo" and "Bar"
-//        Pair<String> p = new Pair<String>("Foo", "Bar");
-//        // When getFirst and getSecond are called, they should be returned.
-//        Assert.assertEquals("Foo", p.getFirst());
-//        Assert.assertEquals("Bar",  p.getSecond());
-//    }
-//
-//    @Test
-//    public void testMin() throws Exception {
-//        // Given a pair with two values
-//        Pair<Double> p = new Pair<Double>(1.23, 2.34);
-//        // When p.min() is called, the smallest should be returned.
-//        Assert.assertEquals(new Double(1.23), p.min());
-//    }
-//
-//    @Test
-//    public void testMax() throws Exception {
-//        // Given a pair with two values
-//        Pair<Double> p = new Pair<Double>(1.23, 2.34);
-//        // When p.max() is called, the largest should be returned.
-//        Assert.assertEquals(new Double(2.34), p.max());
-//    }
-//}
+package Pair;
+
+import org.junit.Test;
+import org.junit.Assert;
+
+public class PairTest {
+
+    @Test
+    public void testGetters() throws Exception {
+        // Given a pair with "Foo" and "Bar"
+        Pair<String> p = new Pair<String>("Foo", "Bar");
+        // When getFirst and getSecond are called, they should be returned.
+        Assert.assertEquals("Foo", p.getFirst());
+        Assert.assertEquals("Bar",  p.getSecond());
+    }
+
+    @Test
+    public void testMin() throws Exception {
+        // Given a pair with two values
+        Pair<Double> p = new Pair<Double>(1.23, 2.34);
+        // When p.min() is called, the smallest should be returned.
+        Assert.assertEquals(new Double(1.23), p.min());
+    }
+
+    @Test
+    public void testMax() throws Exception {
+        // Given a pair with two values
+        Pair<Double> p = new Pair<Double>(1.23, 2.34);
+        // When p.max() is called, the largest should be returned.
+        Assert.assertEquals(new Double(2.34), p.max());
+    }
+}

src/test/java/Swap/SwapTest.java

@@ -1,16 +1,16 @@
 package Swap;
-//
-//import org.junit.Assert;
-//import org.junit.Test;
-//
-///**
-// * Get the tests passing.
-// */
-//public class SwapTest {
-//    @Test
-//    public void testSwap() throws Exception {
-//        Double[] result = Swap.swap(0,1, 1.5, 2,3);
-//        Double[] expected = {2.0, 1.5, 3.0};
-//        Assert.assertArrayEquals(expected, result);
-//    }
-//}
+
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * Get the tests passing.
+ */
+public class SwapTest {
+    @Test
+    public void testSwap() throws Exception {
+        Double[] result = Swap.swap(0,1, 2.0, 1.5, 3.0);
+        Double[] expected = {1.5, 2.0, 3.0};
+        Assert.assertArrayEquals(expected, result);
+    }
+}

src/test/java/TableNested/TableNestedTest.java

@@ -1,50 +1,50 @@
-//package TableNested;
-//
-//import org.junit.Assert;
-//import org.junit.Test;
-//
-//public class TableNestedTest {
-//    @Test
-//    public void testGetWithoutAnItemReturnsNull() throws Exception {
-//        // Given an empty table
-//        TableNested<String, Integer> table = new TableNested<String, Integer>();
-//        // When we try and get an item then it returns null
-//        Assert.assertEquals(table.get("foo"), null);
-//    }
-//
-//    @Test
-//    public void testPutAnItemReturnsAndDoesNotDelete() throws Exception {
-//        //Given an empty table
-//        TableNested<String, Integer> table = new TableNested<String, Integer>();
-//        // When we put an item in it
-//        table.put("foo", 1);
-//        // Then we should be able to get it's value
-//        Assert.assertEquals(table.get("foo"), new Integer(1));
-//        // And then we should be able to get it again as it wasn't removed
-//        Assert.assertEquals(table.get("foo"), new Integer(1));
-//    }
-//
-//    @Test
-//    public void testOverwritingAnItem() throws Exception {
-//        //Given an empty table
-//        TableNested<String, Integer> table = new TableNested<String, Integer>();
-//        // When we put an item in it
-//        table.put("foo", 1);
-//        // And we put a new value with the same key
-//        table.put("foo", 2);
-//        // Then we should get back the new value
-//        Assert.assertEquals(table.get("foo"), new Integer(2));
-//    }
-//
-//    @Test
-//    public void testRemoveAnItem() throws Exception {
-//        //Given an empty table
-//        TableNested<String, Integer> table = new TableNested<String, Integer>();
-//        // When we put an item in it
-//        table.put("foo", 1);
-//        // And we remove that item
-//        table.remove("foo");
-//        // Then we should get back null for that balue
-//        Assert.assertEquals(table.get("foo"), null);
-//    }
-//}
+package TableNested;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TableNestedTest {
+    @Test
+    public void testGetWithoutAnItemReturnsNull() throws Exception {
+        // Given an empty table
+        TableNested<String, Integer> table = new TableNested<String, Integer>();
+        // When we try and get an item then it returns null
+        Assert.assertEquals(table.get("foo"), null);
+    }
+
+    @Test
+    public void testPutAnItemReturnsAndDoesNotDelete() throws Exception {
+        //Given an empty table
+        TableNested<String, Integer> table = new TableNested<String, Integer>();
+        // When we put an item in it
+        table.put("foo", 1);
+        // Then we should be able to get it's value
+        Assert.assertEquals(table.get("foo"), new Integer(1));
+        // And then we should be able to get it again as it wasn't removed
+        Assert.assertEquals(table.get("foo"), new Integer(1));
+    }
+
+    @Test
+    public void testOverwritingAnItem() throws Exception {
+        //Given an empty table
+        TableNested<String, Integer> table = new TableNested<String, Integer>();
+        // When we put an item in it
+        table.put("foo", 1);
+        // And we put a new value with the same key
+        table.put("foo", 2);
+        // Then we should get back the new value
+        Assert.assertEquals(table.get("foo"), new Integer(2));
+    }
+
+    @Test
+    public void testRemoveAnItem() throws Exception {
+        //Given an empty table
+        TableNested<String, Integer> table = new TableNested<String, Integer>();
+        // When we put an item in it
+        table.put("foo", 1);
+        // And we remove that item
+        table.remove("foo");
+        // Then we should get back null for that balue
+        Assert.assertEquals(table.get("foo"), null);
+    }
+}