Question: I need help writing the junit test for the ResizableArrayBag class which implements the BagInterface. It must be the junit test class, I already have
I need help writing the junit test for the ResizableArrayBag class which implements the BagInterface.
It must be the junit test class, I already have a regular test class written.
// BagInterface.java
/**
* An interface that describes the operations of a bag of objects.
*
* @author Frank M. Carrano
* @version 4.0
*/
public interface BagInterface
{
/**
* Gets the current number of entries in this bag.
*
* @return The integer number of entries currently in the bag.
*/
public int getCurrentSize();
/**
* Sees whether this bag is empty.
*
* @return True if the bag is empty, or false if not.
*/
public boolean isEmpty();
/**
* Adds a new entry to this bag.
*
* @param newEntry
* The object to be added as a new entry.
* @return True if the addition is successful, or false if not.
*/
public boolean add(T newEntry);
/**
* Removes one unspecified entry from this bag, if possible.
*
* @return Either the removed entry, if the removal.
*
* was successful, or null.
*/
public T remove();
/**
* Removes one occurrence of a given entry from this bag.
*
* @param anEntry
* The entry to be removed.
* @return True if the removal was successful, or false if not.
*/
public boolean remove(T anEntry);
/** Removes all entries from this bag. */
public void clear();
/**
* Counts the number of times a given entry appears in this bag.
*
* @param anEntry
* The entry to be counted.
* @return The number of times anEntry appears in the bag.
*/
public int getFrequencyOf(T anEntry);
/**
* Tests whether this bag contains a given entry.
*
* @param anEntry
* The entry to locate.
* @return True if the bag contains anEntry, or false if not.
*/
public boolean contains(T anEntry);
/**
* Retrieves all entries that are in this bag.
*
* @return A newly allocated array of all the entries in the bag.
*
* Note: If the bag is empty, the returned array is empty.
*/
public T[] toArray();
// newly added methods
/**
* returns a new bag- the union of the bag receiving the call to the method
* and the bag that is the method's one argument
*/
public BagInterface
/**
*
* @return a new bag the intersection of the bag receiving the call to the
* method and the bag that is the method's one argument
*/
public BagInterface
/**
* @return the difference of the bag receiving the call to the method and
* the bag that is the method's one argument
*
*/
public BagInterface
} // end BagInterface
// ResizableArrayBag.java
import java.util.Arrays;
import java.util.Random;
/**
* A class that implements a bag of objects by using an array.
*
* The bag is never full.
*
* @author Frank M. Carrano
* @version 4.0
*/
public final class ResizableArrayBag
{
private T[] bag; // Cannot be final due to doubling
private int numberOfEntries;
private boolean initialized = false;
private static final int DEFAULT_CAPACITY = 25; // Initial capacity of bag
private static final int MAX_CAPACITY = 10000;
/** Creates an empty bag whose initial capacity is 25. */
public ResizableArrayBag()
{
this(DEFAULT_CAPACITY);
} // end default constructor
/**
* Creates an empty bag having a given initial capacity.
*
* @param initialCapacity
* The integer capacity desired.
*/
public ResizableArrayBag(int initialCapacity)
{
checkCapacity(initialCapacity);
// The cast is safe because the new array contains null entries
@SuppressWarnings("unchecked")
T[] tempBag = (T[]) new Object[initialCapacity]; // Unchecked cast
bag = tempBag;
numberOfEntries = 0;
initialized = true;
} // end constructor
/**
* Creates a bag containing given entries.
*
* @param contents
* An array of objects.
*/
public ResizableArrayBag(T[] contents)
{
checkCapacity(contents.length);
bag = Arrays.copyOf(contents, contents.length);
numberOfEntries = contents.length;
initialized = true;
} // end constructor
/**
* Adds a new entry to this bag.
*
* @param newEntry
* The object to be added as a new entry.
* @return True.
*/
public boolean add(T newEntry)
{
checkInitialization();
if (isArrayFull())
{
doubleCapacity();
} // end if
bag[numberOfEntries] = newEntry;
numberOfEntries++;
return true;
} // end add
/**
* Retrieves all entries that are in this bag.
*
* @return A newly allocated array of all the entries in this bag.
*/
public T[] toArray()
{
checkInitialization();
// The cast is safe because the new array contains null entries.
@SuppressWarnings("unchecked")
T[] result = (T[]) new Object[numberOfEntries]; // Unchecked cast
for (int index = 0; index < numberOfEntries; index++)
{
result[index] = bag[index];
} // end for
return result;
} // end toArray
/**
* Sees whether this bag is empty.
*
* @return True if this bag is empty, or false if not.
*/
public boolean isEmpty()
{
return numberOfEntries == 0;
} // end isEmpty
/**
* Gets the current number of entries in this bag.
*
* @return The integer number of entries currently in this bag.
*/
public int getCurrentSize()
{
return numberOfEntries;
} // end getCurrentSize
/**
* Counts the number of times a given entry appears in this bag.
*
* @param anEntry
* The entry to be counted.
* @return The number of times anEntry appears in this ba.
*/
public int getFrequencyOf(T anEntry)
{
checkInitialization();
int counter = 0;
for (int index = 0; index < numberOfEntries; index++)
{
if (anEntry.equals(bag[index]))
{
counter++;
} // end if
} // end for
return counter;
} // end getFrequencyOf
/**
* Tests whether this bag contains a given entry.
*
* @param anEntry
* The entry to locate.
* @return True if this bag contains anEntry, or false otherwise.
*/
public boolean contains(T anEntry)
{
checkInitialization();
return getIndexOf(anEntry) > -1; // or >= 0
} // end contains
/** Removes all entries from this bag. */
public void clear()
{
while (!isEmpty())
remove();
} // end clear
/**
* Removes one unspecified entry from this bag, if possible.
*
* @return Either the removed entry, if the removal
*
* was successful, or null.
*/
public T remove()
{
checkInitialization();
T result = removeEntry(numberOfEntries - 1);
return result;
} // end remove
/**
* Removes one occurrence of a given entry from this bag.
*
* @param anEntry
* The entry to be removed.
* @return True if the removal was successful, or false if not.
*/
public boolean remove(T anEntry)
{
checkInitialization();
int index = getIndexOf(anEntry);
T result = removeEntry(index);
// Resizing the array if too big
if (isTooBig()) {
reduceArray();
}
return anEntry.equals(result);
} // end remove
// Locates a given entry within the array bag.
// Returns the index of the entry, if located,
// or -1 otherwise.
// Precondition: checkInitialization has been called.
private int getIndexOf(T anEntry)
{
int where = -1;
boolean found = false;
int index = 0;
while (!found && (index < numberOfEntries))
{
if (anEntry.equals(bag[index]))
{
found = true;
where = index;
} // end if
index++;
} // end while
// Assertion: If where > -1, anEntry is in the array bag, and it
// equals bag[where]; otherwise, anEntry is not in the array.
return where;
} // end getIndexOf
// Removes and returns the entry at a given index within the array.
// If no such entry exists, returns null.
// Precondition: 0 <= givenIndex < numberOfEntries.
// Precondition: checkInitialization has been called.
private T removeEntry(int givenIndex)
{
T result = null;
if (!isEmpty() && (givenIndex >= 0))
{
result = bag[givenIndex]; // Entry to remove
int lastIndex = numberOfEntries - 1;
bag[givenIndex] = bag[lastIndex]; // Replace entry to remove with
// last entry
bag[lastIndex] = null; // Remove reference to last entry
numberOfEntries--;
} // end if
// Resizing the array if too big
if (isTooBig()) {
reduceArray();
}
return result;
} // end removeEntry
// Returns true if the array bag is full, or false if not.
private boolean isArrayFull()
{
return numberOfEntries >= bag.length;
} // end isArrayFull
// Doubles the size of the array bag.
// Precondition: checkInitialization has been called.
private void doubleCapacity()
{
int newLength = 2 * bag.length;
checkCapacity(newLength);
bag = Arrays.copyOf(bag, newLength);
} // end doubleCapacity
// Throws an exception if the client requests a capacity that is too large.
private void checkCapacity(int capacity)
{
if (capacity > MAX_CAPACITY)
throw new IllegalStateException(
"Attempt to create a bag whose capacity exceeds " +
"allowed maximum of " + MAX_CAPACITY);
} // end checkCapacity
// Throws an exception if receiving object is not initialized.
private void checkInitialization()
{
if (!initialized)
throw new SecurityException("Uninitialized object used " +
"to call an ArrayBag method.");
} // end checkInitialization
public T replace(T replacement) {
/**
* Replacing a random object and returning the removed object
*/
int randomIndex = new Random().nextInt(numberOfEntries);
T originalData = bag[randomIndex];
bag[randomIndex] = replacement;
return originalData;
}
//newly added methods
/**
* method to remove all occurrences of an entry
* @param anEntry
*/
public void removeEntry(T anEntry) {
while (getIndexOf(anEntry) != -1) {
removeEntry(getIndexOf(anEntry));
}
}
/**
* method to check if two bags are equal
*/
@Override
public boolean equals(Object o) {
if (o instanceof ResizableArrayBag) {
ResizableArrayBag otherBag = (ResizableArrayBag) o;
if (getCurrentSize() == otherBag.getCurrentSize()) {
for (int i = 0; i < numberOfEntries; i++) {
if (getFrequencyOf(bag[i]) != otherBag
.getFrequencyOf(bag[i])) {
return false;
}
return true;
}
}
}
return false;
}
/**
*
* @return true if number of entries in the bag is less than half of the size, and size>20
*/
private boolean isTooBig() {
if (numberOfEntries < bag.length / 2 && bag.length > 20) {
return true;
}
return false;
}
/**
* resizes the bag array to 3/4th of the original array
*/
private void reduceArray() {
int newSize = (int) ((3.0 / 4.0) * bag.length);
bag = Arrays.copyOf(bag, newSize);
}
@Override
public BagInterface
/**
* creating a new ResizableArrayBag with all elements of this bag
*/
ResizableArrayBag
/**
* getting all contents of other bag and adding to the new bag
*/
T otherBagContents[] = otherBag.toArray();
if (otherBag != null) {
for (T content : otherBagContents) {
newBag.add(content);
}
}
return newBag;
}
@Override
public BagInterface
/**
* creating a new ResizableArrayBag
*/
ResizableArrayBag
/**
* looping through all elements of this bag
*/
for (int i = 0; i < numberOfEntries; i++) {
T item = bag[i];
/**
* checking if other bag contains the current item and not already
* added to the new bag
*/
if (otherBag.contains(item) && !newBag.contains(item)) {
// checking count of the item in two bags
int count1 = getFrequencyOf(item);
int count2 = otherBag.getFrequencyOf(item);
// finding the minimum count
int commonFrequency = Math.min(count1, count2);
// adding to the new bag specified number of times
for (int j = 0; j < commonFrequency; j++) {
newBag.add(item);
}
}
}
return newBag;
}
@Override
public BagInterface
/**
* creating a new ResizableArrayBag
*/
ResizableArrayBag
/**
* looping through all elements of this bag
*/
for (int i = 0; i < numberOfEntries; i++) {
T item = bag[i];
/**
* checking if the item is already added
*/
if (!newBag.contains(item)) {
// checking count of the item in two bags
int count1 = getFrequencyOf(item);
int count2 = otherBag.getFrequencyOf(item);
// finding the difference
int difference=count1-count2;
// adding to the new bag specified number of times
for (int j = 0; j < difference; j++) {
newBag.add(item);
}
}
}
return newBag;
}
} // end ResizableArrayBag
Step by Step Solution
There are 3 Steps involved in it
Get step-by-step solutions from verified subject matter experts
Study Help