Programmieren mit Harald R. Haberstroh

Folgende Grenzfälle werden getestet:

• 0 Elemente aufnehmen, Anzahl muss gleich bleiben
  
• 0 Elemente löschen, Anzahl muss gleich bleiben

Sonderfälle:

• negative Anzahl Elemente aufnehmen, Exception
  
• negative Anzahl Elemente löschen, Exception
• nicht vorhandenes Element löschen, Exception

"Normalfälle":

• 10 Elemente aufnehmen, Anzahl testen
  
• 10 Elemente aufnehmen, Ergebnis des Iterators testen

Weitere Annahmen, die aus der Angabe nicht unbedingt hervorgehen:
Die Artikel (Elemente/Items) werden in der Reihenfolge und der gegebenen Anzahl gespeichert, als addItems() aufgerufen wurde. Wird ein Element mit der Anzahl 5 in den Warenkorb aufgenommen, so wird das Element 5 mal gespeichert.

Testklasse:

import java.util.Iterator;
import junit.framework.TestCase;

/**
* unittests/.ShoppingCartTest.java
*
* @author (c) 2009, Harald R. Haberstroh 23.04.2009
*/
public class ShoppingCartTest extends TestCase {

 private ShoppingCart cart;

 private Item[] items = { new Item(1), new Item(2), new Item(3) };

 /**
  * @throws java.lang.Exception
  */
 protected void setUp() throws Exception {
   cart = new MyCart();
 }

 /**
  * @throws java.lang.Exception
  */
 protected void tearDown() throws Exception {
 }

 /*
  * addItem mit Menge 0, itemCount() muss gleich bleiben.
  */
 public void testAddItems0() {
   try {
     cart.addItems(items[0], 0);
     assertEquals("testDeleteItems0: 0 Elemente", 0, cart.itemCount());
   } catch (NegativeCountException e) {
     fail("testAddItem0: es dürfte keine NegativeCountException geworfen werden");
   }
 }

 /*
  * eine negative Anzahl von Elementen aufnehmen -> NegativeCountException
  */
 public void testAddItemNegativ() {
   try {
     cart.addItems(items[0], -23);
     fail("testAddItemNegativ: es müsste eine NegativeCountException geworfen werden");
   } catch (NegativeCountException e) {
   }
 }

 /*
  * deleteItem mit Menge 0, itemCount() muss gleich bleiben.
  */
 public void testDeleteItems0() {
   try {
     cart.addItems(items[0], 1);
     cart.deleteItems(items[0], 0);
     assertEquals("testDeleteItems0: 1 Element", 1, cart.itemCount());
   } catch (NegativeCountException e) {
     fail("testDeleteItems0: es dürfte keine NegativeCountException geworfen werden");
   } catch (NoSuchItemException e) {
     fail("testDeleteItems0: es dürfte keine NoSuchItemException geworfen werden");
   }
 }

 /*
  * deleteItem nicht gültiges Item -> NoSuchItemException, itemCount() == 0
  */
 public void testDeleteItemsNoSuchItem() {
   try {
     cart.addItems(items[0], 1);
     cart.deleteItems(items[1], 1);
     fail("testDeleteItemsNoSuchItem: es müsste NoSuchItemException geworfen werden");
   } catch (NegativeCountException e) {
     fail("testDeleteItemsNoSuchItem: es dürfte keine NegativeCountException geworfen werden");
   } catch (NoSuchItemException e) {
     assertEquals("testDeleteItemsNoSuchItem: 1 Element", 1, cart.itemCount());
   }
 }

 /*
  * eine negative Anzahl von Elementen aufnehmen -> NegativeCountException
  */
 public void testDeleteItemNegativ() {
   try {
     cart.addItems(items[0], -23);
     fail("testAddItemNegativ: es müsste eine NegativeCountException geworfen werden");
   } catch (NegativeCountException e) {
   }
 }

