Question

AQueue.java

class AQueue implements Queue {
private E queueArray[]; // Array holding queue elements
private static final int DEFAULT_SIZE = 10;
private int maxSize; // Maximum size of queue
private int front; // Index of front element
private int rear; // Index of rear element

// Constructors
@SuppressWarnings("unchecked") // Generic array allocation
AQueue(int size) {
//BUG #1: maxSize = size
maxSize = size+1; // One extra space is allocated
rear = 0; front = 1;
queueArray = (E[])new Object[maxSize]; // Create queueArray
}
AQueue() { this(DEFAULT_SIZE); }

// Reinitialize
public void clear() { rear = 0; front = 1; }

// Put "it" in queue
public boolean enqueue(E it) {
//BUG #2: remove or comment out the line below this comment
if (((rear+2) % maxSize) == front) return false; // Full
rear = (rear+1) % maxSize; // Circular increment
queueArray[rear] = it;
return true;
}

// Remove and return front value
public E dequeue() {
if (length() == 0) return null;
E it = queueArray[front];
//BUG #3: front = front+1
front = (front+1) % maxSize; // Circular increment
return it;
}

// Return front value
public E frontValue() {
//BUG #4: remove or comment out the line below this comment
if (length() == 0) return null;
return queueArray[front];
}

// Return queue size
public int length() { return ((rear+maxSize) - front + 1) % maxSize; }
  
//Tell if the queue is empty or not
//BUG #5: public boolean isEmpty() { return front - rear == 1; }
public boolean isEmpty() { return front == (rear + 1) % maxSize; }
}

Queue.java

public interface Queue { // Queue class ADT
// Reinitialize queue
public void clear();

// Put element on rear
public boolean enqueue(E it);

// Remove and return element from front
public E dequeue();

// Return front element
public E frontValue();

// Return queue size
public int length();
  
//Tell if the queue is empty or not
public boolean isEmpty();
}

TestQueue.java (Starter Code)

/**
* @author
*/

public class TestQueue
{
public static void main(String[] args)
{
System.out.println("Bug 4 test: " + (testBug4() ? "passed" : "failed"));
}

public static boolean testBug1()
{
return false;
}

public static boolean testBug2()
{
return false;
}

public static boolean testBug3()
{
return false;
}

/**
* This bug will allow frontValue to return something from the array even if the
* queue is empty.
*
* Unless the queue contains another bug (and we're allowed to assume it does
* not in this assignment), this will not cause an exception. When the queue is
* created, the array will initially contain nothing but null. In order to
* detect this bug, we need to fill every spot in the array and then empty the
* queue. If front value returns something other than null, then we will know
* it's accessing the array.
*/
public static boolean testBug4()
{
AQueue queue = new AQueue(4);

for (int i = 0; i < 5; i++)
{
queue.enqueue("A");
queue.dequeue();
}

return queue.frontValue() == null;
}

public static boolean testBug5()
{
return false;
}
}

In TestQueue is should return true if AQueue passes by not containing any bugs and return false if it contains any bugs. It says it in the first two pictures.

