diff --git a/.classpath b/.classpath
new file mode 100644
index 0000000..3e0fb27
--- /dev/null
+++ b/.classpath
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/src/debug/ContainerArray.java b/src/debug/ContainerArray.java
index 124ece6..0ba62ac 100755
--- a/src/debug/ContainerArray.java
+++ b/src/debug/ContainerArray.java
@@ -1,33 +1,46 @@
 package debug;
 
+import java.util.ArrayList;
+import java.util.List;
 
 public class ContainerArray<E> {
-    private int initialCapacity = 10;
-    private int currentSize = 0;
-    private Object[] internalArray;
+    private int limit;
+    private List<Object> internalList;
+    private static final int DEFAULT_LIMIT = 10;
 
     public ContainerArray () {
-        this(10);
+        this(DEFAULT_LIMIT);
     }
 
     public ContainerArray (int initialCapacity) {
-        internalArray = new Object[initialCapacity];
+    	limit = initialCapacity;
+        internalList = new ArrayList<Object>();
     }
 
     public void add (E element) {
-        internalArray[currentSize++] = element;
+    	if(internalList.size()<limit){
+    		internalList.add(element);
+    	}
     }
 
     public int size () {
-        return currentSize;
+        return internalList.size();
     }
 
     public void remove (E objectToRemove) {
-        currentSize--;
+    	internalList.remove(objectToRemove);
+    }
+    
+    public void removeAll(E objectToRemove) {
+    	for (int i = 0; i < internalList.size(); i++){
+    		if (internalList.get(i).equals(objectToRemove)){
+    			internalList.remove(i);
+    		}
+    	}
     }
 
     @SuppressWarnings("unchecked")
     public E get (int index) {
-        return (E)internalArray[index];
+        return (E) internalList.get(index);
     }
 }
