1. Complete the three empty methods (remove(), find(), and contains()) in the ShoppingListArrayList.java file. These methods are already implemented in the ShoppingListArray class.
2. Complete the ShoppingListArrayListTest.java (For many tests, we now just throw a false statement which will cause the test cases to fail. You need to complete them.)

ShoppingListArrayList

package Shopping;

import DataStructures.*; import java.io.FileNotFoundException; import java.util.ArrayList; import java.util.Scanner;

/** * @version Spring 2019 * @author Paul Franklin, Kyle Kiefer */ public class ShoppingListArrayList implements ShoppingListADT {

private ArrayList shoppingList;

/** * Default constructor of ShoppingArray object. */ public ShoppingListArrayList() { this.shoppingList = new ArrayList<>(); }

/** * Constructor of ShoppingArray object that parses from a file. * * @param filename the name of the file to parse * @throws FileNotFoundException if an error occurs when parsing the file */ public ShoppingListArrayList(String filename) throws FileNotFoundException { this.shoppingList = new ArrayList<>(); scanFile(filename); }

/** * Method to add a new entry. Only new entries can be added. Combines * quantities if entry already exists. * * @param entry the entry to be added */ @Override public void add(Grocery entry) {

// Check if this item already exists if (this.contains(entry)) { //Merge the quantity of new entry into existing entry combineQuantity(entry); return; }

shoppingList.add(entry); }

/** * Method to remove an entry. * * @param ent to be removed * @return true when entry was removed * @throws DataStructures.ElementNotFoundException */ @Override public boolean remove(Grocery ent) { // the boolean found describes whether or not we find the // entry to remove boolean found = false;

// search in the shoppingList, if find ent in the // list remove it, set the value of `found'

// Return false if not found return found; }

/** * Method to find an entry. * * @param index to find * @return the entry if found * @throws Exceptions.EmptyCollectionException */ @Override public Grocery find(int index) throws IndexOutOfBoundsException, EmptyCollectionException { if (this.isEmpty()) { throw new EmptyCollectionException("ECE - find"); } throw new IndexOutOfBoundsException("ArrayList - find"); // check whether or not the input index number is legal // for example, < 0 or falls outside of the size // return the corresponding entry in the shoppingList // need to change the return value // return null; }

/** * Method to locate the index of an entry. * * @param ent to find the index * @return the index of the entry * @throws ElementNotFoundException if no entry was found */ @Override public int indexOf(Grocery ent) throws ElementNotFoundException { for (int i = 0; i < shoppingList.size(); i++) { if (shoppingList.get(i).compareTo(ent) == 0) { return i; } }

throw new ElementNotFoundException("indexOf"); }

/** * Method to determine whether the object contains an entry. * * @param ent to find * @return true if and only if the entry is found */ @Override public boolean contains(Grocery ent) { boolean hasItem = false;

// go through the shoppingList and try to find the // item in the list. If found, return true.

return hasItem; }

/** * Gets the size of the collection. * * @return the size of the collection */ @Override public int size() { return shoppingList.size(); }

/** * Gets whether the collection is empty. * * @return true if and only if the collection is empty */ @Override public boolean isEmpty() { return shoppingList.isEmpty(); }

/** * Returns a string representing this object. * * @return a string representation of this object */ @Override public String toString() { StringBuilder s = new StringBuilder(); s.append(String.format("%-25s", "NAME")); s.append(String.format("%-18s", "CATEGORY")); s.append(String.format("%-10s", "AISLE")); s.append(String.format("%-10s", "QUANTITY")); s.append(String.format("%-10s", "PRICE")); s.append(' '); s.append("------------------------------------------------------------" + "-------------"); s.append(' '); for (int i = 0; i < shoppingList.size(); i++) { s.append(String.format("%-25s", shoppingList.get(i).getName())); s.append(String.format("%-18s", shoppingList.get(i).getCategory())); s.append(String.format("%-10s", shoppingList.get(i).getAisle())); s.append(String.format("%-10s", shoppingList.get(i).getQuantity())); s.append(String.format("%-10s", shoppingList.get(i).getPrice())); s.append(' '); s.append("--------------------------------------------------------" + "-----------------"); s.append(' '); }

return s.toString(); }

/** * Add the quantity of a duplicate entry into the existing * * @param entry duplicate */ private void combineQuantity(Grocery entry) { try { int index = this.indexOf(entry); shoppingList.get(index).setQuantity( shoppingList.get(index).getQuantity() + entry.getQuantity()); } catch (ElementNotFoundException e) { System.out.println("combineQuantity - ECE"); }

}

/** * Scans the specified file to add items to the collection. * * @param filename the name of the file to scan * @throws FileNotFoundException if the file is not found */ private void scanFile(String filename) throws FileNotFoundException { Scanner scanner = new Scanner(getClass().getResourceAsStream(filename)) .useDelimiter("(,| )");

while (scanner.hasNext()) { Grocery temp = new Grocery(scanner.next(), scanner.next(), Integer.parseInt(scanner.next()), Float.parseFloat(scanner.next()), Integer.parseInt(scanner.next())); add(temp); } }

}

ShoppingListArrayListTest

package Shopping;

import DataStructures.*; import org.junit.Test; import static org.junit.Assert.*; import org.junit.Before;

/** * @version Spring 2019 * @author Paul Franklin, Kyle Kiefer */ public class ShoppingListArrayListTest {

private ShoppingListArrayList instance;

/** * Initialize instance and entries */ @Before public void setupTestCases() { instance = new ShoppingListArrayList(); }

/** * Test of add method, of class ShoppingArray. */ @Test public void testAdd() { assertTrue(0==1); }

/** * Test of remove method, of class ShoppingArrayList. */ @Test public void testRemove() { assertTrue(0==1); }

/** * Test of find method, of class ShoppingArrayList. */ @Test public void testFind() { assertTrue(0==1); }

/** * Test of indexOf method, of class ShoppingArrayList. */ @Test public void testIndexOf() { assertTrue(0==1); }

/** * Test of contains method, of class ShoppingArrayList. */ @Test public void testContains() { assertTrue(0==1); }

/** * Test of size method, of class ShoppingArrayList. */ @Test public void testSize() { Grocery entry1 = new Grocery("Mayo", "Dressing / Mayo", 1, 2.99f, 1);

assertEquals(0, instance.size());

instance.add(entry1);

// Test increment assertEquals(1, instance.size());

assertTrue(instance.remove(entry1));

// Test decrement assertEquals(0, instance.size()); }

/** * Test of isEmpty method, of class ShoppingArrayList. */ @Test public void testIsEmpty() { Grocery entry1 = new Grocery("Mayo", "Dressing / Mayo", 1, 2.99f, 1);

// Test empty assertTrue(instance.isEmpty());

instance.add(entry1);

// Test not empty assertFalse(instance.isEmpty()); }

}

ShoppingListADT

public interface ShoppingListADT { /** * Method to add a new entry to the shopping list. If a matching item already * exists, the quantities are combined * * @param entry the new item to add */ public void add(Grocery entry);

/** * Method to remove a specific entry from the shopping list * * @param entry the item to remove * @return true if the opperation was completed successfully */ public boolean remove(Grocery entry);

/** * Method to find a specific item in the shopping list * * @param index the index of the item in the shopping list * @return the entry at the specified index * @throws IndexOutOfBoundsException if the index is out of bounds * @throws EmptyCollectionException if the shopping list is empty */ public Grocery find(int index) throws IndexOutOfBoundsException, EmptyCollectionException;

/** * Method to find the index of a Grocery item that is equivalent to the one * provided * * @param entry the item to find * @return the index of the specified item in the shopping list * @throws ElementNotFoundException if the specified item is not in the shopping * list */ public int indexOf(Grocery entry) throws ElementNotFoundException;

/** * Method to determine the existence of a specific item in the shopping list * * @param entry the item to find * @return true if the specified item exists in the shopping list, otherwise * false */ public boolean contains(Grocery entry);

/** * Method to get the size of the shopping list * * @return the size of the shopping list */ public int size();

/** * Method to tell if the shopping list is empty * * @return true if the shopping list is empty, otherwise false */ public boolean isEmpty();

/** * Method to return a string representation of the shopping list * * @return the string representation of the shopping list */ @Override public String toString(); }