I need help in writing the test cases of the below methods in java. The test cases must test
both empty and non empty deque.PLS HELP ME WITH WRITING THE TEST CASES IN
JAVA.ITS URGENT.
package deque;
/**
* A deque implemented using a doubly-linked chain.
*
* @param <T>
* The type of elements contained in the deque.
*/
public class Lab08Deque<T> extends DLinkedDeque<T> {
/**
* Inserts a new item at the front of the deque.
*
* @param newEntry
* the item to insert.
*/
public void addToFront(T newEntry) {
DLNode<T> newNode = new DLNode<T>(newEntry);
if (isEmpty()) {
lastNode = newNode;
}
else {
firstNode.setPreviousNode(newNode);
}
newNode.setNextNode(firstNode);
firstNode = newNode;
size++;
throw new UnsupportedOperationException(
"You have not implemented addToFront() yet");
}
/**
* Insert a new item at the rear of the deque.
*
* @param newEntry
* the item to insert.
*/
public void addToBack(T newEntry) {
DLNode<T> newNode = new DLNode<T>(newEntry);
if (isEmpty()) {
firstNode = newNode;
}
else {
lastNode.setPreviousNode(newNode);
newNode.setPreviousNode(lastNode);
}
lastNode = newNode;
size++;
throw new UnsupportedOperationException(
"You have not implemented addToBack() yet");
}
/**
* Remove the item at the front of the deque.
*
* @return The item that was removed
* @throws EmptyQueueException
* if there is not an element at the front
*/
public T removeFront() {
if (isEmpty()) {
throw new EmptyQueueException();
}
T front = firstNode.getData();
firstNode = firstNode.getNextNode();
if (firstNode == null) {
lastNode = null;
}
else {
firstNode.setPreviousNode(null);
}
throw new UnsupportedOperationException(
"You have not implemented removeFront() yet");
}
/**
* Remove the item at the rear of the deque.
*
* @return The item that was removed
* @throws EmptyQueueException
* if there is no element at the front
*/
public T removeBack() {
if (isEmpty()) {
throw new EmptyQueueException();
}
T data = lastNode.getData();
lastNode = lastNode.getPreviousNode();
if (lastNode == null) {
firstNode = null;
}
else {
lastNode.setPreviousNode(null);
}
throw new UnsupportedOperationException(
"You have not implemented removeBack() yet");
}
/**
* Get the item at the front (the head) of the deque. Does not alter the
* deque.
*
* @return the item at the front of the deque.
* @throws EmptyQueueException
* if no element at the front
*/
public T getFront() {
if (isEmpty()) {
throw new EmptyQueueException();
}
return firstNode.getData();
}
/**
* Get the item at the rear (the tail) of the deque. Does not alter the
* deque.
*
* @return the item at the rear of the deque.
* @throws EmptyQueueException
* if no element at rear
*
*/
public T getBack() {
if (isEmpty()) {
throw new EmptyQueueException();
}
return lastNode.getData();
}
/**
* Check if the deque is empty
*
* @return true if the deque has no items
*/
public boolean isEmpty() {
return size() == 0;
}
/**
* Empty the deque.
*/
public void clear() {
while (!isEmpty()) {
removeFront();
}
}
// -------------------------------.
I need help in writing the test cases of the below methods i.pdf
1. I need help in writing the test cases of the below methods in java. The test cases must test
both empty and non empty deque.PLS HELP ME WITH WRITING THE TEST CASES IN
JAVA.ITS URGENT.
package deque;
/**
* A deque implemented using a doubly-linked chain.
*
* @param <T>
* The type of elements contained in the deque.
*/
public class Lab08Deque<T> extends DLinkedDeque<T> {
/**
* Inserts a new item at the front of the deque.
*
* @param newEntry
* the item to insert.
*/
public void addToFront(T newEntry) {
DLNode<T> newNode = new DLNode<T>(newEntry);
if (isEmpty()) {
lastNode = newNode;
}
else {
firstNode.setPreviousNode(newNode);
}
newNode.setNextNode(firstNode);
firstNode = newNode;
size++;
throw new UnsupportedOperationException(
"You have not implemented addToFront() yet");
}
/**
* Insert a new item at the rear of the deque.
*
* @param newEntry
* the item to insert.
*/
public void addToBack(T newEntry) {
DLNode<T> newNode = new DLNode<T>(newEntry);
if (isEmpty()) {
firstNode = newNode;
}
2. else {
lastNode.setPreviousNode(newNode);
newNode.setPreviousNode(lastNode);
}
lastNode = newNode;
size++;
throw new UnsupportedOperationException(
"You have not implemented addToBack() yet");
}
/**
* Remove the item at the front of the deque.
*
* @return The item that was removed
* @throws EmptyQueueException
* if there is not an element at the front
*/
public T removeFront() {
if (isEmpty()) {
throw new EmptyQueueException();
}
T front = firstNode.getData();
firstNode = firstNode.getNextNode();
if (firstNode == null) {
lastNode = null;
}
else {
firstNode.setPreviousNode(null);
}
throw new UnsupportedOperationException(
"You have not implemented removeFront() yet");
}
/**
* Remove the item at the rear of the deque.
*
* @return The item that was removed
* @throws EmptyQueueException
* if there is no element at the front
*/
public T removeBack() {
if (isEmpty()) {
throw new EmptyQueueException();
}
3. T data = lastNode.getData();
lastNode = lastNode.getPreviousNode();
if (lastNode == null) {
firstNode = null;
}
else {
lastNode.setPreviousNode(null);
}
throw new UnsupportedOperationException(
"You have not implemented removeBack() yet");
}
/**
* Get the item at the front (the head) of the deque. Does not alter the
* deque.
*
* @return the item at the front of the deque.
* @throws EmptyQueueException
* if no element at the front
*/
public T getFront() {
if (isEmpty()) {
throw new EmptyQueueException();
}
return firstNode.getData();
}
/**
* Get the item at the rear (the tail) of the deque. Does not alter the
* deque.
*
* @return the item at the rear of the deque.
* @throws EmptyQueueException
* if no element at rear
*
*/
public T getBack() {
if (isEmpty()) {
throw new EmptyQueueException();
}
return lastNode.getData();
}
/**
* Check if the deque is empty
4. *
* @return true if the deque has no items
*/
public boolean isEmpty() {
return size() == 0;
}
/**
* Empty the deque.
*/
public void clear() {
while (!isEmpty()) {
removeFront();
}
}
// ----------------------------------------------------------
/**
* Returns a string representation of this deque. A deque's string
* representation is written as a comma-separated list of its contents (in
* front-to-rear order) surrounded by square brackets, like this:
*
* [52, 14, 12, 119, 73, 80, 35]
*
* An empty deque is simply [].
*
* @return a string representation of the deque
*/
@Override
public String toString() {
StringBuilder s = new StringBuilder();
s.append("[");
DLNode<T> p = firstNode;
while (p != null) {
if (s.length() > 1) {
s.append(", ");
}
s.append(p.getData());
p = p.getNextNode();
}
s.append("]");
return s.toString();
}
}