diff --git a/src/debug/ContainerArrayTest.java b/src/debug/ContainerArrayTest.java
index c566d50..c7d7e3f 100755
--- a/src/debug/ContainerArrayTest.java
+++ b/src/debug/ContainerArrayTest.java
@@ -12,7 +12,15 @@ public class ContainerArrayTest {
     public void setUp () {
         myContainer = new ContainerArray<>();
     }
-
+    //Added test:
+    @Test
+    public void checkLimitNotOverReached(){
+        myContainer = new ContainerArray<>(1);
+        myContainer.add("Alligator");
+        myContainer.add("Bear");
+        myContainer.add("Camel");
+        assertEquals("Add size", 1, myContainer.size());
+    }
     @Test
     public void testSizeChangeWithAdd () {
         myContainer.add("Alligator");
@@ -44,4 +52,15 @@ public void testObjectIsRemoved () {
         myContainer.remove("Bear");
         assertEquals("Remove should be same reference", alligator, myContainer.get(0));
     }
+    
+    @Test
+    public void testRemoveAllObject () {
+    	String alligator = "Alligator";
+    	myContainer.add("Bear");
+    	myContainer.add("Alligator");
+    	myContainer.add("Bear");
+    	myContainer.removeAll("Bear");
+    	 assertEquals("Remove should be same reference", alligator, myContainer.get(0));
+    	
+    }
 }
diff --git a/src/tdd/Sheet.java b/src/tdd/Sheet.java
new file mode 100644
index 0000000..534e3a9
--- /dev/null
+++ b/src/tdd/Sheet.java
@@ -0,0 +1,43 @@
+package tdd;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Sheet {
+	private Map<String,String> myCellArray;
+	private Map<String,String> myLiteralCellArray;
+
+	public Sheet(){
+		myCellArray = new HashMap<String,String>();
+		myLiteralCellArray = new HashMap<String,String>();
+	}
+	public String get(String s) {
+		if( myCellArray.containsKey(s)){return myCellArray.get(s);}
+		return "";
+	}
+
+	public void put(String theCell, String string) {
+		myLiteralCellArray.put(theCell,string);
+		String temp = string;
+		temp = temp.replaceAll(" ", "");
+
+		System.out.println(temp);
+		if(isNumeric(temp)){string = temp;}
+		myCellArray.put(theCell, string);
+	}
+	
+	private static boolean isNumeric(String str)
+	{
+		try{
+			int num = Integer.parseInt(str);
+			return true;
+		}
+		catch(NumberFormatException e){
+			return false;
+		}
+	}
+	public Object getLiteral(String theCell) {
+		return myLiteralCellArray.get(theCell);
+	}
+
+}
diff --git a/src/tdd/Tester1.java b/src/tdd/Tester1.java
new file mode 100644
index 0000000..277efce
--- /dev/null
+++ b/src/tdd/Tester1.java
@@ -0,0 +1,85 @@
+package tdd;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+public class Tester1 {
+	@Test
+	public void test() {
+		Sheet sheet = new Sheet();
+		assertEquals("", sheet.get("A1"));
+		assertEquals("", sheet.get("ZX347"));
+	}
+	
+	// Implement each test before going to the next one.
+	@Test
+	public void testThatTextCellsAreStored() {
+	  Sheet sheet = new Sheet();
+	  String theCell = "A21";
+
+	  sheet.put(theCell, "A string");
+	  assertEquals("A string", sheet.get(theCell));
+
+	  sheet.put(theCell, "A different string");
+	  assertEquals("A different string", sheet.get(theCell));
+
+	  sheet.put(theCell, "");
+	  assertEquals("", sheet.get(theCell));
+	}
+	
+	// Implement each test before going to the next one; then refactor.
+	@Test
+	public void testThatManyCellsExist() {
+	  Sheet sheet = new Sheet();
+	  sheet.put("A1", "First");
+	  sheet.put("X27", "Second");
+	  sheet.put("ZX901", "Third");
+
+	  assertEquals("A1", "First", sheet.get("A1"));
+	  assertEquals("X27", "Second", sheet.get("X27"));
+	  assertEquals("ZX901", "Third", sheet.get("ZX901"));
+
+	  sheet.put("A1", "Fourth");
+	  assertEquals("A1 after", "Fourth", sheet.get("A1"));
+	  assertEquals("X27 same", "Second", sheet.get("X27"));
+	  assertEquals("ZX901 same", "Third", sheet.get("ZX901"));
+	}
+	// Implement each test before going to the next one.
+	// You can split this test case if it helps.
+	@Test
+	public void testThatNumericCellsAreIdentifiedAndStored() {
+	  Sheet sheet = new Sheet();
+	  String theCell = "A21";
+
+	  sheet.put(theCell, "X99"); // "Obvious" string
+	  assertEquals("X99", sheet.get(theCell));
+
+	  sheet.put(theCell, "14"); // "Obvious" number
+	  assertEquals("14", sheet.get(theCell));
+
+	  sheet.put(theCell, " 99 X"); // Whole string must be numeric
+	  assertEquals(" 99 X", sheet.get(theCell));
+
+	  sheet.put(theCell, " 1234 "); // Blanks ignored
+	  assertEquals("1234", sheet.get(theCell));
+
+	  sheet.put(theCell, " "); // Just a blank
+	  assertEquals(" ", sheet.get(theCell));
+	}
+	// Refactor before going to each succeeding test.
+	@Test
+	public void testThatWeHaveAccessToCellLiteralValuesForEditing() { 
+	  Sheet sheet = new Sheet();
+	  String theCell = "A21";
+
+	  sheet.put(theCell, "Some string"); 
+	  assertEquals("Some string", sheet.getLiteral(theCell));
+
+	  sheet.put(theCell, " 1234 "); 
+	  assertEquals(" 1234 ", sheet.getLiteral(theCell));
+
+	  sheet.put(theCell, "=7"); // Foreshadowing formulas:)
+	  assertEquals("=7", sheet.getLiteral(theCell));
+	}
+}