Question

Java/Queues

** Task: Write a JUnit test that shows a failure in some part of the ADT

-----ArrayQueue.java-------

public class ArrayQueue {
   private static final int INITIAL_CAPACITY = 2; // to permit easier testing
   private Object[] contents;
   private int front, rear;
  
   /**
   * Create an empty queue with an initial capacity.
   */
   public ArrayQueue() {
       contents = new Object[INITIAL_CAPACITY];
   }
  
   /**
   * Add an element to the back of the queue.
   * The queue's capacity is increased as necessary.
   * @param element element added
   */
   public void enqueue(E element) {
       contents[rear] = element;
       ++rear;
       if (rear >= INITIAL_CAPACITY) {
           Object[] newContents = new Object[contents.length*2];
           for (int i=0; i < contents.length; ++i) {
               newContents[i] = contents[i];
           }
           contents = newContents;
       }
   }
  
   /**
   * Remove and return the front of the queue.
   * @return first element in the queue.
   */
   public E dequeue() {
       E result = peek();
       ++front;
       if (front >= INITIAL_CAPACITY) front = 0;
       return result;
   }
  
   /**
   * Return the front of the queue without removing it.
   * @return the first element in the queue.
   */
   public E peek() {
       @SuppressWarnings("unchecked")
       E result = (E)contents[front];
       return result;
   }
  
   /**
   * Return the number of elements in the queue.
   * @return number of elements in the queue.
   */
   public int size() {
       return front + rear;
   }
  
   /**
   * Return the capacity of the queue.
   * It shouldn't more than twice
   * the maximum size (or max size + 1) the queue ever had.
   * @return current capacity of the queue
   */
   public int capacity() {
       return contents.length;
   }
}

-------TestQueue.java-------

import junit.framework.TestCase;
import edu.uwm.apc430.ArrayQueue;

public class TestQueue extends TestCase {

   private ArrayQueue queue;
  
   protected void setUp() {
       queue = new ArrayQueue<>();
   }
  
   public void test00() {
       assertEquals(0,queue.size());
   }
  
   public void test01() {
       queue.enqueue(42);
       assertEquals(1,queue.size());
   }
}

Answer 1

package com.HomeworkLib;

import junit.framework.TestCase;

public class TestQueue extends TestCase {
   @SuppressWarnings("rawtypes")
   private ArrayQueue queue;

   protected void setUp() {
       queue = new ArrayQueue<>();
   }

   public void test00() {
       assertEquals(0, queue.size());
   }

   public void test01() {
       queue.enqueue(42);
       assertEquals(1, queue.size());
   }

   public void test02() {
       queue.enqueue(42);
       queue.enqueue(43);
       queue.enqueue(44);
       queue.enqueue(45);

       assertEquals(3, queue.size());
   }

   //To test dequeue function
   public void test03() {
       queue.enqueue(42);
       queue.enqueue(43);
       queue.enqueue(44);
       queue.enqueue(45);
       //Dequeue should remove one element from queue so size should be 3
       queue.dequeue();
       assertEquals(3, queue.size());
   }
  
   public void test04() {
       queue.enqueue(42);
       queue.enqueue(43);
       queue.enqueue(44);
       queue.enqueue(45);
       System.out.println(queue.capacity());
       //Dequeue should remove one element from queue so size should be 3
       int expectedFirstElement = 42;
       assertEquals(expectedFirstElement, queue.peek());
   }
  
  
}
----------
package com.HomeworkLib;

public class ArrayQueue<E> {
   private static final int INITIAL_CAPACITY = 2; // to permit easier testing
   private Object[] contents;
   private int front, rear;

   /**
   * Create an empty queue with an initial capacity.
   */
   public ArrayQueue() {
       contents = new Object[INITIAL_CAPACITY];
   }

   /**
   * Add an element to the back of the queue. The queue's capacity is increased as
   * necessary.
   *
   * @param element element added
   */
   public void enqueue(E element) {
       contents[rear] = element;
       ++rear;
       if (rear >= INITIAL_CAPACITY) {
           Object[] newContents = new Object[contents.length * 2];
           for (int i = 0; i < contents.length; ++i) {
               newContents[i] = contents[i];
           }
           contents = newContents;
       }
   }

   /**
   * Remove and return the front of the queue.
   *
   * @return first element in the queue.
   */
   public E dequeue() {
       E result = peek();
       ++front;
       if (front >= INITIAL_CAPACITY)
           front = 0;
       return result;
   }

   /**
   * Return the front of the queue without removing it.
   *
   * @return the first element in the queue.
   */
   public E peek() {
       @SuppressWarnings("unchecked")
       E result = (E) contents[front];
       return result;
   }

   /**
   * Return the number of elements in the queue.
   *
   * @return number of elements in the queue.
   */
   public int size() {
       return front + rear;
   }

   /**
   * Return the capacity of the queue. It shouldn't more than twice the maximum
   * size (or max size + 1) the queue ever had.
   *
   * @return current capacity of the queue
   */
   public int capacity() {
       return contents.length;
   }
}