test/jdk/java/util/Arrays/SetAllTest.java - master - githubmirror/panama-vector

test/jdk/java/util/Arrays/SetAllTest.java
331 строка13 KB
David Simms
8389219: Implement JEP 401: Value Objects (Preview)
31 июл 2026, 03:45
31 июл 2026, 03:45cc278db
/*
 * Copyright (c) 2013, 2026, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/*
 * @test
 * @bug 8012650
 * @summary Unit test for setAll, parallelSetAll variants
 * @library /test/lib
 * @run junit SetAllTest
 */

import java.util.Arrays;
import java.util.function.IntFunction;
import java.util.function.IntToDoubleFunction;
import java.util.function.IntToLongFunction;
import java.util.function.IntUnaryOperator;

import jdk.test.lib.valueclass.AsValueClass;

import org.junit.jupiter.api.Assertions;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.fail;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInstance;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
public class SetAllTest {
    private static final IntFunction<String> toString = i -> "N" + Integer.valueOf(i);
    private static final IntFunction<String> fillString = i -> "X";
    private static final String[] r0 = {};
    private static final String[] r1 = { "N0" };
    private static final String[] r10 = { "N0", "N1", "N2", "N3", "N4", "N5", "N6", "N7", "N8", "N9" };

    private Object[][] stringData = new Object[][] {
        { "empty", 0, toString, r0 },
        { "one", 1, toString, r1 },
        { "ten", 10, toString, r10 },
        { "fill", 3, fillString, new String[] { "X", "X", "X" }}
    };

    private static final IntUnaryOperator toInt = i -> i << 1;
    private static final IntUnaryOperator fillInt = i -> 99;
    private static final int[] ir0 = {};
    private static final int[] ir1 = { 0 };
    private static final int[] ir10 = { 0, 2, 4, 6, 8, 10, 12, 14, 16, 18 };
    private Object[][] intData = new Object[][] {
        { "empty", 0, toInt, ir0 },
        { "one", 1, toInt, ir1 },
        { "ten", 10, toInt, ir10 },
        { "fill", 3, fillInt, new int[] { 99, 99, 99 }}
    };

    private static final IntToLongFunction toLong = i -> i << 1;
    private static final IntToLongFunction fillLong = i -> 9999L;
    private static final long[] lr0 = {};
    private static final long[] lr1 = { 0L };
    private static final long[] lr10 = { 0L, 2L, 4L, 6L, 8L, 10L, 12L, 14L, 16L, 18L };
    private Object[][] longData = new Object[][] {
        { "empty", 0, toLong, lr0 },
        { "one", 1, toLong, lr1 },
        { "ten", 10, toLong, lr10 },
        { "fill", 3, fillLong, new long[] { 9999L, 9999L, 9999L }}
    };

    private static final IntToDoubleFunction toDouble = i -> i * 1.1;
    private static final IntToDoubleFunction fillDouble = i -> 3.14;
    private static final double[] dr0 = {};
    private static final double[] dr1 = { 0.0 };
    private static final double[] dr10 = { 0.0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9 };
    private Object[][] doubleData = new Object[][] {
        { "empty", 0, toDouble, dr0 },
        { "one", 1, toDouble, dr1 },
        { "ten", 10, toDouble, dr10 },
        { "fill", 3, fillDouble, new double[] { 3.14, 3.14, 3.14 }}
    };

    @AsValueClass
    record Point(int x, int y) { }

    private static final IntFunction<Point> toPoint = i -> new Point(i, i * 2);
    private static final IntFunction<Point> fillPoint = i -> new Point(0, 0);
    private static final Point[] pr0  = {};
    private static final Point[] pr1  = { new Point(0, 0) };
    private static final Point[] pr10 = { new Point(0,0), new Point(1, 2), new Point(2, 4),
            new Point(3, 6), new Point(4, 8), new Point(5, 10), new Point(6, 12),
            new Point(7, 14), new Point(8, 16), new Point(9, 18) };

    private Object[][] pointData = new Object[][] {
            { "empty", 0, toPoint, pr0 },
            { "one",   1, toPoint, pr1 },
            { "ten",  10, toPoint, pr10 },
            { "fill",  3, fillPoint, new Point[] { new Point(0,0), new Point(0,0), new Point(0,0) }}
    };

