Deque AddFront вызывает ошибки junit

Question

Я должен написать код для Dequeue, используя круговой массив. Я получаю исключения нулевого указателя, которые указывают на мой метод addFront, я чувствую, что логика верна, но я просто не могу понять, что не так. Полная очередь обозначается, когда задняя часть находится на 2 позиции против часовой стрелки спереди. И пустая очередь обозначается, когда задняя часть на 1 позицию против часовой стрелки впереди.

Вот мой код:

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

public class Dequeue<E> {
    private E elements[];
    private int front;
    private int rear;
    private static final int INITIAL_CAPACITY = 5;

    /** Creates a queue with an initial capacity of 5 */
    @SuppressWarnings("unchecked")
    public Dequeue(int INITIAL_CAPACITY) {
        elements = (E[]) new Object[INITIAL_CAPACITY];
        front = 0;
        rear = -1;
    }

    public Dequeue() {
        front = 1;
        rear = 0;
    }

    public int size() {
        return elements.length;
    }

    public boolean empty() {
        return (rear + 1 == front);
    }

    public boolean isFull() {
        return (front == rear + 2);
    }

    @SuppressWarnings("unchecked")
    private void resize() {
        E[] temp = (E[]) new Object[(elements.length * 2)+1]; // new array
        int i = 0; // use this to control new array positions
        int j = front; // use this to control old array positions
        boolean rearReached = false;
        while (!rearReached) {
            rearReached = j % elements.length == rear; // is true if we've reached the rear
            temp[i] = elements[j % elements.length];
            i++;
            j++;
        }
        front = 0;
        rear = elements.length - 1;
        elements = temp;
    }

    public boolean addFront(E item) {
        // check whether Deque if  full or not 
        if (isFull()) {
            resize();
        }
        if (elements.length == 0) {
            elements[front] = item;
        } else if (front == 0){
            front = elements.length - 1 ;
            elements[front] = item;
        } else {
            front--;
            elements[front] = item;
        }
        return true;
    }

    public boolean addRear(E item) {
        if (isFull()) {
            resize();
            rear++;
            elements[rear] = item;
        } else if (empty()) {
            rear++;
            elements[rear] = item;
        }
        return elements[rear] == item;
    }

    public E peekFront() {
        // check whether Deque is empty or not
        if (empty()) {
            throw new NoSuchElementException("Empty Deque");
        }
        E result = elements[front];
        return result;
    }

    public E peekRear() {
        // check whether Deque is empty or not
        if (empty()) {
            throw new NoSuchElementException("Empty Deque");
        }
        E result = elements[rear];
        return result;
    }

    public E removeFront() {
        // check whether Deque is empty or not
        if (empty()) {
            throw new NoSuchElementException("Empty Deque");
        }

        // Deque has only one element
        if (front == rear) {
            front = -1;
            rear = -1;
        } else
        // back to initial position
        if (front == size() - 1)
            front = 0;

        else // increment front by '1' to remove current
             // front value from Deque
            front++;
        return elements[front];
    }

    public E removeRear() {
        if (empty()) {
            throw new NoSuchElementException("Empty Deque");
        }

        // Deque has only one element
        if (front == rear) {
            front = -1;
            rear = -1;
        } else if (rear == 0)
            rear = size() - 1;
        else
            rear = rear - 1;
        return elements[rear];
    }

    public Iterator<E> iterator() {
        Iterator<E> it = new Iterator<E>() {
            private int currentIndex = front;

            @Override
            public boolean hasNext() {
                return currentIndex < size() && elements[currentIndex] != elements[rear];
            }

            @Override
            public E next() {
                return elements[currentIndex++];
            }

            @Override
            public void remove() {
                throw new UnsupportedOperationException();
            }
        };
        return it;
    }

}