Description Testing is very important in large software projects, and it is common to test individual classes and methods in isolation [referred to as unit testing). Unit tests are effective for ensuring a small part of the program meets its specifications, and bugs detected by unit tests tend to be easy to locate and fix (we know they're in the class or method that was tested]. This activity is meant to provide some practice writing tests, as well as improve your understanding of the inner workings of the circular queue implementation in the text. Rather than writing comprehensive unit tests, you will instead be writing tests for a set of 4 bugs in the AQueue class (there are 5, but one test has already been written for you as an example). When writing each method, you may also assume that no bugs exist except for the bug you are testing. This is not normally a realistic assumption, but it allows us to use a much simpler testing scenario in this introduction. The starter code for this lab contains a modified version of the AQueue from Chapter 9, the Queue interface, and an outline for the test class. If you look at the AQueue code, you should find 5 comments starting with the word "BUG. Each of these comments shows how to create a bug thet must be detected by one of the tests This involves modifying or removing the line below the "BUG comment. You can add and remove the bug to make sure your test detects its presence or absence. In the TestQueue class you will find 5 static methods, one for each of the bugs in AQueue. Your job is to complete the 4 unfinished tests. Each test should return true if the AQueue passes (does not contain the bug) or false if it fails (does contain the bug). Grading Submit TestQueue.java. This assignment will be graded by Mimir's automated tests. Each test will run one of your methods on two versions of the AQueue: one with the bug and one without the bug. Make sure each method is testing for the appropriete bug, and thet it returns true if the bug is not present Advice When beginning to write a test for one of the bugs, it can be helpful to answer the following questions 1. What is the purpose of the original line of code? 2 How does the bug change the queue's behavior? 3. How can I cause the queue to exhibit this behavior? We can look at the bug #4 test for an example of this process. If we answer the above questions for bug #4 1. The original line of code prevents the queue from accessing the array when the queue is empty. The array can contain garbage data, but if the queue is empty then the frontValuel method should always return null (the queue has no front value when empty 2. Removing that line of code allows frontValue to return garbage data from the array when the queue is empty 3. If we fill the entire array with non-null values and dequeue each value, then the queue will be empty, but each space in the array contains a value other than null. if we then call frontValue, it will access the array alinahas is and nnn Moditying or removing the line below the "BUG Comment. You can add and remove the bug to make sure your test detects its presence or absence. In the TestQueue class you will find 5 static methods, one for each of the bugs in AQueue. Your job is to complete the 4 unfinished tests. Each test should return true if the AQueue passes (does not contain the buglc false if it fails (does contain the bug). Grading Submit TestQueue.java. This assignment will be graded by Mimir's automated tests. Each test will run one of your methods on two versions of the AQueue: one with the bug and one without the bug. Make sure each method is testing for the appropriate bug, and that it returns true if the bug is not present Advice When beginning to write a test for one of the bugs, it can be helpful to an: answer the following questions: 1. What is the purpose of the original line of code? 2 How does the bug change the queue's behavior? 3. How can I cause the queue to exhibit this behavior? We can look at the bug # 4 test for an example of this process. If we answer the above questions for bug # 4: 1. The original line of code prevents the queue from accessing the array when the queue is empty. The array can contain garbage data, but if the queue is empty then the frontValue(] method should always return null (the queue has no front value when empty). 2 Removing that line of code allows frontValue to return garbage data from the array when the queue is empty. 3. If we fill the entire array with non-null values and dequeue each value, then the queue will be empty, but each space in the array contains a value other than null. If we then call frontValue, it will access the array and return a value that isn't null. With the answers to these questions, it's much easier to write our test. We make a new queue, enqueue and dequeue an arbitrary value (anything but null) until the entire array has been overwritten, and then check whether frontValue) returns null. If it does supposed to be empty, indicating that bug # 4 is present not return null, then it is accessing the array while the queue is

Answer 1

Please do rate the answer if it was helpful. Thank you
To indent code in eclipse , select code by pressing ctrl+a and then indent using ctrl+i

import java.util.NoSuchElementException;
public class ArrayQueue<T> implements QueueInterface<T> {
// Do not add new instance variables.
private T[] backingArray;
private int front;
private int size;
/**
* Constructs a new ArrayQueue.
*/
public ArrayQueue() {
backingArray = (T[])new Object[INITIAL_CAPACITY];
front = 0;
size = 0;
}
/**
* Dequeue from the front of the queue.
*
* Do not shrink the backing array.
* If the queue becomes empty as a result of this call, you should
* explicitly reset front to 0.
*
* You should replace any spots that you dequeue from with null. Failure to
* do so can result in a loss of points.
*
* See the homework pdf for more information on implementation details.
*
* @see QueueInterface#dequeue()
*/
/**
* Dequeue from the front of the queue.
*
* This method should be implemented in O(1) time.
*
* @return the data from the front of the queue
* @throws java.util.NoSuchElementException if the queue is empty
*/
@Override
public T dequeue() {
if(isEmpty())
throw new NoSuchElementException();
T val = backingArray[front];
backingArray[front] = null;
front++;
size--;
if(isEmpty())
front = 0;
return val;
}
/**
* Add the given data to the queue.
*
* If sufficient space is not available in the backing array, you should
* regrow it to double the current length. If a regrow is necessary,
* you should copy elements to the front of the new array and reset
* front to 0.
*
* @see QueueInterface#enqueue(T)
*/
/**
* Add the given data to the queue.
*
* This method should be implemented in (if array-backed, amortized) O(1)
* time.
*
* @param data the data to add
* @throws IllegalArgumentException if data is null
*/
@Override
public void enqueue(T data) {
int last = front + size;
//expand the array if the new data can't fit
if(last >= backingArray.length)
{
T[] temp = (T[]) new Object[2*backingArray.length];
for(int i = 0, j = front; i < size; i++, j++)
temp[i] = backingArray[j];
backingArray = temp;
front = 0;
last = size;
}
backingArray[last] = data;
}
@Override
public T peek() {
return backingArray[front];
}
@Override
public boolean isEmpty() {
// DO NOT MODIFY THIS METHOD!
return size == 0;
}
@Override
public int size() {
// DO NOT MODIFY THIS METHOD!
return size;
}
/**
* Returns the backing array of this queue.
* Normally, you would not do this, but we need it for grading your work.
*
* DO NOT USE THIS METHOD IN YOUR CODE.
*
* @return the backing array
*/
public Object[] getBackingArray() {
// DO NOT MODIFY THIS METHOD!
return backingArray;
}
}