    public Object[][] stringTests() { return stringData; }

    public Object[][] intTests() { return intData; }

    public Object[][] longTests() { return longData; }

    public Object[][] doubleTests() { return doubleData; }

    public Object[][] pointTests() { return pointData; }

    @ParameterizedTest(name = "{0}, size={1}, data={3}")
    @MethodSource("stringTests")
    public void testSetAllString(String name, int size, IntFunction<String> generator, String[] expected) {
        String[] result = new String[size];
        Arrays.setAll(result, generator);
        Assertions.assertArrayEquals(expected, result, "setAll(String[], IntFunction<String>) case " + name + " failed.");

        // ensure fresh array
        result = new String[size];
        Arrays.parallelSetAll(result, generator);
        Assertions.assertArrayEquals(expected, result, "parallelSetAll(String[], IntFunction<String>) case " + name + " failed.");
    }

    @ParameterizedTest(name = "{0}, size={1}, data={3}")
    @MethodSource("intTests")
    public void testSetAllInt(String name, int size, IntUnaryOperator generator, int[] expected) {
        int[] result = new int[size];
        Arrays.setAll(result, generator);
        Assertions.assertArrayEquals(expected, result, "setAll(int[], IntUnaryOperator) case " + name + " failed.");

        // ensure fresh array
        result = new int[size];
        Arrays.parallelSetAll(result, generator);
        Assertions.assertArrayEquals(expected, result, "parallelSetAll(int[], IntUnaryOperator) case " + name + " failed.");
    }

    @ParameterizedTest(name = "{0}, size={1}, data={3}")
    @MethodSource("longTests")
    public void testSetAllLong(String name, int size, IntToLongFunction generator, long[] expected) {
        long[] result = new long[size];
        Arrays.setAll(result, generator);
        Assertions.assertArrayEquals(expected, result, "setAll(long[], IntToLongFunction) case " + name + " failed.");

        // ensure fresh array
        result = new long[size];
        Arrays.parallelSetAll(result, generator);
        Assertions.assertArrayEquals(expected, result, "parallelSetAll(long[], IntToLongFunction) case " + name + " failed.");
    }

    private void assertDoubleArrayEquals(double[] actual, double[] expected, double delta, String msg) {
        if (actual.length != expected.length) {
            fail(msg + ": length mismatch, expected " + expected.length + ", got " + actual.length);
        }

        for (int i = 0; i < actual.length; i++) {
            assertEquals(actual[i], expected[i], delta, msg + "(mismatch at index " + i + ")");
        }
    }

    @ParameterizedTest(name = "{0}, size={1}, data={3}")
    @MethodSource("doubleTests")
    public void testSetAllDouble(String name, int size, IntToDoubleFunction generator, double[] expected) {
        double[] result = new double[size];
        Arrays.setAll(result, generator);
        assertDoubleArrayEquals(result, expected, 0.05, "setAll(double[], IntToDoubleFunction) case " + name + " failed.");

        // ensure fresh array
        result = new double[size];
        Arrays.parallelSetAll(result, generator);
        assertDoubleArrayEquals(result, expected, 0.05, "setAll(double[], IntToDoubleFunction) case " + name + " failed.");
    }

    @ParameterizedTest(name = "{0}, size={1}, data={3}")
    @MethodSource("pointTests")
    public void testSetAllPoint(String name, int size, IntFunction<Point> generator, Point[] expected) {
        Point[] result = new Point[size];
        Arrays.setAll(result, generator);
        Assertions.assertArrayEquals(expected, result, "setAll(Point[], IntFunction<Point>) case " + name + " failed.");

        result = new Point[size];
        Arrays.parallelSetAll(result, generator);
        Assertions.assertArrayEquals(expected, result, "parallelSetAll(Point[], IntFunction<Point>) case " + name + " failed.");
    }

