Problem with LinkedList extra space is added when Assert. assertEquals()

I have my own LinkedList implementation, I'm trying to test it using junit, but I get an error due to the fact that an extra space is added:

java.lang.AssertionError:
Expected :impl.LinkedListOwnImpl<B; A; >*в этом месте пробел* 
Actual :impl.LinkedListOwnImpl<B; A; >

I had the same problem with my ArrayList implementation, the problem was that I forgot to redefine equals. But in LinkedList and the internal Node class, the equals methods are overridden. Everything seems to be correct. Am I missing something? What could be the problem?

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 void addLast(T element) {
        Node<T> newPrev = lastNode;
        newPrev.value = element;
        lastNode = new Node<>(null, newPrev, null);
        newPrev.next = lastNode;
        size++;
    }

   private Node<T> getNextNode(Node<T> element) {
        return element.next;
    }

    @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);
        }
    }
}

Test:

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");
    }

    @Test
    public void addFirst() {
        LinkedListOwn<String> expected = new LinkedListOwnImpl<>();
        expected.addLast("B");
        expected.addLast("A");

        linkedListOwn.addFirst("B");

        Assert.assertEquals(expected, linkedListOwn);
    }