Проблема с LinkedList java.lang.AssertionError добавляется лишний пробел при Assert.assertEquals()

public class LinkedListOwnImpl<T> implements LinkedListOwn<T> {
 
    private Node<T> firstNode;
    private Node<T> lastNode;
    private int size;
 
    public LinkedListOwnImpl() {
        lastNode = new Node<>(null, firstNode, null);
        firstNode = new Node<>(null, null, lastNode);
    }
 
    @Override
    public void addFirst(T element) {
        Node<T> newNext = firstNode;
        newNext.value = element;
        firstNode = new Node<>(null, null, newNext);
        newNext.prev = firstNode;
        while (getNextNode(newNext) != lastNode) {
            newNext = getNextNode(newNext);
        }
        lastNode.prev = newNext;
        size++;
    }
 
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof LinkedListOwnImpl)) return false;
        LinkedListOwnImpl<?> that = (LinkedListOwnImpl<?>) 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);
    }
 
    @Override
    public String toString() {
        String str = "";
        Node<T> node = firstNode;
        while (getNextNode(node) != lastNode) {
            str += getNextNode(node).value.toString() + "; ";
            node = getNextNode(node);
        }
        return str;
    }
 
    private static class Node<T> {
        private T value;
        private Node<T> prev;
        private Node<T> next;
 
        Node(T value, Node<T> prev, Node<T> next) {
            this.value = value;
            this.prev = prev;
            this.next = next;
        }
 
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof Node)) return false;
            Node<?> node = (Node<?>) o;
            return Objects.equals(value, node.value) &&
                    Objects.equals(prev, node.prev) &&
                    Objects.equals(next, node.next);
        }
 
        @Override
        public int hashCode() {
            return Objects.hash(value, prev, next);
        }
    }
}

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
 
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
 
public class LinkedListOwnImplTest {
 
    LinkedListOwn<String> linkedListOwn;
 
    @Before
    public void setUp() {
        linkedListOwn = new LinkedListOwnImpl<>();
        linkedListOwn.addLast("A");
        linkedListOwn.addLast("B");
        linkedListOwn.addLast("C");
    }
 
    @Test
    public void addFirst() {
        LinkedListOwn<String> expected = new LinkedListOwnImpl<>();
        expected.addLast("D");
        expected.addLast("A");
        expected.addLast("B");
        expected.addLast("C");
 
        linkedListOwn.addFirst("D");
 
        Assert.assertEquals(expected, linkedListOwn);
    }

Objects.equals(firstNode, that.firstNode) &&
                Objects.equals(lastNode, that.lastNode);