Merge 5231662b77850a6940ea554c2d50f0ad8e39b7ab into 23c2c01bf07b924ac9b860fa2771bf6ceb246ad5

pom.xml

@@ -7,6 +7,18 @@
     <groupId>io.zipcoder</groupId>
     <artifactId>PainfullAfternoon</artifactId>
     <version>1.0-SNAPSHOT</version>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>1.7</source>
+                    <target>1.7</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
 
     <dependencies>
         <dependency>

src/main/java/io/zipcoder/Item.java

@@ -45,4 +45,10 @@ public class Item {
     public String toString(){
         return "name:" + name + " price:" + price + " type:" + type + " expiration:" + expiration;
     }
+
+    public static void main(String[] args) {
+        Item item = new Item("milk", 3.23, "food", "1/25/2016");
+        String itemAsString = item.toString();
+        System.out.println(itemAsString);
+    }
 }

src/main/java/io/zipcoder/ItemParseException.java

@@ -1,4 +1,58 @@
 package io.zipcoder;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Logger;
+
 public class ItemParseException extends Exception {
+
+    private int errorCount;
+    private List<String> errors;
+    private static final Logger logger = Logger.getGlobal();
+
+    public ItemParseException() {
+        this.errorCount = 0;
+        errors = new ArrayList<>();
+    }
+
+    public ItemParseException(String emptyFieldName) {
+        logger.info("This field name is empty: " + "\"" + emptyFieldName + "\"");
+    }
+
+    public void logErrorCount(String emptyFieldName, String rawItem) {
+        errors.add("Field " + "\"" + emptyFieldName + "\"" + " is empty in " + rawItem);
+        errorCount++;
+    }
+
+    public int getErrorCount() {
+        return errorCount;
+    }
+
+    public List<String> getErrors() {
+        return errors;
+    }
+
+    public String errorCountAsString() {
+        String s = String.format("%-13s", "Errors");
+        StringBuilder sb = new StringBuilder();
+        sb.append(s);
+        sb.append("\t\t" + "seen: " + errorCount + " times");
+        return sb.toString();
+    }
+
+    public String errorsAsString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("Error count: " + errorCount + "\n");
+        sb.append("Errors:\n");
+
+        int errorNumber = 1;
+        for (String error : errors) {
+            sb.append("Error " + errorNumber + ": " + error + "\n");
+            errorNumber++;
+        }
+        sb.deleteCharAt(sb.length() - 1);
+
+        return sb.toString();
+    }
+
 }

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

@@ -1,31 +1,247 @@
 package io.zipcoder;
 
