From e76170124104647b4162d0562eb097fb445c0900 Mon Sep 17 00:00:00 2001
From: Hayden Bader <hpb3@duke.edu>
Date: Thu, 7 Apr 2016 17:31:10 -0400
Subject: [PATCH] pushing junit tests

---
 src/debug/ContainerArray.java     | 20 +++++--
 src/debug/ContainerArrayTest.java | 43 +++++++++++++--
 src/tdd/Sheet.java                | 45 ++++++++++++++++
 src/tdd/TestSheet.java            | 87 +++++++++++++++++++++++++++++++
 4 files changed, 188 insertions(+), 7 deletions(-)
 create mode 100644 src/tdd/Sheet.java
 create mode 100644 src/tdd/TestSheet.java

diff --git a/src/debug/ContainerArray.java b/src/debug/ContainerArray.java
index 124ece6..dab88ac 100755
--- a/src/debug/ContainerArray.java
+++ b/src/debug/ContainerArray.java
@@ -2,16 +2,16 @@
 
 
 public class ContainerArray<E> {
-    private int initialCapacity = 10;
+    private static int limit = 10;
     private int currentSize = 0;
     private Object[] internalArray;
 
     public ContainerArray () {
-        this(10);
+        this(limit);
     }
 
-    public ContainerArray (int initialCapacity) {
-        internalArray = new Object[initialCapacity];
+    public ContainerArray (int limit) {
+        internalArray = new Object[limit];
     }
 
     public void add (E element) {
@@ -23,6 +23,18 @@ public int size () {
     }
 
     public void remove (E objectToRemove) {
+        //remove removes the first element in the list
+    	// and then collapse all other elements down the list
+    	boolean collapse = false;
+        for(int i=0; i<currentSize; i++){
+        	if(internalArray[i].equals(objectToRemove)){
+        		internalArray[i] = null;
+        		collapse = true;
+        	}
+        	if(collapse && i < internalArray.length-1){
+        		internalArray[i] = internalArray[i+1];
+        	}
+        }
         currentSize--;
     }
 
diff --git a/src/debug/ContainerArrayTest.java b/src/debug/ContainerArrayTest.java
index c566d50..27113dd 100755
--- a/src/debug/ContainerArrayTest.java
+++ b/src/debug/ContainerArrayTest.java
@@ -38,10 +38,47 @@ public void testSizeChangeWithRemove () {
 
     @Test
     public void testObjectIsRemoved () {
-        String alligator = "Alligator";
         myContainer.add("Alligator");
         myContainer.add("Bear");
-        myContainer.remove("Bear");
-        assertEquals("Remove should be same reference", alligator, myContainer.get(0));
+        myContainer.remove("Alligator");
+        assertEquals("Remove should be same reference", "Bear", myContainer.get(0));
+        
+    }
+    
+    @Test
+    public void testSizeLimit(){
+    	for(int i = 0; i < 10; i++){
+    		myContainer.add("a");
+    	}
+    	myContainer.remove("a");
+    	myContainer.add("a");
+    	assert(myContainer.size() < 10);
+    }
+    
+    @Test
+    public void testAddAfterRemovePlacement(){
+        myContainer.add("Alligator");
+        myContainer.add("Bear");
+        myContainer.remove("Alligator");
+        myContainer.add("Dog");
+        assertEquals("Dog", myContainer.get(1));
+    }
+    
+    @Test
+    public void testDoubleAddAndRemove(){
+    	String Alligator = "Alligator";
+    	myContainer.add("Alligator");
+       	myContainer.add("Alligator");
+       	myContainer.add("Alligator");
+       	myContainer.add("Alligator");
+       	myContainer.remove(Alligator);
+       	assert(myContainer.size() == 3);
+       	assertEquals(myContainer.get(0), Alligator);
+       	
+    }
+    
+    @Test(expected=IndexOutOfBoundsException.class)
+    public void testOutOfBounds(){
+    	myContainer.get(10);
     }
 }
diff --git a/src/tdd/Sheet.java b/src/tdd/Sheet.java
new file mode 100644
index 0000000..ec48cea
--- /dev/null
+++ b/src/tdd/Sheet.java
@@ -0,0 +1,45 @@
+package tdd;
+
+import java.util.HashMap;
+import java.util.Map;
+
+
+
+public class Sheet {
+	
+	private Map<String, String> mySheet = new HashMap();
+	
+	public String get(String string){
+		
+		if(mySheet.get(string) == null){
+			return "";
+		}
+		
+		String tempString = mySheet.get(string).replace(" ", "");
+		
+		boolean numeric = true;
+		if(tempString.isEmpty()){
+			return mySheet.get(string);
+		}
+		for(char c: tempString.toCharArray()){
+			if(!Character.isDigit(c)){
+				numeric = false;
+			}
+		}
+		if(numeric){
+			return tempString;
+		}
+		return mySheet.get(string);
+		
+		
+	}
+	
+	public void put(String cellName, String cellContents){
+		
+		mySheet.put(cellName, cellContents);
+	}
+	
+	public String getLiteral(String cellName){
+		return mySheet.get(cellName);
+	}
+}
diff --git a/src/tdd/TestSheet.java b/src/tdd/TestSheet.java
new file mode 100644
index 0000000..5d5c10f
--- /dev/null
+++ b/src/tdd/TestSheet.java
@@ -0,0 +1,87 @@
+package tdd;
+
+import static org.junit.Assert.*;
+import org.junit.Test;
+
+public class TestSheet {
+
+	@Test
+	public void testThatCellsAreEmptyByDefault(){
+		Sheet sheet = new Sheet();
+		assertEquals("", sheet.get("A1"));
+		assertEquals("", sheet.get("ZX34?"));
+	}
+
+	@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));
+	}
+}