    @Test
    public void testStringSetNulls() {
        String[] ar = new String[2];
        try {
            Arrays.setAll(null, (IntFunction<String>) i -> "X");
            fail("Arrays.setAll(null, foo) should throw NPE");
        } catch (NullPointerException npe) {
            // expected
        }
        try {
            Arrays.parallelSetAll(null, (IntFunction<String>) i -> "X");
            fail("Arrays.parallelSetAll(null, foo) should throw NPE");
        } catch (NullPointerException npe) {
            // expected
        }
        try {
            Arrays.setAll(ar, null);
            fail("Arrays.setAll(array, null) should throw NPE");
        } catch (NullPointerException npe) {
            // expected
        }
        try {
            Arrays.parallelSetAll(ar, null);
            fail("Arrays.parallelSetAll(array, null) should throw NPE");
        } catch (NullPointerException npe) {
            // expected
        }
    }

    @Test
    public void testIntSetNulls() {
        int[] ar = new int[2];
        try {
            Arrays.setAll(null, (IntUnaryOperator) i -> i);
            fail("Arrays.setAll(null, foo) should throw NPE");
        } catch (NullPointerException npe) {
            // expected
        }
        try {
            Arrays.parallelSetAll(null, (IntUnaryOperator) i -> i);
            fail("Arrays.parallelSetAll(null, foo) should throw NPE");
        } catch (NullPointerException npe) {
            // expected
        }
        try {
            Arrays.setAll(ar, null);
            fail("Arrays.setAll(array, null) should throw NPE");
        } catch (NullPointerException npe) {
            // expected
        }
        try {
            Arrays.parallelSetAll(ar, null);
            fail("Arrays.parallelSetAll(array, null) should throw NPE");
        } catch (NullPointerException npe) {
            // expected
        }
    }

    @Test
    public void testLongSetNulls() {
        long[] ar = new long[2];
        try {
            Arrays.setAll(null, (IntToLongFunction) i -> Long.MAX_VALUE);
            fail("Arrays.setAll(null, foo) should throw NPE");
        } catch (NullPointerException npe) {
            // expected
        }
        try {
            Arrays.parallelSetAll(null, (IntToLongFunction) i -> Long.MAX_VALUE);
            fail("Arrays.parallelSetAll(null, foo) should throw NPE");
        } catch (NullPointerException npe) {
            // expected
        }
        try {
            Arrays.setAll(ar, null);
            fail("Arrays.setAll(array, null) should throw NPE");
        } catch (NullPointerException npe) {
            // expected
        }
        try {
            Arrays.parallelSetAll(ar, null);
            fail("Arrays.parallelSetAll(array, null) should throw NPE");
        } catch (NullPointerException npe) {
            // expected
        }
    }

    @Test
    public void testDoubleSetNulls() {
        double[] ar = new double[2];
        try {
            Arrays.setAll(null, (IntToDoubleFunction) i -> Math.E);
            fail("Arrays.setAll(null, foo) should throw NPE");
        } catch (NullPointerException npe) {
            // expected
        }
        try {
            Arrays.parallelSetAll(null, (IntToDoubleFunction) i -> Math.E);
            fail("Arrays.parallelSetAll(null, foo) should throw NPE");
        } catch (NullPointerException npe) {
            // expected
        }
        try {
            Arrays.setAll(ar, null);
            fail("Arrays.setAll(array, null) should throw NPE");
        } catch (NullPointerException npe) {
            // expected
        }
        try {
            Arrays.parallelSetAll(ar, null);
            fail("Arrays.parallelSetAll(array, null) should throw NPE");
        } catch (NullPointerException npe) {
            // expected
        }
    }

    @Test
    public void testPointSetNulls() {
        Point[] ar = new Point[2];

        assertThrows(NullPointerException.class, () -> Arrays.setAll(
            (Point[]) null, (IntFunction<Point>) i -> new Point(i, i)));
        assertThrows(NullPointerException.class, () -> Arrays.parallelSetAll(
            (Point[]) null, (IntFunction<Point>) i -> new Point(i, i)));
        assertThrows(NullPointerException.class, () -> Arrays.setAll(
            ar, (IntFunction<Point>) null));
        assertThrows(NullPointerException.class, () -> Arrays.parallelSetAll(
            ar, (IntFunction<Point>) null));
    }
}