How can i pass this test?

Question

This is my code for PointSet in Java and i can't pass this test called "pointSetKeepsTrackOfPoints" which should do exactly what the name implies. Output of this test is this:Expected :(1, 1), (2, 1), (1, 2) Actual :Point{x=1, y=1}, Point{x=2, y=1}, Point{x=1, y=2} Why does my output is so much different than the expected output? Also yes i can not use Lists, Sets or other dynamic collections. I only need to get through with the arrays.

package oo.hide;

import java.util.Arrays;

public class PointSet {

    private Point[] points;
    private int size;

    public PointSet() {
        this(10);
    }

    public PointSet(int initialCapacity) {
        points = new Point[initialCapacity];
    }

    public void add(Point point) {
        if (contains(point)) {
            return;
        }

        if (size == points.length) {
            points = Arrays.copyOf(points, points.length * 2);
        }

        points[size++] = point;
    }

    public int size() {
        return size;
    }

    public boolean contains(Point point) {
        for (int i = 0; i < size; i++) {
            if (points[i].equals(point)) {
                return true;
            }
        }

        return false;
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();

        for (int i = 0; i < size; i++) {
            builder.append(points[i]);

            if (i < size - 1) {
                builder.append(", ");
            }
        }

        return builder.toString();
    }

    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof PointSet)) {
            return false;
        }

        PointSet other = (PointSet) obj;

        if (size != other.size) {
            return false;
        }

        for (int i = 0; i < size; i++) {
            if (!other.contains(points[i])) {
                return false;
            }
        }

        return true;
    }

    public PointSet subtract(PointSet other) {
        PointSet result = new PointSet();

        for (int i = 0; i < size; i++) {
            if (!other.contains(points[i])) {
                result.add(points[i]);
            }
        }

        return result;
    }

    public PointSet intersect(PointSet other) {
        PointSet result = new PointSet();

        for (int i = 0; i < size; i++) {
            if (other.contains(points[i])) {
                result.add(points[i]);
            }
        }

        return result;
    }
}

Here we have the tests, other test are fine except pointSetKeepsTrackOfPoints():

package oo.hide;

import org.junit.Test;

import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.List;

import static junit.framework.TestCase.assertTrue;
import static org.junit.Assert.assertFalse;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
import static org.junit.Assert.fail;

public class PointSetTests {

    @Test
    public void pointSetKeepsTrackOfPoints() {
        PointSet set = new PointSet();

        set.add(new Point(1, 1));
        set.add(new Point(2, 1));
        set.add(new Point(1, 2));
        assertThat(set.size(), is(3));

        set.add(new Point(2, 1));

        assertThat(set.size(), is(3));

        assertTrue(set.contains(new Point(1, 1)));
        assertTrue(set.contains(new Point(1, 2)));
        assertFalse(set.contains(new Point(1, 3)));

        assertThat(set.toString(), is("(1, 1), (2, 1), (1, 2)"));
    }

    @Test
    public void pointSetSupportsEqualityTesting() {
        assertThat(getSet(), is(getSet()));

        assertThat(getSet(new Point(1, 1)), is(not(getSet())));

        assertThat(getSet(new Point(1, 1)),
                is(not(getSet(new Point(1, 2)))));

        assertThat(getSet(new Point(1, 1), new Point(1, 2)),
                is(getSet(new Point(1, 2), new Point(1, 1))));
    }

    @Test
    public void pointSetSupportsSubtractingAnotherSet() {
        PointSet a = getSet(new Point(1, 1), new Point(1, 2));
        PointSet b = getSet(new Point(1, 1), new Point(1, 3));

        PointSet remainder = a.subtract(b);

        assertThat(a, is(getSet(new Point(1, 1), new Point(1, 2))));

        assertThat(remainder, is(getSet(new Point(1, 2))));
    }

    @Test
    public void pointSetSupportsIntersectionOperation() {
        PointSet a = getSet(new Point(1, 1), new Point(1, 2));
        PointSet b = getSet(new Point(1, 1), new Point(1, 3));

        PointSet intersection = a.intersect(b);

        assertThat(a, is(getSet(new Point(1, 1), new Point(1, 2))));

        assertThat(intersection, is(getSet(new Point(1, 1))));
    }

    @Test
    public void setGrowsWhenThereIsNoMoreRoom() {
        PointSet set = new PointSet(2);

        set.add(new Point(1, 1));
        set.add(new Point(2, 1));

        assertThat(getInternalArray(set).length, is(2));

        set.add(new Point(3, 1));

        assertThat(getInternalArray(set).length, is(4));
    }

    private PointSet getSet(Point... points) {
        PointSet set = new PointSet();
        for (Point point : points) {
            set.add(point);
        }

        return set;
    }

    @SuppressWarnings("PMD")
    private Point[] getInternalArray(PointSet set) {

        Field[] fields = set.getClass().getDeclaredFields();

        List<Field> integerArrayFields = Arrays.stream(fields)
                .filter(field -> field.getType()
                        .equals(Point[].class))
                .toList();

        if (integerArrayFields.isEmpty()) {
            fail("PointSet should have a field of type Point[]");
        }

        if (integerArrayFields.size() > 1) {
            fail("PointSet should have just one field of type Point[]");
        }

        integerArrayFields.get(0).setAccessible(true);

        try {
            return (Point[]) integerArrayFields.get(0).get(set);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }

}