 /*
  * addItems für 10 Items, keine Exception, itemCount() == 10
  */
 public void testAddItems10() {
   try {
     cart.addItems(items[0], 3);
     cart.addItems(items[1], 3);
     cart.addItems(items[2], 4);
     assertEquals("testAddItems10: 10 Elemente", 10, cart.itemCount());
   } catch (NegativeCountException e) {
     fail("testAddItems10: es dürfte keine NegativeCountException geworfen werden");
   }
 }

 /*
  * addItems für 10 Items, deleteItems für 5 Items, keine Exception,
  * itemCount() == 5
  */
 public void testAddDeleteItems5() {
   try {
     cart.addItems(items[0], 3);
     cart.addItems(items[1], 3);
     cart.addItems(items[2], 4);
     cart.deleteItems(items[0], 2);
     cart.deleteItems(items[2], 2);
     cart.deleteItems(items[1], 1);
     assertEquals("testAddDeleteItems5: 5 Elemente", 5, cart.itemCount());
   } catch (NegativeCountException e) {
     fail("testAddDeleteItems5: es dürfte keine NegativeCountException geworfen werden");
   } catch (NoSuchItemException e) {
     fail("testAddDeleteItems5: es dürfte keine NoSuchItemException geworfen werden");
   }
 }

 /*
  * addItems für 10 Items, Iterator muss Zugriff auf die 10 Elemente gestatten
  */
 public void testIterator() {
   try {
     cart.addItems(items[0], 3);
     cart.addItems(items[1], 3);
     cart.addItems(items[2], 4);
     Iterator<Item> iterator = cart.iterator();
     int cntItems = 0;
     Item[] stroredItems = new Item[10];
     while (iterator.hasNext()) {
       stroredItems[cntItems] = iterator.next();
       cntItems++;
     }
     assertEquals("testIterator: 10 Elemente", 10, cntItems);
     for (int i = 0; i < 3; i++) {
       assertEquals("testIterator: Element sollte gleich sein", items[0],
           stroredItems[i]);
       System.out.println(stroredItems[i]);
     }
     for (int i = 3; i < 6; i++) {
       assertEquals("testIterator: Element sollte gleich sein", items[1],
           stroredItems[i]);
       System.out.println(stroredItems[i]);
     }
     for (int i = 6; i < 10; i++) {
       assertEquals("testIterator: Element sollte gleich sein", items[2],
           stroredItems[i]);
       System.out.println(stroredItems[i]);
     }
   } catch (NegativeCountException e) {
     fail("testIterator: es dürfte keine NegativeCountException geworfen werden");
   }
 }
}

Implementierung des Interfaces ShoppingCart:

import java.util.ArrayList;
import java.util.Iterator;

/**
* unittests/.MyCart.java
* @author (c) 2009, Harald R. Haberstroh
* 23.04.2009
*/
public class MyCart implements ShoppingCart {

 private ArrayList<Item> items = new ArrayList<Item>();

 /*
  * (non-Javadoc)
  *
  * @see ShoppingCart#addItems(Item, int)
  */
 public void addItems(Item anItem, int quantity) throws NegativeCountException {
   if (quantity < i =" 0;" i =" 0;"> iterator() {
   return items.iterator();
 }

}

Zusätzlich müssen natürlich die geforderten Exceptions implementiert werden (Kommentare wurden hier weggelassen):

public class NegativeCountException extends Exception {

}

public class NoSuchItemException extends Exception {

}

Die Klasse für die Artikel (Item) wurde einfach durch eine Nummer ergänzt, die beim Konstruktor angegeben werden muss. Für eine realistische Anwendung müsste diese Klasse noch erweitert werden:

/**
* unittests/.Item.java
* @author (c) 2009, Harald R. Haberstroh
* 23.04.2009
*/

/**
* @author Harald R. Haberstroh (user)
*
*/
public class Item {
 private int itemNr = 0;

 /**
  * @param itemNr
  */
 public Item(int itemNr) {
   this.itemNr = itemNr;
 }

 /*
  * (non-Javadoc)
  *
  * @see java.lang.Object#toString()
  */
 @Override
 public String toString() {
   return "Item " + itemNr;
 }

}

Labels: Java, Lösung, PR3