src/main/java/ArrayListCombiner/ArrayListCombiner.java

@@ -9,4 +9,14 @@ import java.util.ArrayList;
  * The second method should be called superCombiner and should use ? super E
  */
 public class ArrayListCombiner {
+    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

@@ -1,5 +1,6 @@
 package MapFunc;
 
+import javax.xml.bind.Element;
 import java.util.ArrayList;
 import java.util.function.Function;
 
@@ -7,6 +8,25 @@ import java.util.function.Function;
  * Create a function called `map` that takes an ArrayList and a `Function<T,R>` object,
  * and returns an ArrayList with all of the elements of the first after the function is applied to them.
  */
-public class MapFunc {
+public  class MapFunc {
+
+    public  static<T,R> ArrayList map(ArrayList<T> intList, Function<T, R> MapDemo)//Array list then arrayList name;fUNCTION then function nmae
+    {
+        ArrayList<T> resultArrayList = new ArrayList<T>(); //cREATING NEW aRRAYLIST
+
+        for(T e : intList)   //Traversing through arrayList and applying each element to function
+        {
+           resultArrayList.add((T) MapDemo.apply(e)); // aPPLYING function MapDemo to 1st element in the list(i.e MapDemo.apply(e)).Then adding that to resultArrayList(i.e resultArrayList.add)    
+        }
+
+
+return resultArrayList;
+
+    }
+
+
+
+
+
 
 }

src/main/java/Pair/Arrays.java

@@ -10,7 +10,7 @@ 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 <___> Pair<E> firstLast(ArrayList<___> a) {
+    }*/
+

src/main/java/StackArray/GenericStack.java

@@ -1,6 +1,8 @@
 package StackArray;
 
+import java.lang.reflect.Array;
 import java.util.Arrays;
+import java.util.EmptyStackException;
 
 /**
  * Expand the ArrayList implementation of stack here to use an E[] array.  Still implement push, pop, and isEmpty.
@@ -8,8 +10,88 @@ import java.util.Arrays;
  * @param <E>
  */
 public class GenericStack<E> {
-    private E[] elements;
 
-    public GenericStack() {
+    private E[] inputArray;
+
+
+    private int numOfElements;
+
+
+    public GenericStack(int size) {   //Even if array length is 8, numOfElements  can be 0 ie,it can have 0 or any num:of elements
+        this.numOfElements = 0;
+        inputArray = (E[])new Object[size];
+//        inputArray = (E[]) Array.newInstance(inputArray.getClass().getComponentType(), size);
+        //inputArray = (E[]) new Object[size];
+    }
+
+    public void push(E I) {
+        if(inputArray.length >= numOfElements)
+        {
+            inputArray[numOfElements] =  I;
+            System.out.println(inputArray[numOfElements]);
+            numOfElements++;
+
+        }
+        else {
+
+            E[] inputArray1 = Arrays.copyOf(inputArray, inputArray.length + 1);
+
+            //int index = inputArray.length;
+
+            inputArray1[inputArray.length] = I;
+            numOfElements++;
+            inputArray = inputArray1;
+        }
+
+    }
+
+    public boolean isEmpty() {
+        if(numOfElements == 0)
+        {
+            return true;
+        }
+        else
+        {
+            return  false;
+        }
+
+
     }
+
+
+
+    /*private boolean isFull() {
+        if (index == size) {
+            return true;
+        } else {
+            return false;
+        }
+    }*/
+
+
+    public E pop()
+    {
+        E popedVar;
+        if(numOfElements == 0)
+        {
+           throw new IndexOutOfBoundsException();
+        }
+        else
+        {
+
+          popedVar= inputArray[numOfElements-1];
+            //E[] inputArray1 = Arrays.copyOf(inputArray, inputArray.length -1);
+
+           // inputArray = inputArray1;
+            numOfElements--;
+
+        }
+
+        return  popedVar;
+
+
+    }
+
+
+
 }

src/main/java/StackArray/ObjectStack.java

@@ -10,7 +10,26 @@ import java.util.Arrays;
 public class ObjectStack<E> {
     private Object[] elements;
 
+    GenericStack gs ;
+
     public ObjectStack() {
+        gs = new GenericStack(9); //cannot declare anything in constructor,then scope will be inside constructor.
+
+    }
+    public boolean isEmpty()
+    {
+        return gs.isEmpty();
+    }
 
+    public void push(E i)
+    {
+         gs.push(i);
     }
+
+    public E pop()
+    {
+       return (E) gs.pop();
+    }
+
+
 }

src/main/java/StackArrayList/Stack.java

@@ -7,10 +7,42 @@ import java.util.ArrayList;
  * If you pop on an empty stack, throw an IndexOutOfBoundsException.
  */
 public class Stack<E> {
-    private ArrayList elements;
 
+    //private ArrayList elements;
 
-    public Stack(){
+    private ArrayList<E> myStack;
 
+
+    public Stack() {
+        myStack = new ArrayList<E>();
+    }
+
+   /* public Stack(int Size){
+        Stack = new ArrayList<Integer>(Size);
+
+    }*/
+    public void push(E i)
+    {
+        myStack.add(i);
+    }
+
+    public E pop()
+    {
+        if(!myStack.isEmpty()) {
+            E i= myStack.get(myStack.size()-1);
+            myStack.remove(myStack.size()-1);
+            return i;
+        } else{
+            throw new ArrayIndexOutOfBoundsException();
+        }
+    }
+
+    public boolean isEmpty()
+    {
+        if(myStack.size() == 0)
+        {
+            return true;
+        }
+        return false;
     }
 }

src/main/java/Swap/Swap.java

@@ -4,10 +4,14 @@ package Swap;
  * Keep this.  Just make it so the tests pass.
  */
 public class Swap {
-    public static <T> T[] swap(int i, int j, T... values) {
+    public static <T> T[] swap(int i, int j, double v, int i1, int i2, T... values) {
         T temp = values[i];
         values[i] = values[j];
         values[j] = temp;
         return values;
     }
+
+    public static Double[] swap(int i, int j, double v, double v1, double v2) {
+        return null;
+    }
 }

src/main/java/Table/Entry.java

@@ -17,4 +17,6 @@ public class Entry<K, V> {
         return value;
     }
 
+    public <V> void setValue(V v) {
+    }
 }

src/main/java/Table/Table.java

@@ -10,8 +10,42 @@ import java.util.ArrayList;
  * Void return on `remove`.
  */
 public class Table<K, V> {
-    private ArrayList entries;
+    private ArrayList<Entry> entries;
 
     public Table() {
+        this.entries = new ArrayList<>();
     }
+
+    public V get(K k){
+        V value = null;
+        for(Entry e: entries){
+            if(e.getKey().equals(k)){
+                value = (V)e.getValue();
+            }
+        }
+        return value;
+    }
+
+    public void put(K k, V v){
+        Entry newEntry = new Entry(k,v);
+        if(entries.contains(newEntry.getKey())) {
+            for (Entry e : entries) {
+                if (e.getKey().equals(k)) {
+                    e.setValue(v);
+                }
+            }
+        } else entries.add(newEntry);
+    }
+
+    public void remove(K k){
+        int removeIndex = -1;
+        for (Entry e: entries) {
+            if(k.equals(e.getKey())){
+                removeIndex = entries.indexOf(e);
+            }
+        }
+        entries.remove(removeIndex);
+    }
+
 }
+

src/test/java/ArrayListCombiner/ArrayListCombinerTest.java

@@ -9,40 +9,40 @@ 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/StackArray/GenericStackTest.java

@@ -1,41 +1,43 @@
-//package StackArray;
-//
-//import org.junit.Assert;
-//import org.junit.Test;
-//
-//public class GenericStackTest {
-//    @Test
-//    public void testPushingGrowsTheStack() throws Exception {
-//        // Given an empty stack
-//        GenericStack<String> stack = new GenericStack<>();
-//
-//        // Assert that it is empty.
-//        Assert.assertEquals(true, stack.isEmpty());
-//        // When we push something onto the stack
-//        stack.push("foobar");
-//        // Then it shouldn't be empty
-//        Assert.assertEquals(false, stack.isEmpty());
-//    }
-//
-//    @Test
-//    public void testPushingAndPoppingOrder() throws Exception {
-//        // Given an empty stack
-//        GenericStack<String> stack = new GenericStack<>();
-//        // When we push two elements on it
-//        stack.push("foo");
-//        stack.push("bar");
-//        // Then we should see them returned in the correct order
-//        Assert.assertEquals("bar", stack.pop());
-//        Assert.assertEquals("foo", stack.pop());
-//    }
-//
-//    @Test(expected = IndexOutOfBoundsException.class)
-//    public void testPopFirst() throws Exception {
-//        // Given an empty stack
-//        GenericStack<String> stack = new GenericStack<>();
-//        // When it's popped
-//        stack.pop();
-//        // Then we should get an exception
-//    }
-//
-//}
+package StackArray;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+public class GenericStackTest {
+    @Test
+    public void testPushingGrowsTheStack() throws Exception {
+        // Given an empty stack
+        GenericStack<String> stack = new GenericStack<>(8);
+
+        // Assert that it is empty.
+        Assert.assertEquals(true, stack.isEmpty());
+        // When we push something onto the stack
+        stack.push("foobar");
+        // Then it shouldn't be empty
+        Assert.assertEquals(false, stack.isEmpty());
+    }
+
+    @Test
+    public void testPushingAndPoppingOrder() throws Exception {
+        // Given an empty stack
+        GenericStack<String> stack = new GenericStack<>(6);
+        // When we push two elements on it
+        stack.push("foo");
+        stack.push("bar");
+        // Then we should see them returned in the correct order
+        Assert.assertEquals("bar", stack.pop());
+        Assert.assertEquals("foo", stack.pop());
+    }
+
+    @Test(expected = IndexOutOfBoundsException.class)
+    public void testPopFirst() throws Exception {
+        // Given an empty stack
+        GenericStack<String> stack = new GenericStack<>(9);
+        // When it's popped
+        stack.pop();
+        // Then we should get an exception
+    }
+
+}

src/test/java/StackArray/ObjectStackTest.java

@@ -1,39 +1,39 @@
-//package StackArray;
-//
-//import org.junit.Assert;
-//import org.junit.Test;
-//
-//public class ObjectStackTest {
-//    @Test
-//    public void testPushingGrowsTheStack() throws Exception {
-//        // Given an empty stack
-//        ObjectStack<String> stack = new ObjectStack<>();
-//        // Assert that it is empty.
-//        Assert.assertEquals(true, stack.isEmpty());
-//        // When we push something onto the stack
-//        stack.push("foobar");
-//        // Then it shouldn't be empty
-//        Assert.assertEquals(false, stack.isEmpty());
-//    }
-//
-//    @Test
-//    public void testPushingAndPoppingOrder() throws Exception {
-//        // Given an empty stack
-//        ObjectStack<String> stack = new ObjectStack<>();
-//        // When we push two elements on it
-//        stack.push("foo");
-//        stack.push("bar");
-//        // Then we should see them returned in the correct order
-//        Assert.assertEquals("bar", stack.pop());
-//        Assert.assertEquals("foo", stack.pop());
-//    }
-//
-//    @Test(expected = IndexOutOfBoundsException.class)
-//    public void testPopFirst() throws Exception {
-//        // Given an empty stack
-//        ObjectStack<String> stack = new ObjectStack<>();
-//        // When it's popped
-//        stack.pop();
-//        // Then we should get an exception
-//    }
-//}
+package StackArray;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class ObjectStackTest {
+    @Test
+    public void testPushingGrowsTheStack() throws Exception {
+        // Given an empty stack
+        ObjectStack<String> stack = new ObjectStack<>();
+        // Assert that it is empty.
+        Assert.assertEquals(true, stack.isEmpty());
+        // When we push something onto the stack
+        stack.push("foobar");
+        // Then it shouldn't be empty
+        Assert.assertEquals(false, stack.isEmpty());
+    }
+
+    @Test
+    public void testPushingAndPoppingOrder() throws Exception {
+        // Given an empty stack
+        ObjectStack<String> stack = new ObjectStack<>();
+        // When we push two elements on it
+        stack.push("foo");
+        stack.push("bar");
+        // Then we should see them returned in the correct order
+        Assert.assertEquals("bar", stack.pop());
+        Assert.assertEquals("foo", stack.pop());
+    }
+
+    @Test(expected = IndexOutOfBoundsException.class)
+    public void testPopFirst() throws Exception {
+        // Given an empty stack
+        ObjectStack<String> stack = new ObjectStack<>();
+        // When it's popped
+        stack.pop();
+        // Then we should get an exception
+    }
+}

src/test/java/StackArrayList/StackTest.java

@@ -1,45 +1,45 @@
-//package StackArrayList;
-//
-//import org.junit.Test;
-//
-//import org.junit.Assert;
-//
-//public class StackTest {
-//    @Test
-//    public void testEmptyStackStopsBeingEmptyWhenAnItemIsAdded() throws Exception {
-//        // Given an empty stack
-//        Stack<String> stack = new Stack<>();
-//        // Assert that it starts empty
-//        Assert.assertEquals(true, stack.isEmpty());
-//        // When an element gets pushed
-//        stack.push("foobar");
-//        // Then the stack should not be empty.
-//        Assert.assertEquals(false, stack.isEmpty());
-//    }
-//
-//    @Test
-//    public void testTwoItemsPushedComeOutInCorrectOrder() throws Exception {
-//        // Given an empty stack
-//        Stack<String> stack = new Stack<>();
-//
-//        //When two items are pushed
-//        stack.push("foo");
-//        stack.push("bar");
-//
-//        // Then they should come off in reverse order.
-//        Assert.assertEquals("bar", stack.pop());
-//        Assert.assertEquals("foo", stack.pop());
-//
-//        // And then the stack should be empty
-//        Assert.assertEquals(true, stack.isEmpty());
-//    }
-//
-//    @Test(expected = IndexOutOfBoundsException.class)
-//    public void testPopFirst() throws Exception {
-//        // Given an empty stack
-//        Stack<String> stack = new Stack<>();
-//        // Then it is popped
-//        stack.pop();
-//        // We should get an exception
-//    }
-//}
+package StackArrayList;
+
+import org.junit.Test;
+
+import org.junit.Assert;
+
+public class StackTest {
+    @Test
+    public void testEmptyStackStopsBeingEmptyWhenAnItemIsAdded() throws Exception {
+        // Given an empty stack
+        Stack<String> stack = new Stack<>();
+        // Assert that it starts empty
+        Assert.assertEquals(true, stack.isEmpty());
+        // When an element gets pushed
+        stack.push("foobar");
+        // Then the stack should not be empty.
+        Assert.assertEquals(false, stack.isEmpty());
+    }
+
+    @Test
+    public void testTwoItemsPushedComeOutInCorrectOrder() throws Exception {
+        // Given an empty stack
+        Stack<String> stack = new Stack<>();
+
+        //When two items are pushed
+        stack.push("foo");
+        stack.push("bar");
+
+        // Then they should come off in reverse order.
+        Assert.assertEquals("bar", stack.pop());
+        Assert.assertEquals("foo", stack.pop());
+
+        // And then the stack should be empty
+        Assert.assertEquals(true, stack.isEmpty());
+    }
+
+    @Test(expected = IndexOutOfBoundsException.class)
+    public void testPopFirst() throws Exception {
+        // Given an empty stack
+        Stack<String> stack = new Stack<>();
+        // Then it is popped
+        stack.pop();
+        // We should get an exception
+    }
+}

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, 1.5, 2.0,3.0);
+        Double[] expected = {2.0, 1.5, 3.0};
+        Assert.assertArrayEquals(expected, result);
+    }
+}

src/test/java/Table/TableTest.java

@@ -1,50 +1,50 @@
-//package Table;
-//
-//import org.junit.Assert;
-//import org.junit.Test;
-//
-//public class TableTest {
-//    @Test
-//    public void testGetWithoutAnItemReturnsNull() throws Exception {
-//        // Given an empty table
-//        Table<String, Integer> table = new Table<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
-//        Table<String, Integer> table = new Table<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
-//        Table<String, Integer> table = new Table<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
-//        Table<String, Integer> table = new Table<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 Table;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TableTest {
+    @Test
+    public void testGetWithoutAnItemReturnsNull() throws Exception {
+        // Given an empty table
+        Table<String, Integer> table = new Table<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
+        Table<String, Integer> table = new Table<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
+        Table<String, Integer> table = new Table<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
+        Table<String, Integer> table = new Table<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);
+    }
+}