-import java.util.ArrayList;
-import java.util.Arrays;
+import apple.laf.JRSUIUtils;
+
+import java.rmi.activation.ActivationGroup_Stub;
+import java.util.*;
+import java.util.regex.Pattern;
+import java.util.regex.Matcher;
+import java.util.Map.Entry;
 
 public class ItemParser {
 
+    private ItemParseException ipe;
+    private List<String> itemStrings;
+    private List<Item> items;
+    private TreeMap<String, ArrayList<Item>> itemOrganizer;
+
+    public ItemParser() {
+        this.ipe = new ItemParseException();
+        this.itemStrings = new ArrayList<>();
+        this.items = new ArrayList<>();
+        this.itemOrganizer = new TreeMap<>();
+    }
+
+    public ItemParseException getIpe() {
+        return ipe;
+    }
 
-    public ArrayList<String> parseRawDataIntoStringArray(String rawData){
+    public ArrayList<String> parseRawDataIntoItemStringArray(String rawData){
         String stringPattern = "##";
-        ArrayList<String> response = splitStringWithRegexPattern(stringPattern , rawData);
+        ArrayList<String> response = splitStringWithRegexPattern(rawData, stringPattern);
+        itemStrings = response;
         return response;
     }
 
-    public Item parseStringIntoItem(String rawItem) throws ItemParseException{
-        return null;
+    public List<String> getItemStrings() {
+        return itemStrings;
+    }
+
+    public void createItems() throws ItemParseException {
+        for (String itemString : itemStrings) {
+            Item item = parseStringIntoItem(itemString);
+            items.add(item);
+        }
+    }
+
+    public List<Item> getItems() {
+        return items;
+    }
+
+    public String itemsAsString() {
+        StringBuilder sb = new StringBuilder();
+        int count = 1;
+        for (Item item : items) {
+            sb.append(count + " " + item.toString() + "\n");
+            count++;
+        }
+        sb.deleteCharAt(sb.length() - 1);
+        return sb.toString();
+    }
+
+    public ArrayList<Item> getItemsOfSameName(String name) {
+        ArrayList<Item> itemsOfSameName = new ArrayList<>();
+        for (Item item : items) {
+            if (item.getName().equals(name)) {
+                itemsOfSameName.add(item);
+            }
+        }
+        return itemsOfSameName;
+    }
+
+    public void addNameAndItemsOfSameNameToItemOrganizer() {
+        for (Item item : items) {
+            String itemName = item.getName();
+            if (itemOrganizer.get(itemName) == null) {
+                itemOrganizer.put(itemName, getItemsOfSameName(itemName));
+            }
+        }
+    }
+
+    public TreeMap<String, ArrayList<Item>> getItemOrganizer() {
+        return itemOrganizer;
+    }
+
+    public String itemOrganizerAsString() {
+        StringBuilder sb = new StringBuilder();
+        for (Entry entry : itemOrganizer.entrySet()) {
+            sb.append("name: " + entry.getKey() + " " + "nameCount: " + itemOrganizer.get(entry.getKey()).size() + "\n"
+            + entry.getValue() + "\n");
+        }
+        sb.deleteCharAt(sb.length() - 1);
+        return sb.toString();
+    }
+
+    public String itemNameAndCountAsString(String name) {
+        String timeOrTimes = "times";
+        StringBuilder sb = new StringBuilder();
+        for (String keyName : itemOrganizer.keySet()) {
+            if (itemOrganizer.get(keyName).size() == 1) {
+                timeOrTimes = "time";
+            }
+            if (keyName.equals(name)) {
+                int numberOfEmptyPriceFields = countNumberOfEmptyPriceFields(name);
+                int actualCount = itemOrganizer.get(name).size() - numberOfEmptyPriceFields;
+                String s = String.format("%-5s%8s", "name:", capitalizeFirstLetterOnly(name));
+                sb.append(s);
+                sb.append("\t\tseen: " + actualCount + " " + timeOrTimes);
+            }
+        }
+        return sb.toString();
+    }
+
+    public int countNumberOfEmptyPriceFields(String name) {
+        int count = 0;
+        for (String keyName : itemOrganizer.keySet()) {
+            if (keyName.equals(name)) {
+                for (Item item : itemOrganizer.get(keyName)) {
+                    if (item.getPrice() == 0) {
+                        count++;
+                    }
+                }
+            }
+        }
+        return count;
+    }
+
+    public String capitalizeFirstLetterOnly(String word) {
+        StringBuilder sb = new StringBuilder();
+        String firstLetterOfWord = word.substring(0,1);
+        sb.append(firstLetterOfWord.toUpperCase() + word.substring(1, word.length()));
+        return sb.toString();
+    }
+
+    public Map<Double, Integer> getPricesAndTheirCount(String name) {
+        Map<Double, Integer> pricesAndTheirCount = new TreeMap<>(Collections.reverseOrder());
+        for (String nameKey : itemOrganizer.keySet()) {
+            if (nameKey.equals(name)) {
+                for (int i = 0; i < itemOrganizer.get(nameKey).size(); i++) {
+                    double price = itemOrganizer.get(nameKey).get(i).getPrice();
+                    if (pricesAndTheirCount.get(price) == null) {
+                        pricesAndTheirCount.put(price, 1);
+                    } else {
+                        pricesAndTheirCount.put(price, pricesAndTheirCount.get(price) + 1);
+                    }
+                }
+            }
+        }
+        return pricesAndTheirCount;
+    }
+
+    public String pricesAndTheirCountAsString(Map<Double, Integer> pricesAndTheirCount) {
+
+        int count = 0;
+        StringBuilder sb = new StringBuilder();
+        sb.append("=============\t\t=============\n");
+        for (Double price : pricesAndTheirCount.keySet()) {
+            String timeOrTimes = "times";
+            if (pricesAndTheirCount.get(price) == 1) {
+                timeOrTimes = "time";
+            }
+            if (price != 0) {
+                sb.append("Price:   " + price + "\t\tseen: " + pricesAndTheirCount.get(price) + " " + timeOrTimes + "\n");
+                sb.append("-------------\t\t-------------\n");
+            }
+            count++;
+        }
+        if (count > 1) {
+            sb.delete(sb.length() - 29, sb.length());
+        }
+//        sb.deleteCharAt(sb.length() - 1);
+        return sb.toString();
+    }
+
+    public String getReportAsString() {
+        StringBuilder sb = new StringBuilder();
+        for (String name : itemOrganizer.keySet()) {
+            if (! name.equals("EMPTY")) {
+                sb.append(itemNameAndCountAsString(name) + "\n");
+                sb.append(pricesAndTheirCountAsString(getPricesAndTheirCount(name)) + "\n");
+            }
+        }
+        sb.append(getIpe().errorCountAsString());
+        return sb.toString();
+    }
+
+    public Item parseStringIntoItem(String rawItem) throws ItemParseException {
+
+        String emptyFieldName = "";
+        List<String> keyValuePairsArrayList = findKeyValuePairsInRawItemData(rawItem);
+
+        String upToAndIncludingColonString = "\\w+:";
+        Pattern upToAndIncludingColonPattern = Pattern.compile(upToAndIncludingColonString);
+
+        Matcher nameMatcher = upToAndIncludingColonPattern.matcher(keyValuePairsArrayList.get(0));
+        String name = nameMatcher.replaceAll("").toLowerCase();
+        String cookiesString = "(c|C)\\w+(s|S)";
+        Pattern cookiesPattern = Pattern.compile(cookiesString);
+        Matcher cookiesMatcher = cookiesPattern.matcher(name);
+        if (cookiesMatcher.find()) {
+            name = cookiesMatcher.replaceAll("cookies");
+        }
+        if (name.equals("")) {
+            name = "EMPTY";
+            emptyFieldName = "name";
+            ipe.logErrorCount(emptyFieldName, rawItem);
+        }
+
+        Matcher priceMatcher = upToAndIncludingColonPattern.matcher(keyValuePairsArrayList.get(1));
+        String priceString = priceMatcher.replaceAll("");
+        if (priceString.equals("")) {
+            priceString = "0.00";
+            emptyFieldName = "price";
+            ipe.logErrorCount(emptyFieldName, rawItem);
+        }
+        double price = Double.parseDouble(priceString);
+
+        Matcher typeMatcher = upToAndIncludingColonPattern.matcher(keyValuePairsArrayList.get(2));
+        String type = typeMatcher.replaceAll("").toLowerCase();
+        if (type.equals("")) {
+            type = "EMPTY";
+            emptyFieldName = "type";
+            ipe.logErrorCount(emptyFieldName, rawItem);
+        }
+
+        Matcher expirationMatcher = upToAndIncludingColonPattern.matcher(keyValuePairsArrayList.get(3));
+        String expiration = expirationMatcher.replaceAll("").toLowerCase();
+        if (expiration.equals("")) {
+            expiration = "EMPTY";
+            emptyFieldName = "expiration";
+            ipe.logErrorCount(emptyFieldName, rawItem);
+        }
+
+        Item item = new Item(name, price, type, expiration);
+        return item;
     }
 
     public ArrayList<String> findKeyValuePairsInRawItemData(String rawItem){
-        String stringPattern = "[;|^]";
-        ArrayList<String> response = splitStringWithRegexPattern(stringPattern , rawItem);
+        String stringPattern = "[^\\w:.\\/]";
+        ArrayList<String> response = splitStringWithRegexPattern(rawItem, stringPattern);
         return response;
     }
 
-    private ArrayList<String> splitStringWithRegexPattern(String stringPattern, String inputString){
+    private ArrayList<String> splitStringWithRegexPattern(String inputString, String stringPattern){
         return new ArrayList<String>(Arrays.asList(inputString.split(stringPattern)));
     }
 
-
-
 }

src/main/java/io/zipcoder/Main.java

@@ -13,7 +13,26 @@ public class Main {
 
     public static void main(String[] args) throws Exception{
         String output = (new Main()).readRawDataToString();
-        System.out.println(output);
+//        System.out.println(output);
         // TODO: parse the data in output into items, and display to console.
+
+        ItemParser itemParser = new ItemParser();
+        itemParser.parseRawDataIntoItemStringArray(output);
+        itemParser.createItems();
+        itemParser.addNameAndItemsOfSameNameToItemOrganizer();
+
+        // Prints report in alphabetical order by name (the prices/counts match output.txt)
+        System.out.println(itemParser.getReportAsString());
+
+        // These commands (commented out) will print the same information in the order of output.txt
+//        System.out.println(itemParser.itemNameAndCountAsString("milk"));
+//        System.out.println(itemParser.pricesAndTheirCountAsString(itemParser.getPricesAndTheirCount("milk")));
+//        System.out.println(itemParser.itemNameAndCountAsString("bread"));
+//        System.out.println(itemParser.pricesAndTheirCountAsString(itemParser.getPricesAndTheirCount("bread")));
+//        System.out.println(itemParser.itemNameAndCountAsString("cookies"));
+//        System.out.println(itemParser.pricesAndTheirCountAsString(itemParser.getPricesAndTheirCount("cookies")));
+//        System.out.println(itemParser.itemNameAndCountAsString("apples"));
+//        System.out.println(itemParser.pricesAndTheirCountAsString(itemParser.getPricesAndTheirCount("apples")));
+//        System.out.println(itemParser.getIpe().errorCountAsString());
     }
 }

src/main/resources/RawDataCopy.txt

@@ -0,0 +1 @@
+naMe:Milk;price:3.23;type:Food;expiration:1/25/2016##naME:BreaD;price:1.23;type:Food;expiration:1/02/2016##NAMe:BrEAD;price:1.23;type:Food;expiration:2/25/2016##naMe:MiLK;price:3.23;type:Food^expiration:1/11/2016##naMe:Cookies;price:2.25;type:Food%expiration:1/25/2016##naMe:CoOkieS;price:2.25;type:Food*expiration:1/25/2016##naMe:COokIes;price:2.25;type:Food;expiration:3/22/2016##naMe:COOkieS;price:2.25;type:Food;expiration:1/25/2016##NAME:MilK;price:3.23;type:Food;expiration:1/17/2016##naMe:MilK;price:1.23;type:Food!expiration:4/25/2016##naMe:apPles;price:0.25;type:Food;expiration:1/23/2016##naMe:apPles;price:0.23;type:Food;expiration:5/02/2016##NAMe:BrEAD;price:1.23;type:Food;expiration:1/25/2016##naMe:;price:3.23;type:Food;expiration:1/04/2016##naMe:Milk;price:3.23;type:Food;expiration:1/25/2016##naME:BreaD;price:1.23;type:Food@expiration:1/02/2016##NAMe:BrEAD;price:1.23;type:Food@expiration:2/25/2016##naMe:MiLK;priCe:;type:Food;expiration:1/11/2016##naMe:Cookies;price:2.25;type:Food;expiration:1/25/2016##naMe:Co0kieS;pRice:2.25;type:Food;expiration:1/25/2016##naMe:COokIes;price:2.25;type:Food;expiration:3/22/2016##naMe:COOkieS;Price:2.25;type:Food;expiration:1/25/2016##NAME:MilK;price:3.23;type:Food;expiration:1/17/2016##naMe:MilK;priCe:;type:Food;expiration:4/25/2016##naMe:apPles;prIce:0.25;type:Food;expiration:1/23/2016##naMe:apPles;pRice:0.23;type:Food;expiration:5/02/2016##NAMe:BrEAD;price:1.23;type:Food;expiration:1/25/2016##naMe:;price:3.23;type:Food^expiration:1/04/2016##

src/test/java/io/zipcoder/ItemParseExceptionTest.java

@@ -0,0 +1,27 @@
+package io.zipcoder;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class ItemParseExceptionTest {
+
+    private ItemParser itemParser;
+    private String rawBrokenSingleItem = "naMe:;price:3.23;type:Food;expiration:1/25/2016##";
+
+    @Before
+    public void setUp() {
+        itemParser = new ItemParser();
+    }
+
+    @Test
+    public void logErrorCountTest() throws ItemParseException {
+        // Given
+        int expectedErrorCount = 1;
+        Item item = itemParser.parseStringIntoItem(rawBrokenSingleItem);
+        // When
+        int actualErrorCount = itemParser.getIpe().getErrorCount();
+        // Then
+        Assert.assertEquals(expectedErrorCount, actualErrorCount);
+    }
+}

src/test/java/io/zipcoder/ItemParserTest.java

@@ -5,6 +5,7 @@ import org.junit.Before;
 import org.junit.Test;
 
 import java.util.ArrayList;
+import java.util.List;
 
 import static org.junit.Assert.*;
 
@@ -14,11 +15,23 @@ public class ItemParserTest {
 
     private String rawSingleItemIrregularSeperatorSample = "naMe:MiLK;price:3.23;type:Food^expiration:1/11/2016##";
 
-    private String rawBrokenSingleItem =    "naMe:Milk;price:3.23;type:Food;expiration:1/25/2016##";
+    // I "broke" the original String value (I removed "Milk"), because the original String value was good
+    private String rawBrokenSingleItem =    "naMe:;price:3.23;type:Food;expiration:1/25/2016##";
+    private String rawBrokenSingleItem2 =   "naMe:Milk;price:;type:Food;expiration:1/25/2016##";
 
     private String rawMultipleItems = "naMe:Milk;price:3.23;type:Food;expiration:1/25/2016##"
                                       +"naME:BreaD;price:1.23;type:Food;expiration:1/02/2016##"
                                       +"NAMe:BrEAD;price:1.23;type:Food;expiration:2/25/2016##";
+
+    private String rawMultipleItems2 = "naMe:Milk;price:3.23;type:Food;expiration:1/25/2016##"
+                                      +"naME:BreaD;price:3.23;type:Food;expiration:1/02/2016##"
+                                      +"NAMe:BrEAD;price:1.23;type:Food;expiration:2/25/2016##";
+
+    private String rawMultipleItems3 = "naMe:Milk;price:3.23;type:Food;expiration:1/25/2016##"
+                                      +"naME:BreaD;price:3.23;type:Food;expiration:1/02/2016##"
+                                      +"naME:BreaD;price:3.23;type:Food;expiration:1/02/2016##"
+                                      +"NAMe:BrEAD;price:1.23;type:Food;expiration:2/25/2016##";
+
     private ItemParser itemParser;
 
     @Before
@@ -27,9 +40,150 @@ public class ItemParserTest {
     }
 
     @Test
+    public void getItemStringsTest() {
+        // Given
+        int expectedItemStringsSize = 3;
+        itemParser.parseRawDataIntoItemStringArray(rawMultipleItems);
+        // When
+        int actualItemStringsSize = itemParser.getItemStrings().size();
+        // Then
+        Assert.assertEquals(expectedItemStringsSize, actualItemStringsSize);
+    }
+
+    @Test
+    public void createItemsTest() throws ItemParseException {
+        // Given
+        int expectedItemsSize = 3;
+        itemParser.parseRawDataIntoItemStringArray(rawMultipleItems);
+        itemParser.createItems();
+        // When
+        int actualItemsSize = itemParser.getItems().size();
+        // Then
+        Assert.assertEquals(expectedItemsSize, actualItemsSize);
+    }
+
+    @Test
+    public void itemsAsStringTest() throws ItemParseException {
+        // Given
+        String expectedDisplay = "1 name:milk price:3.23 type:food expiration:1/25/2016" + "\n"
+                               + "2 name:bread price:1.23 type:food expiration:1/02/2016" + "\n"
+                               + "3 name:bread price:1.23 type:food expiration:2/25/2016";
+        itemParser.parseRawDataIntoItemStringArray(rawMultipleItems);
+        itemParser.createItems();
+        // When
+        String actualDisplay = itemParser.itemsAsString();
+        // Then
+        Assert.assertEquals(expectedDisplay, actualDisplay);
+    }
+
+    @Test
+    public void getItemsOfSameNameTest() throws ItemParseException {
+        // Given
+        String expectedName = "milk";
+        itemParser.parseRawDataIntoItemStringArray(rawMultipleItems);
+        itemParser.createItems();
+        // When
+        ArrayList<Item> itemOfSameName = itemParser.getItemsOfSameName(expectedName);
+        String actualName = itemOfSameName.get(0).getName();
+        // Then
+        Assert.assertEquals(expectedName, actualName);
+    }
+
+    @Test
+    public void addNameAndItemsOfSameNameToItemOrganizerTest() throws ItemParseException {
+        // Given
+        String expectedName = "bread";
+        int expectedNameCount = 2;
+        itemParser.parseRawDataIntoItemStringArray(rawMultipleItems);
+        itemParser.createItems();
+        // When
+        itemParser.addNameAndItemsOfSameNameToItemOrganizer();
+        int actualNameCount = itemParser.getItemOrganizer().get(expectedName).size();
+        // Then
+        Assert.assertEquals(expectedNameCount, actualNameCount);
+    }
+
+    @Test
+    public void itemNameAndCountAsString() throws ItemParseException {
+        // Given
+        String nameForBread = "bread";
+        String expectedNameAndCount = "name:   Bread\t\tseen: 3 times";
+        itemParser.parseRawDataIntoItemStringArray(rawMultipleItems3);
+        itemParser.createItems();
+        // When
+        itemParser.addNameAndItemsOfSameNameToItemOrganizer();
+        String actualNameAndCount = itemParser.itemNameAndCountAsString(nameForBread);
+        // Then
+        Assert.assertEquals(expectedNameAndCount, actualNameAndCount);
+    }
+
+    @Test
+    public void countNumberOfEmptyPriceFieldsTest() throws ItemParseException {
+        // Given
+        String expectedName = "milk";
+        int expectedEmptyPrice = 1;
+        itemParser.parseRawDataIntoItemStringArray(rawBrokenSingleItem2);
+        itemParser.createItems();
+        // When
+        itemParser.addNameAndItemsOfSameNameToItemOrganizer();
+        int actualEmptyPrice = itemParser.countNumberOfEmptyPriceFields(expectedName);
+        // Then
+        Assert.assertEquals(expectedEmptyPrice, actualEmptyPrice);
+
+    }
+
+    @Test
+    public void capitalizeFirstLetterOnlyTest() {
+        // Given
+        String word = "word";
+        String expectedWord = "Word";
+        // When
+        String actualWord = itemParser.capitalizeFirstLetterOnly(word);
+        // Then
+        Assert.assertEquals(expectedWord, actualWord);
+    }
+
+    @Test
+    public void getPricesAndTheirCountTest() throws ItemParseException {
+        // Given
+        String nameForBread = "bread";
+        double expected323Price = 3.23;
+        double expected123Price = 1.23;
+        int expected323Count = 1;
+        int expected123Count = 1;
+        itemParser.parseRawDataIntoItemStringArray(rawMultipleItems2);
+        itemParser.createItems();
+        itemParser.addNameAndItemsOfSameNameToItemOrganizer();
+        // When
+        int actual323Count = itemParser.getPricesAndTheirCount(nameForBread).get(expected323Price);
+        int actual123Count = itemParser.getPricesAndTheirCount(nameForBread).get(expected123Price);
+        // Then
+        Assert.assertEquals(expected323Count, actual323Count);
+        Assert.assertEquals(expected123Count, actual123Count);
+    }
+
+    @Test
+    public void pricesAndTheirCountAsStringTest() throws ItemParseException {
+        // Given
+        String nameForBread = "bread";
+        itemParser.parseRawDataIntoItemStringArray(rawMultipleItems3);
+        itemParser.createItems();
+        itemParser.addNameAndItemsOfSameNameToItemOrganizer();
+        String expectedPricesAndTheirCount = "=============\t\t=============\n" +
+                                             "Price:   " + "3.23" + "\t\tseen: " + "2" + " " + "times" + "\n" +
+                                             "-------------\t\t-------------\n" +
+                                             "Price:   " + "1.23" + "\t\tseen: " + "1" + " " + "time" + "\n" +
+                                             "-------------\t\t-------------";
+        // When
+        String actualPATC = itemParser.pricesAndTheirCountAsString(itemParser.getPricesAndTheirCount(nameForBread));
+        // Then
+        Assert.assertEquals(expectedPricesAndTheirCount, actualPATC);
+    }
+
+    @Test
     public void parseRawDataIntoStringArrayTest(){
         Integer expectedArraySize = 3;
-        ArrayList<String> items = itemParser.parseRawDataIntoStringArray(rawMultipleItems);
+        ArrayList<String> items = itemParser.parseRawDataIntoItemStringArray(rawMultipleItems);
         Integer actualArraySize = items.size();
         assertEquals(expectedArraySize, actualArraySize);
     }