AssertionError in JUnit test for LinkedList [дубликат]

Написал свой LinkedList, решил протестировать код и застрял на том, что после использования assertThat падает тест, показывает непонятный пробел перед expectedList.

LinkedListTest:

private Link linkedList;
@Before
public void before(){
    linkedList = new LinkedList<>();
}
@Test
public void addFirstTest(){
    String str = "Test";
    Link<String> expectedList = new LinkedList<>();
    expectedList.addByIndex(0, "Test");
    linkedList.addFirst(str);
    assertThat(linkedList, is(equalTo(expectedList)));
}

Ошибка сама:

java.lang.AssertionError: Expected: is <Test >
 but: was <Test >

Подскажите, пожалуйста, в чем беда то? Очень намучался, понять не могу как исправить. Буду безумно благодарен!

P.S. Методы equals() и hashcode() переопределял в классе Node, пробовал в самом LinkedList, пробовал и там и там, но ничего не помогает.

LinkedList:

public class LinkedList<T> implements Link<T> {
private Node<T> firstNode;
private Node<T> lastNode;
private int size = 0;
public LinkedList() {
    lastNode = new Node<>(firstNode, null, null);
    firstNode = new Node<>(null, null, lastNode);
}
private class Node<T> {
    private Node<T> prev;
    private T item;
    private Node<T> next;
    private Node(Node<T> prev, T item, Node<T> next) {
        this.prev = prev;
        this.item = item;
        this.next = next;
    }
    private Node(T element) {
        this.item = element;
    }
    @Override
    public String toString() {
        return item.toString();
    }
}
@Override
public void addByIndex(int index, T element) {
    try {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException();
        }
    }catch (IndexOutOfBoundsException e){
        System.out.println("INCORRECT INDEX for add");
        throw new ArrayIndexOutOfBoundsException();
    }
    Node<T> newNode = new Node<>(element);
    if (index == 0) {
        addFirst(element);
    }else if (index == size) {
        addLast(element);
    }else {
        Node<T> oldNode = firstNode.next;
        for (int i = 0; i < index; i++) {
            oldNode = oldNode.next;
        }
        Node<T> oldPrevious = oldNode.prev;
        oldPrevious.next = newNode;
        newNode.next = oldNode;
        size++;
    }
}
@Override
public void addFirst(T element) {
    Node<T> newElement = firstNode;
    newElement.item = element;
    firstNode = new Node<>(null, null, newElement);
    newElement.prev = firstNode;
    lastNode.prev = newElement;
    size++;
}
@Override
public void addLast(T element) {
    Node<T> newElement = lastNode;
    newElement.item = element;
    lastNode = new Node<>(newElement, null, null);
    lastNode.prev = newElement;
    newElement.next = lastNode;
    size++;
}
@Override
public T remove(int index) {
    try {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException();
        }
    }catch (IndexOutOfBoundsException e) {
        System.out.println("INCORRECT INDEX for remove");
        throw new ArrayIndexOutOfBoundsException();
    }
    if (index == 0) {
        return removeFirst();
    }else if (index == size - 1) {
        return removeLast();
    }else {
        Node<T> oldNode = firstNode.next;
        for (int i = 0; i < index; i++) {
            oldNode = oldNode.next;
        }
        Node<T> oldPrevious = oldNode.prev;
        Node<T> oldNext = oldNode.next;
        T removedElement = oldNode.item;
        oldPrevious.next = oldNext;
        oldNext.prev = oldPrevious;
        size--;
        return removedElement;
    }
}
@Override
public T removeFirst(){
    Node<T> oldPrev = firstNode;
    Node<T> oldFirst = oldPrev.next;
    Node<T> next = oldFirst.next;
    T removedFirstElement = oldFirst.item;
    oldPrev.next = oldFirst.next;
    next.prev = oldPrev;
    size--;
    return removedFirstElement;
}
@Override
public T removeLast() {
    Node<T> oldNext = lastNode;
    Node<T> oldLast = lastNode.prev;
    Node<T> oldLastPrev = oldLast.prev;
    T removedLastElement = oldLast.item;
    oldLastPrev.next = oldNext;
    lastNode.prev = oldLast.prev;
    size--;
    return removedLastElement;
}
public T getFirstElement(){
    return firstNode.next.item;
}
public T getLastElement(){
    return lastNode.prev.item;
}
@Override
public T get(int index) {
    try {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException();
        }
    }catch (IndexOutOfBoundsException e) {
        System.out.println("INCORRECT INDEX for get");
        throw new ArrayIndexOutOfBoundsException();
    }
    Node<T> target = firstNode.next;
    for (int i = 0; i < index; i++){
        target = getNextElement(target);
    }
    return target.item;
}
private Node<T> getNextElement(Node<T> current){
    return current.next;
}
@Override
public int size() {
    return size;
}
@Override
public String toString() {
    String string = "";
    Node<T> node = firstNode;
    for (int i = 0; getNextElement(node) != lastNode; i++){
        string += getNextElement(node).toString() + " ";
        node = getNextElement(node);
    }
    return string;
}
@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (!(o instanceof LinkedList)) return false;
    LinkedList<?> that = (LinkedList<?>) o;
    return size == that.size &&
            Objects.equals(firstNode, that.firstNode) &&
            Objects.equals(lastNode, that.lastNode);
}
@Override
public int hashCode() {
    return Objects.hash(firstNode, lastNode, size);
}

Link:

public interface Link<T> extends Common<T> {
void addFirst(T element);
void addLast(T element);
T getFirstElement();
T getLastElement();
T removeFirst();
T removeLast();
T remove(int index);
}

Common:

public interface Common<T> {
void addByIndex(int index, T element);
T get(int index);
int size();
}