CS-144
/
class
1
0
Fork 0
Code Issues 0 Pull Requests 0 Projects 0 Releases 0 Wiki Activity
Browse Source

Finish project 3

master
Brett Bender 3 years ago
parent
d534e31b64
commit
3e7cde90f3
4 changed files with 811 additions and 6 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +52
    -1
      LAB-9/src/uwstout/courses/cs144/projects/project3/orders/OrderList.java
  2. +360
    -0
      LAB-9/src/uwstout/courses/cs144/projects/project3/orders/OrderListTest.java
  3. +53
    -5
      LAB-9/src/uwstout/courses/cs144/projects/project3/orders/OrderProcessor.java
  4. +346
    -0
      LAB-9/src/uwstout/courses/cs144/projects/project3/orders/OrderProcessorTest.java

+ 52
- 1
LAB-9/src/uwstout/courses/cs144/projects/project3/orders/OrderList.java View File

@ -1,5 +1,11 @@
package uwstout.courses.cs144.projects.project3.orders;
/**
* Represents a list of Orders
*
* @author Brett Bender
* @version 2022.12.12
*/
public class OrderList {
private static final int INITIAL_SIZE = 3;
@ -7,11 +13,19 @@ public class OrderList {
private Order[] orders;
private int count;
/**
* Creates an empty order list
*/
public OrderList() {
orders = new Order[INITIAL_SIZE];
count = 0;
}
/**
* Copies an order list
*
* @param other The list to copy
*/
public OrderList(OrderList other) {
count = other.count;
orders = new Order[other.orders.length];
@ -20,10 +34,21 @@ public class OrderList {
}
}
/**
* Get the number of orders in the list.
*
* @return The number of orders
*/
public int getOrderCount() {
return count;
}
/**
* Get a specific order in the list
*
* @param pos The position to get the order from
* @return The order in that position
*/
public Order getOrder(int pos) {
if (pos >= 0 && pos < count) {
return orders[pos];
@ -31,6 +56,11 @@ public class OrderList {
return null;
}
/**
* Adds an order to the list (automatically grows the array if needed).
*
* @param other The order to add
*/
public void addOrder(Order other) {
if (count == orders.length) {
growArray();
@ -38,6 +68,12 @@ public class OrderList {
orders[count++] = other;
}
/**
* Finds an order in the list. Returns null if can't be found.
*
* @param orderNumber The order number to search for
* @return The order
*/
public Order findOrder(int orderNumber) {
Order found = null;
for (int i = 0; i < count; i++) {
@ -50,6 +86,11 @@ public class OrderList {
return found;
}
/**
* Get the grand total off all of the orders in the array.
*
* @return The grand total (with tax)
*/
public double getGrandTotal() {
double sum = 0;
for (int i = 0; i < count; i++) {
@ -60,10 +101,17 @@ public class OrderList {
return sum;
}
/**
* Substitutes an item into the orders in the list.
*
* @param subItem The item to be subbed out
* @param replacementName The name of the item being subbed in
* @return The number of orders that had the item replaced
*/
public int substituteItems(MenuItem subItem, String replacementName) {
int replaced = 0;
for (int i = 0; i < 0; i++) {
for (int i = 0; i < count; i++) {
if (orders[i].substituteItem(subItem, replacementName)) {
replaced++;
}
@ -72,6 +120,9 @@ public class OrderList {
return replaced;
}
/**
* Clears the list
*/
public void clearList() {
count = 0;
}


+ 360
- 0
LAB-9/src/uwstout/courses/cs144/projects/project3/orders/OrderListTest.java View File

@ -0,0 +1,360 @@
package uwstout.courses.cs144.projects.project3.orders;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import org.junit.Before;
import org.junit.Test;
/**
* Tests the OrderList class
*
* @author Brett Bender
* @version 2022.12.12
*/
public class OrderListTest {
private static final double DELTA = 0.01;
/**
* Some standard menu items to be used in tests.
*/
private static final MenuItem[] MENU_ITEMS = {
new MenuItem("Steak", 25.45, MenuItemType.ENTREE), // 0
new MenuItem("Tofu", 35.95, MenuItemType.ENTREE), // 1
new MenuItem("Chicken Noodle", 3.75, MenuItemType.SOUP), // 2
new MenuItem("Hot Seasoned Water", 10.10, MenuItemType.SOUP), // 3
new MenuItem("All Lettuce", 7.15, MenuItemType.SALAD), // 4
new MenuItem("Taco Salad", 5.65, MenuItemType.SALAD), // 5
new MenuItem("Water", 3.50, MenuItemType.DRINK), // 6
new MenuItem("Cold Water", 5.50, MenuItemType.DRINK), // 7
new MenuItem("Fries", 6.95, MenuItemType.SIDE), // 8
new MenuItem("Bacon Fries", 8.95, MenuItemType.SIDE), // 9
new MenuItem("Fried Bacon", 10.95, MenuItemType.SIDE), // 10
new MenuItem("Mixed Vegetables", 5.50, MenuItemType.SIDE), // 11
new MenuItem("Unmixed Vegetables", 6.50, MenuItemType.SIDE), // 12
new MenuItem("Pie", 7.25, MenuItemType.DESSERT), // 13
new MenuItem("Cake", 6.10, MenuItemType.DESSERT), }; // 14
private OrderList list1;
private OrderList list2;
/**
* Sets the class up for testing
*
* @throws Exception Not used
*/
@Before
public void setUp() throws Exception {
// List 1
list1 = new OrderList();
Order order;
// add some stuff
order = new Order(531);
order.addItem(MENU_ITEMS[0]);
order.addItem(MENU_ITEMS[8]);
order.addItem(MENU_ITEMS[14]);
list1.addOrder(order);
order = new Order(97645);
order.addItem(MENU_ITEMS[3]);
order.addItem(MENU_ITEMS[6]);
order.addItem(MENU_ITEMS[11]);
order.addItem(MENU_ITEMS[12]);
list1.addOrder(order);
order = new Order(2931);
order.addItem(MENU_ITEMS[6]);
list1.addOrder(order);
// List 2
list2 = new OrderList();
order = new Order(8675309);
order.addItem(MENU_ITEMS[1]);
order.addItem(MENU_ITEMS[5]);
order.addItem(MENU_ITEMS[6]);
list2.addOrder(order);
order = new Order(1337);
order.addItem(MENU_ITEMS[7]);
order.addItem(MENU_ITEMS[14]);
list2.addOrder(order);
}
/**
* Tests the constructor
*/
@Test
public void testOrderList() {
OrderList testList = new OrderList();
assertEquals(0, testList.getOrderCount());
assertNull(testList.getOrder(0));
}
/**
* Tests the copy constructor
*/
@Test
public void testOrderListOrderList() {
// Test copy constructor
OrderList copyList = new OrderList(list1);
assertEquals("List length is wrong", list1.getOrderCount(),
copyList.getOrderCount());
// check orders
for (int i = 0; i < list1.getOrderCount(); i++) {
assertTrue("The orders in the list were wrong",
checkOrder(list1.getOrder(i), copyList.getOrder(i)));
// check if a copy was made, instead of a reference
assertNotSame("The Orders were not copied", list1.getOrder(i),
copyList.getOrder(i));
}
OrderList copyList2 = new OrderList(list2);
assertEquals("List length is wrong", list2.getOrderCount(),
copyList2.getOrderCount());
// check orders
for (int i = 0; i < list2.getOrderCount(); i++) {
assertTrue("The orders in the list were wrong",
checkOrder(list2.getOrder(i), copyList2.getOrder(i)));
// check if a copy was made, instead of a reference
assertNotSame("The Orders were not copied", list2.getOrder(i),
copyList2.getOrder(i));
}
}
/**
* Tests the getOrderCount method
*/
@Test
public void testGetOrderCount() {
assertEquals(3, list1.getOrderCount());
assertEquals(2, list2.getOrderCount());
}
/**
* Tests the getOrder method
*/
@Test
public void testGetOrder() {
assertNull(list1.getOrder(-1));
assertTrue(checkOrder(list1.getOrder(0), 531, new MenuItem[] {
MENU_ITEMS[0], MENU_ITEMS[8], MENU_ITEMS[14] }));
assertTrue(checkOrder(list1.getOrder(1), 97645,
new MenuItem[] { MENU_ITEMS[3], MENU_ITEMS[6], MENU_ITEMS[11],
MENU_ITEMS[12] }));
assertTrue(checkOrder(list1.getOrder(2), 2931,
new MenuItem[] { MENU_ITEMS[6] }));
assertNull(list1.getOrder(3));
assertNull(list2.getOrder(-1));
assertTrue(checkOrder(list2.getOrder(0), 8675309, new MenuItem[] {
MENU_ITEMS[1], MENU_ITEMS[5], MENU_ITEMS[6] }));
assertTrue(checkOrder(list2.getOrder(1), 1337,
new MenuItem[] { MENU_ITEMS[7], MENU_ITEMS[14] }));
assertNull(list2.getOrder(2));
}
/**
* Tests the addOrder method
*/
@Test
public void testAddOrder() {
Order order;
// Generally test adding again
order = new Order(333);
order.addItem(MENU_ITEMS[1]);
list1.addOrder(order);
assertTrue(checkOrder(list1.getOrder(list1.getOrderCount() - 1), 333,
new MenuItem[] { MENU_ITEMS[1] }));
// Ensure we can go past the initial 5 limit
order = new Order(666);
order.addItem(MENU_ITEMS[2]);
order.addItem(MENU_ITEMS[10]);
order.addItem(MENU_ITEMS[13]);
list1.addOrder(order);
assertTrue(checkOrder(list1.getOrder(list1.getOrderCount() - 1), 666,
new MenuItem[] { MENU_ITEMS[2], MENU_ITEMS[10],
MENU_ITEMS[13] }));
}
/**
* Tests the findOrder method
*/
@Test
public void testFindOrder() {
assertNull(list1.findOrder(-1));
assertTrue(checkOrder(list1.findOrder(531), list1.getOrder(0)));
assertTrue(checkOrder(list1.findOrder(97645), list1.getOrder(1)));
assertTrue(checkOrder(list1.findOrder(2931), list1.getOrder(2)));
assertNull(list2.findOrder(-1));
assertTrue(checkOrder(list2.findOrder(8675309), list2.getOrder(0)));
assertTrue(checkOrder(list2.findOrder(1337), list2.getOrder(1)));
}
/**
* Tests the getGrandTotal method
*/
@Test
public void testGetGrandTotal() {
assertEquals(71.39, list1.getGrandTotal(), DELTA);
assertEquals(59.88, list2.getGrandTotal(), DELTA);
}
/**
* Tests the substituteItem method
*/
@Test
public void testSubstituteItems() {
// Changing water to boiling water
// 2 Orders should change
MenuItem[] items1 = { MENU_ITEMS[3],
// item 6 with name changed
new MenuItem("Boiling Water", 3.50, MenuItemType.DRINK),
MENU_ITEMS[11], MENU_ITEMS[12] };
MenuItem[] items2 = {
new MenuItem("Boiling Water", 3.50, MenuItemType.DRINK),
};
// 1 should not, make copy
Order origOrder = new Order(list1.getOrder(0));
// Should substitute Water
// do this after creating the array of menu items
assertEquals("Wrong value returned", 2,
list1.substituteItems(MENU_ITEMS[6], "Boiling Water"));
assertTrue("substituteItems failed - order 0",
checkOrder(list1.getOrder(0), origOrder));
assertTrue("substituteItems failed - order 1",
checkOrder(list1.getOrder(1), 97645, items1));
assertTrue("substituteItems failed - order 2",
checkOrder(list1.getOrder(2), 2931, items2));
// Changing water to boiling water
// Only the first order should change
MenuItem[] list2Items1 = {
// item 6 with name changed
MENU_ITEMS[1], MENU_ITEMS[5],
new MenuItem("Mountain Moo", 3.50, MenuItemType.DRINK) };
origOrder = new Order(list2.getOrder(1));
// Should substitute Water
// do this after creating the array of menu items
assertEquals("Wrong value returned", 1,
list2.substituteItems(MENU_ITEMS[6], "Mountain Moo"));
assertTrue("substituteItems failed - order 0",
checkOrder(list2.getOrder(0), 8675309, list2Items1));
assertTrue("substituteItems failed - order 1",
checkOrder(list2.getOrder(1), origOrder));
}
/**
* Tests the clearList method
*/
@Test
public void testClearList() {
assertEquals(3, list1.getOrderCount());
list1.clearList();
assertEquals(0, list1.getOrderCount());
assertNull(list1.getOrder(0));
assertEquals(2, list2.getOrderCount());
list2.clearList();
assertEquals(0, list2.getOrderCount());
assertNull(list2.getOrder(0));
}
/**
* Compares two MenuItems
*
* @param expected The MenuItem you expect to have
* @param actual The actual MenuItem
* @return true if they are the same
*/
private boolean checkMenuItem(MenuItem expected, MenuItem actual) {
// if both are null or the same object
if (expected == actual) {
return true;
}
// one of them is null
if (expected == null || actual == null) {
return false;
}
// check if all of the values match
return expected.getName().equals(actual.getName())
&& Math.abs(expected.getCost() - actual.getCost()) < 0.01
&& expected.getType() == actual.getType();
}
/**
* Checks if an Order is as expected
*
* @param ord Order to check
* @param eOrderNumber Expected order number
* @param items Array of MenuItems that should be in the array.
* Should have the same length as the number of items in
* the order.
* @return True if it matches the order number and items.
*/
private boolean checkOrder(Order ord, int eOrderNumber, MenuItem[] items) {
// check if the order number of number of items
// is wrong
if (ord == null || ord.getOrderNumber() != eOrderNumber
|| ord.getItemCount() != items.length) {
return false;
}
// check if each menu item is the same
for (int i = 0; i < ord.getItemCount(); i++) {
if (!checkMenuItem(items[i], ord.getItem(i))) {
return false;
}
}
// must be equal if we are here.
return true;
}
/**
* Checks if an Order is as expected
*
* @param eOrder Expected value
* @param aOrder Actual order
*
* @return True if the orders are the same.
*/
private boolean checkOrder(Order eOrder, Order aOrder) {
// if both are null or the same object
if (eOrder == aOrder) {
return true;
}
// one of them is null
// or the number of items does not match
if (eOrder == null || aOrder == null
|| eOrder.getItemCount() != aOrder.getItemCount()) {
return false;
}
// check if each menu item is the same
for (int i = 0; i < eOrder.getItemCount(); i++) {
if (!checkMenuItem(eOrder.getItem(i), aOrder.getItem(i))) {
return false;
}
}
// must be equal if we are here.
return true;
}
}

+ 53
- 5
LAB-9/src/uwstout/courses/cs144/projects/project3/orders/OrderProcessor.java View File

@ -1,11 +1,27 @@
package uwstout.courses.cs144.projects.project3.orders;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.Scanner;
/**
* Processes orders from a file, as well as additional helpers for handling
* data.
*
* @author Brett Bender
* @version 2022.12.12
*/
public class OrderProcessor {
private static final NumberFormat DF = DecimalFormat.getCurrencyInstance();
private OrderList oList;
/**
* Create an OrderProcessor with the given order list
*
* @param nOList The order list to be used
*/
public OrderProcessor(OrderList nOList) {
oList = null;
if (nOList != null) {
@ -13,10 +29,21 @@ public class OrderProcessor {
}
}
/**
* Get the OrderList associated with this processor
*
* @return The order list
*/
public OrderList getList() {
return oList;
}
/**
* Process a scanner that contains commands that the OrderProcessor should
* handle.
*
* @param sc The input scanner
*/
public void processOrders(Scanner sc) {
if (oList == null) {
return;
@ -34,7 +61,7 @@ public class OrderProcessor {
orderCommand(lineSc);
break;
case "items":
case "item":
itemCommand(lineSc);
break;
@ -49,6 +76,11 @@ public class OrderProcessor {
}
}
/**
* Get a summary of all of the orders in the OrderList.
*
* @return The summary
*/
public String getOrderSummary() {
if (oList == null) {
return "";
@ -58,15 +90,21 @@ public class OrderProcessor {
for (int i = 0; i < oList.getOrderCount(); i++) {
Order order = oList.getOrder(i);
builder.append(order.getOrderNumber() + " " + order.getTotalCost()
+ order.getTax() + "\n");
builder.append(order.getOrderNumber() + " "
+ DF.format(order.getTotalCost() + order.getTax()) + "\n");
}
builder.append("\nGrand Total: " + oList.getGrandTotal());
builder.append("\nGrand Total: " + DF.format(oList.getGrandTotal()));
return builder.toString();
}
/**
* Get a summary of the types that are contained within the orders
*
* @param types The types to get a summary of
* @return The summary
*/
public String getMenuItemSummary(MenuItemType[] types) {
if (oList == null) {
return "";
@ -90,6 +128,14 @@ public class OrderProcessor {
return builder.toString().trim();
}
/**
* Process the order command:
*
* {@code order <order number> <item count> <item name 1> <item cost 1> <item type
* 1> <item name 2> ...}
*
* @param sc The scanner
*/
private void orderCommand(Scanner sc) {
int orderNumber = sc.nextInt();
int itemCount = sc.nextInt();
@ -106,7 +152,9 @@ public class OrderProcessor {
int orderNumber = sc.nextInt();
Order order = oList.findOrder(orderNumber);
order.addItem(readItem(sc));
if (order != null) {
order.addItem(readItem(sc));
}
}
private void subCommand(Scanner sc) {


+ 346
- 0
LAB-9/src/uwstout/courses/cs144/projects/project3/orders/OrderProcessorTest.java View File

@ -0,0 +1,346 @@
package uwstout.courses.cs144.projects.project3.orders;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.util.Scanner;
import org.junit.Before;
import org.junit.Test;
/**
* Tests the OrderProcessor class
*
* @author Brett Bender
* @version 2022.12.12
*
*/
public class OrderProcessorTest {
/**
* Some standard menu items to be used in tests.
*/
private static final MenuItem[] ITEM_VALUES = {
new MenuItem("Pork", 19.15, MenuItemType.ENTREE),
new MenuItem("Tofu", 35.95, MenuItemType.ENTREE),
new MenuItem("Chicken Noodle", 3.75, MenuItemType.SOUP),
new MenuItem("Hot Seasoned Water", 10.10, MenuItemType.SOUP),
new MenuItem("All Lettuce", 7.15, MenuItemType.SALAD),
new MenuItem("Ceasar Salad", 4.50, MenuItemType.SALAD),
new MenuItem("Taco Salad", 5.65, MenuItemType.SALAD),
new MenuItem("Water", 3.50, MenuItemType.DRINK),
new MenuItem("Sprite", 4.15, MenuItemType.DRINK),
new MenuItem("Cold Water", 5.50, MenuItemType.DRINK),
new MenuItem("Bacon Fries", 8.95, MenuItemType.SIDE),
new MenuItem("Fried Bacon", 10.95, MenuItemType.SIDE),
new MenuItem("Mixed Vegetables", 5.50, MenuItemType.SIDE),
new MenuItem("Unmixed Vegetables", 6.50, MenuItemType.SIDE),
new MenuItem("Pie", 7.25, MenuItemType.DESSERT),
new MenuItem("Ice Cream", 5.10, MenuItemType.DESSERT), };
/*
* A series of order commands for testing All fields are separated by \t and
* each line ends with a tab
*/
private static final String ORDER_INPUT = "order\t39515\t1\tFried Bacon\t10.95\tSIDE\n"
+ "order\t66618\t2\tAll Lettuce\t7.15\tSALAD\tPork\t19.15\tENTREE\n"
+ "order\t82328\t1\tCold Water\t5.5\tDRINK\n"
+ "subs\tCeasar Salad\t4.5\tSALAD\tNothin' But Lettuce\n"
+ "order\t11613\t1\tCeasar Salad\t4.5\tSALAD\n"
+ "item\t82328\tPork\t19.15\tENTREE\n"
+ "order\t74480\t2\tTofu\t35.95\tENTREE\tSprite\t4.15\tDRINK\n"
+ "order\t31423\t2\tUnmixed Vegetables\t6.5\tSIDE\tWater\t3.5\tDRINK\n"
+ "order\t55259\t3\tTaco Salad\t5.65\tSALAD\tHot Seasoned Water\t10.1\tSOUP\tTofu\t35.95\tENTREE\n"
+ "item\t00001\tUnmixed Vegetables\t6.5\tSIDE\n"
+ "subs\tTofu\t35.95\tENTREE\tBacon\n";
private OrderProcessor p2;
/**
* Sets the class up for testing
*
* @throws Exception Not used
*/
@Before
public void setUp() throws Exception {
p2 = new OrderProcessor(null);
}
/**
* Tests the constructor
*/
@Test
public void testOrderProcessor() {
OrderList expectedList = getExpectedList();
OrderProcessor o1 = new OrderProcessor(null);
OrderProcessor o2 = new OrderProcessor(getExpectedList());
assertNull(o1.getList());
OrderList testList = o2.getList();
// check orders
for (int i = 0; i < expectedList.getOrderCount(); i++) {
assertTrue("The Order at position " + i + " did not match",
checkOrder(expectedList.getOrder(i), testList.getOrder(i)));
}
}
/**
* Tests the processOrders method
*/
@Test
public void testProcessOrders() {
OrderList list = new OrderList();
OrderProcessor processor = new OrderProcessor(list);
// Create Scanner with input
Scanner input = new Scanner(ORDER_INPUT);
// process it
processor.processOrders(input);
// Get expected list
OrderList expectedList = getExpectedList();
// Get list from processor
OrderList readInList = processor.getList();
assertEquals("Processed list is not the right length.",
expectedList.getOrderCount(), readInList.getOrderCount());
// check orders
for (int i = 0; i < expectedList.getOrderCount(); i++) {
assertTrue("The Order at position " + i + " did not match",
checkOrder(expectedList.getOrder(i),
readInList.getOrder(i)));
}
OrderProcessor processor2 = new OrderProcessor(null);
// This should do nothing.
// Create Scanner with input
Scanner input2 = new Scanner(ORDER_INPUT);
// process it
processor2.processOrders(input2);
// Get list from processor
OrderList readInList2 = processor2.getList();
assertNull(readInList2);
}
/**
* Tests the getOrderSummary method
*/
@Test
public void testGetOrderSummary() {
OrderList list = new OrderList();
OrderProcessor processor = new OrderProcessor(list);
// Create Scanner with input
Scanner input = new Scanner(ORDER_INPUT);
// process it
processor.processOrders(input);
// get report
String summary = processor.getOrderSummary();
// for debugging
// System.out.println(summary);
// Check if the order numbers are in string
// indexOf returns the position in the String where
// the parameter is found. It returns -1 if
// it is not there.
assertNotEquals("No order number found", -1, summary.indexOf("39515"));
assertNotEquals("No order number found", -1, summary.indexOf("66618"));
assertNotEquals("No order number found", -1, summary.indexOf("82328"));
assertNotEquals("No order number found", -1, summary.indexOf("11613"));
assertNotEquals("No order number found", -1, summary.indexOf("74480"));
assertNotEquals("No order number found", -1, summary.indexOf("31423"));
assertNotEquals("No order number found", -1, summary.indexOf("55259"));
// find the costs + tax
assertNotEquals("No order total found", -1, summary.indexOf("11.56"));
assertNotEquals("No order total found", -1, summary.indexOf("27.77"));
assertNotEquals("No order total found", -1, summary.indexOf("26.03"));
assertNotEquals("No order total found", -1, summary.indexOf("4.75"));
assertNotEquals("No order total found", -1, summary.indexOf("42.35"));
assertNotEquals("No order total found", -1, summary.indexOf("10.56"));
assertNotEquals("No order total found", -1, summary.indexOf("54.60"));
// find grand total
assertNotEquals("No grand total found", -1, summary.indexOf("177.62"));
// Test to make sure it returns nothing if oList is null
assertEquals("", new OrderProcessor(null).getOrderSummary());
}
/**
* Tests the getMenuItemSummary method
*/
@Test
public void testGetMenuItemSummary() {
MenuItemType[] typesInReport = { MenuItemType.DRINK, MenuItemType.SOUP,
MenuItemType.DESSERT };
MenuItemType[] typesNotInReport = { MenuItemType.ENTREE,
MenuItemType.SALAD, MenuItemType.SIDE };
OrderList list = new OrderList();
OrderProcessor processor = new OrderProcessor(list);
// Create Scanner with input
Scanner input = new Scanner(ORDER_INPUT);
// process it
processor.processOrders(input);
// get report
String summary = processor.getMenuItemSummary(typesInReport);
// for debugging
// System.out.println(summary);
// find the names of the types in the output
for (int i = 0; i < typesInReport.length; i++) {
// indexOf returns -1 if not found
assertNotEquals(typesInReport[i] + " was not in the summary.", -1,
summary.indexOf(typesInReport[i].toString()));
}
// find the counts in the summary
// This is not the best way, but is good enough
// for the moment
assertNotEquals("Cannot find the Drink count", -1,
summary.indexOf("3"));
assertNotEquals("Cannot find the Soup count", -1, summary.indexOf("1"));
assertNotEquals("Cannot find the Dessert count", -1,
summary.indexOf("0"));
// check for other names not being there
for (int i = 0; i < typesNotInReport.length; i++) {
// indexOf returns -1 if not found
assertEquals(
typesNotInReport[i] + " was in the summary "
+ "when it should not be.",
-1, summary.indexOf(typesNotInReport[i].toString()));
}
// Test to make sure it returns nothing if oList is null
assertEquals("",
new OrderProcessor(null).getMenuItemSummary(typesInReport));
}
/**
* Compares two MenuItems
*
* @param expected The MenuItem you expect to have
* @param actual The actual MenuItem
* @return true if they are the same
*/
private boolean checkMenuItem(MenuItem expected, MenuItem actual) {
// if both are null or the same object
if (expected == actual) {
return true;
}
// one of them is null
if (expected == null || actual == null) {
return false;
}
// check if all of the values match
return expected.getName().equals(actual.getName())
&& Math.abs(expected.getCost() - actual.getCost()) < 0.01
&& expected.getType() == actual.getType();
}
/**
* Checks if an Order is as expected
*
* @param eOrder Expected value
* @param aOrder Actual order
*
* @return True if the orders are the same.
*/
private boolean checkOrder(Order eOrder, Order aOrder) {
// if both are null or the same object
if (eOrder == aOrder) {
return true;
}
// one of them is null
// or the number of items does not match
if (eOrder == null || aOrder == null
|| eOrder.getItemCount() != aOrder.getItemCount()) {
return false;
}
// check if each menu item is the same
for (int i = 0; i < eOrder.getItemCount(); i++) {
if (!checkMenuItem(eOrder.getItem(i), aOrder.getItem(i))) {
return false;
}
}
// must be equal if we are here.
return true;
}
/**
* Creates the expected output for ORDER_INPUT
*
* @return List with the expected output
*/
private OrderList getExpectedList() {
// substituted menu items
// "subs\tTofu\t35.95\tENTREE\tBacon"
MenuItem subs = new MenuItem("Bacon", 35.95, MenuItemType.ENTREE);
// does nothing since there isn't anything order in the list
// with a Ceasar Salad when this is run
// "subs\tCeasar Salad\t4.5\tSALAD\tNothin' But Lettuce\n"
// does nothing since 00001 is not an order number
// in the list
// "item\t00001\tUnmixed Vegetables\t6.5\tSIDE\n"
OrderList list = new OrderList();
Order order;
// "order\t39515\t1\tFried Bacon\t10.95\tSIDE\n"
order = new Order(39515);
order.addItem(ITEM_VALUES[11]);
list.addOrder(order);
// "order\t66618\t2\tAll Lettuce\t7.15\tSALAD\tPork\t19.15\tENTREE\n"
order = new Order(66618);
order.addItem(ITEM_VALUES[4]);
order.addItem(ITEM_VALUES[0]);
list.addOrder(order);
// "order\t82328\t1\tCold Water\t5.5\tDRINK\n"
// "item\t82328\tPork\t19.15\tENTREE\n" adds item
order = new Order(82328);
order.addItem(ITEM_VALUES[9]);
order.addItem(ITEM_VALUES[0]);
list.addOrder(order);
// "order\t11613\t1\tCeasar Salad\t4.5\tSALAD\n"
order = new Order(11613);
order.addItem(ITEM_VALUES[5]);
list.addOrder(order);
// "order\t74480\t2\tTofu\t35.95\tENTREE\tSprite\t4.15\tDRINK\n"
order = new Order(74480);
order.addItem(subs); // substituted for ITEM_VALUES[1]
order.addItem(ITEM_VALUES[8]);
list.addOrder(order);
// "order\t31423\t2\tUnmixed Vegetables\t6.5\tSIDE\tWater\t3.5\tDRINK\n"
order = new Order(31423);
order.addItem(ITEM_VALUES[13]);
order.addItem(ITEM_VALUES[7]);
list.addOrder(order);
// "order\t55259\t3\tTaco Salad\t5.65\tSALAD\tHot Seasoned
// Water\t10.1\tSOUP\tTofu\t35.95\tENTREE\n";
order = new Order(55259);
order.addItem(ITEM_VALUES[6]);
order.addItem(ITEM_VALUES[3]);
order.addItem(subs); // substituted for ITEM_VALUES[1]
list.addOrder(order);
return list;
}
}

Write Preview
Loading…
Cancel
Save