cleaned up code and added more tests

src/main/java/io/zipcoder/ItemParser.java

@@ -94,7 +94,7 @@ public class ItemParser {
         Pattern pattern = Pattern.compile("A");
         Matcher matcher = pattern.matcher(rawData);
         String lower = matcher.replaceAll("a");
-        for(int i = 0; i<upperCase.size(); i++){
+        for(int i = 1; i<upperCase.size(); i++){
             matcher.reset(lower);
             matcher.usePattern(Pattern.compile(upperCase.get(i)));
             lower = matcher.replaceAll(lowerCase.get(i));

src/main/java/io/zipcoder/ListCreation.java

@@ -6,40 +6,24 @@ import java.util.regex.Pattern;
 
 public class ListCreation {
 
-    private ListEntryPair entry;
-    private ArrayList<ListEntryPair> groceryList;
     private ItemParser parser;
 
     public ListCreation() {
-        this.entry = new ListEntryPair("", 0.00);
-        this.groceryList = new ArrayList<>();
         this.parser = new ItemParser();
     }
 
     public String rawStringToFinishedGroceryList(String raw) throws Exception {
         ArrayList<String> rawItems = parser.parseRawDataIntoStringArray(raw);
-        ArrayList<Item> itemArray = parser.stringArrayToItemArray(rawItems);
-        ArrayList<ListEntryPair> groceryListArray = createNameAndPriceList(itemArray);
-        String finish = formattedGroceryListString(groceryListArray);
-        return finish;
+        ArrayList<Item> groceryList = parser.stringArrayToItemArray(rawItems);
+        return formattedGroceryListString(groceryList);
     }
 
-    public ArrayList<ListEntryPair> createNameAndPriceList(ArrayList<Item> itemObjects) {
-        for (Item item : itemObjects) {
-            String name = item.getName();
-            Double price = item.getPrice();
-            entry = new ListEntryPair(name, price);
-            groceryList.add(entry);
-        }
-        return groceryList;
-    }
-
-    public String formattedGroceryListString(ArrayList<ListEntryPair> groceryList) {
+    public String formattedGroceryListString(ArrayList<Item> groceryList) {
         LinkedHashMap<Double,Integer> priceOccur = new LinkedHashMap<>();
         String list = "";
         for (String key : keySet(groceryList)) {
             Pattern p = Pattern.compile(key);
-            Matcher matcher = p.matcher(keyAndValueString(groceryList));
+            Matcher matcher = p.matcher(keyString(groceryList));
             int x = 0;
             while (matcher.find()) {
                 x++;
@@ -55,39 +39,35 @@ public class ListCreation {
             }
         }
         int errors = parser.getExceptionCounter();
-        if(errors == 1){
-            list += String.format("Errors              seen: %d time",errors);
-        }else {
-            list += String.format("Errors              seen: %d times",errors);
-        }
+        list += String.format("Errors              seen: %d times",errors);
         list = namesToCaps(list);
         return list;
     }
 
-    private LinkedHashSet<String> keySet(ArrayList<ListEntryPair> groceryList) {
+    public LinkedHashSet<String> keySet(ArrayList<Item> groceryList) {
         LinkedHashSet<String> keys = new LinkedHashSet<>();
-        for (ListEntryPair pair : groceryList) {
-            keys.add(pair.getName());
+        for (Item item : groceryList) {
+            keys.add(item.getName());
         }
         return keys;
     }
 
-    private String keyAndValueString(ArrayList<ListEntryPair> groceryList) {
-        String keysAndValues = "";
-        for (ListEntryPair pair : groceryList) {
-            keysAndValues += pair.pairToString();
+    public String keyString(ArrayList<Item> groceryList) {
+        String keys = "";
+        for (Item item : groceryList) {
+            keys += item.getName();
         }
-        return keysAndValues;
+        return keys;
     }
 
-    private LinkedHashMap<Double, Integer> valueCount(ArrayList<ListEntryPair> groceryList,String key) {
+    public LinkedHashMap<Double, Integer> valueCount(ArrayList<Item> groceryList,String key) {
         LinkedHashMap<Double, Integer> priceOccurrences = new LinkedHashMap<>();
-        for (ListEntryPair pair : groceryList) {
-            Double price = pair.getPrice();
-            if (key.equals(pair.getName())) {
-                if (!priceOccurrences.containsKey(pair.getPrice())) {
+        for (Item item : groceryList) {
+            Double price = item.getPrice();
+            if (key.equals(item.getName())) {
+                if (!priceOccurrences.containsKey(item.getPrice())) {
                     priceOccurrences.put(price, 1);
-                } else if (priceOccurrences.containsKey(pair.getPrice())) {
+                } else if (priceOccurrences.containsKey(item.getPrice())) {
                     priceOccurrences.replace(price, (priceOccurrences.get(price) + 1));
                 }
             }

src/main/java/io/zipcoder/ListEntryPair.java

@@ -1,25 +0,0 @@
-package io.zipcoder;
-
-public class ListEntryPair {
-
-
-    private String name;
-    private Double price;
-
-    public ListEntryPair(String name, Double price){
-        this.name = name;
-        this.price = price;
-    }
-
-    public String getName() {
-        return name;
-    }
-
-    public Double getPrice() {
-        return price;
-    }
-
-    public String pairToString(){
-        return name+price;
-    }
-}

src/test/java/io/zipcoder/ListCreationTest.java

@@ -3,7 +3,7 @@ package io.zipcoder;
 import org.junit.Assert;
 import org.junit.Test;
 
-import java.util.ArrayList;
+import java.util.*;
 
 public class ListCreationTest {
 
@@ -20,44 +20,61 @@ public class ListCreationTest {
     }
 
     @Test
-    public void testCreateGroceryList1() {
+    public void testFormattedGroceryListString(){
         //Given
         ListCreation list = new ListCreation();
-        ListEntryPair entry = new ListEntryPair("", 0.00);
         Item item1 = new Item("milk", 3.23, "food", "1/25/2016");
         Item item2 = new Item("cookies", 2.50, "food", "12/03/2018");
+        Item item3 = new Item("apples", 0.35, "food","04/23/2018");
+        Item item4 = new Item("milk", 3.23, "food", "1/25/2016");
+        Item item5 = new Item("milk", 2.00, "food", "1/25/2016");
         //When
-        ArrayList<Item> itemObjects = new ArrayList<>();
-        itemObjects.add(item1);
-        itemObjects.add(item2);
-        String expectedName = "milk";
+        ArrayList<Item> itemObjects = new ArrayList<>(Arrays.asList(item1,item2,item3,item4,item5));
         //Then
-        ArrayList<ListEntryPair> groceries = list.createNameAndPriceList(itemObjects);
-        entry = groceries.get(0);
-        String actualName = entry.getName();
-        Assert.assertEquals(expectedName, actualName);
+        String groceryList = list.formattedGroceryListString(itemObjects);
+        boolean expected = true;
+        boolean actual = groceryList.contains("Milk");
+        Assert.assertEquals(expected, actual);
     }
 
     @Test
-    public void testFormattedGroceryListString(){
-        //Given
+    public void testKeySet(){
+        ListCreation list = new ListCreation();
+        Item item1 = new Item("apples", 0.35, "food","04/23/2018");
+        Item item2 = new Item("milk", 3.23, "food", "1/25/2016");
+        Item item3 = new Item("milk", 2.00, "food", "1/25/2016");
+        ArrayList<Item> itemObjects = new ArrayList<>(Arrays.asList(item1,item2,item3));
+        LinkedHashSet<String> actual = list.keySet(itemObjects);
+        LinkedHashSet<String> expected = new LinkedHashSet<>(Arrays.asList("apples","milk"));
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void testKeyString(){
+        ListCreation list = new ListCreation();
+        Item item1 = new Item("apples", 0.35, "food","04/23/2018");
+        Item item2 = new Item("milk", 3.23, "food", "1/25/2016");
+        Item item3 = new Item("milk", 2.00, "food", "1/25/2016");
+        ArrayList<Item> itemObjects = new ArrayList<>(Arrays.asList(item1, item2,item3));
+        String expected = "applesmilkmilk";
+        String actual = list.keyString(itemObjects);
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testValueCount(){
         ListCreation list = new ListCreation();
-        ArrayList<Item> itemObjects = new ArrayList<>();
         Item item1 = new Item("milk", 3.23, "food", "1/25/2016");
         Item item2 = new Item("cookies", 2.50, "food", "12/03/2018");
         Item item3 = new Item("apples", 0.35, "food","04/23/2018");
         Item item4 = new Item("milk", 3.23, "food", "1/25/2016");
         Item item5 = new Item("milk", 2.00, "food", "1/25/2016");
-        //When
-        itemObjects.add(item1);
-        itemObjects.add(item2);
-        itemObjects.add(item3);
-        itemObjects.add(item4);
-        itemObjects.add(item5);
-        //Then
-        ArrayList<ListEntryPair> groceries = list.createNameAndPriceList(itemObjects);
-        String actual = list.formattedGroceryListString(groceries);
-        System.out.println(actual);
+        ArrayList<Item> itemObjects = new ArrayList<>(Arrays.asList(item1, item2, item3, item4, item5));
+        LinkedHashMap<Double,Integer> expected = new LinkedHashMap<>();
+        expected.put(3.23,2);
+        expected.put(2.00,1);
+        LinkedHashMap<Double,Integer> actual = list.valueCount(itemObjects, "milk");
+        Assert.assertEquals(expected, actual);
     }
 
     @Test