undefect. CWE-407 — 63 sites patched across 27 ecosystems
Authors: russell@unturf.com · brackishbert@gmail.com · foxhop.net · TimeHexOn.com Patches, unit tests, benchmarks, whitepaper, and outreach briefs. Public domain — no copyright claimed. Use freely.
This commit is contained in:
commit
0a580b313d
70422 changed files with 17213626 additions and 0 deletions
313
test/jdk/java/util/Arrays/largeMemory/ParallelPrefix.java
Normal file
313
test/jdk/java/util/Arrays/largeMemory/ParallelPrefix.java
Normal file
|
|
@ -0,0 +1,313 @@
|
|||
/*
|
||||
* 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 8014076 8025067
|
||||
* @summary unit test for Arrays.ParallelPrefix().
|
||||
* @modules java.management jdk.management
|
||||
* @run junit/othervm -Xms256m -Xmx1024m ParallelPrefix
|
||||
*/
|
||||
|
||||
import java.lang.management.ManagementFactory;
|
||||
import java.util.Arrays;
|
||||
import java.util.function.BinaryOperator;
|
||||
import java.util.function.DoubleBinaryOperator;
|
||||
import java.util.function.Function;
|
||||
import java.util.function.IntBinaryOperator;
|
||||
import java.util.function.LongBinaryOperator;
|
||||
import java.util.stream.IntStream;
|
||||
import java.util.stream.LongStream;
|
||||
import com.sun.management.OperatingSystemMXBean;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
import org.junit.jupiter.api.BeforeAll;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.api.TestInstance;
|
||||
import org.junit.jupiter.api.function.Executable;
|
||||
import org.junit.jupiter.params.ParameterizedTest;
|
||||
import org.junit.jupiter.params.provider.MethodSource;
|
||||
|
||||
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
|
||||
public class ParallelPrefix {
|
||||
//Array size less than MIN_PARTITION
|
||||
private static final int SMALL_ARRAY_SIZE = 1 << 3;
|
||||
|
||||
//Array size equals MIN_PARTITION
|
||||
private static final int THRESHOLD_ARRAY_SIZE = 1 << 4;
|
||||
|
||||
//Array size greater than MIN_PARTITION
|
||||
private static final int MEDIUM_ARRAY_SIZE = 1 << 8;
|
||||
|
||||
//Array size much greater than MIN_PARTITION
|
||||
private static final int LARGE_ARRAY_SIZE = 1 << 14;
|
||||
|
||||
private static int[] arraySizeCollection;
|
||||
|
||||
@BeforeAll
|
||||
public static void setup() {
|
||||
java.lang.management.OperatingSystemMXBean bean =
|
||||
ManagementFactory.getOperatingSystemMXBean();
|
||||
if (bean instanceof OperatingSystemMXBean) {
|
||||
OperatingSystemMXBean os = (OperatingSystemMXBean)bean;
|
||||
long physicalMemorySize = os.getTotalPhysicalMemorySize() / (1024 * 1024);
|
||||
System.out.println("System memory size: " + physicalMemorySize + "M");
|
||||
// when we can get system memory size, and it's larger than 2G,
|
||||
// then we enable large array size test below,
|
||||
// else disable large array size test below.
|
||||
if (physicalMemorySize > (2 * 1024)) {
|
||||
arraySizeCollection = new int[]{
|
||||
SMALL_ARRAY_SIZE,
|
||||
THRESHOLD_ARRAY_SIZE,
|
||||
MEDIUM_ARRAY_SIZE,
|
||||
LARGE_ARRAY_SIZE
|
||||
};
|
||||
System.out.println("System memory is large enough, add large array size test");
|
||||
return;
|
||||
}
|
||||
}
|
||||
arraySizeCollection = new int[]{
|
||||
SMALL_ARRAY_SIZE,
|
||||
THRESHOLD_ARRAY_SIZE,
|
||||
MEDIUM_ARRAY_SIZE
|
||||
};
|
||||
System.out.println("System memory is not large enough, remove large array size test");
|
||||
}
|
||||
|
||||
public static Object[][] intSet(){
|
||||
return genericData(size -> IntStream.range(0, size).toArray(),
|
||||
new IntBinaryOperator[]{
|
||||
Integer::sum,
|
||||
Integer::min});
|
||||
}
|
||||
|
||||
public static Object[][] longSet(){
|
||||
return genericData(size -> LongStream.range(0, size).toArray(),
|
||||
new LongBinaryOperator[]{
|
||||
Long::sum,
|
||||
Long::min});
|
||||
}
|
||||
|
||||
public static Object[][] doubleSet(){
|
||||
return genericData(size -> IntStream.range(0, size).mapToDouble(i -> (double)i).toArray(),
|
||||
new DoubleBinaryOperator[]{
|
||||
Double::sum,
|
||||
Double::min});
|
||||
}
|
||||
|
||||
public static Object[][] stringSet(){
|
||||
Function<Integer, String[]> stringsFunc = size ->
|
||||
IntStream.range(0, size).mapToObj(Integer::toString).toArray(String[]::new);
|
||||
BinaryOperator<String> concat = String::concat;
|
||||
return genericData(stringsFunc,
|
||||
(BinaryOperator<String>[]) new BinaryOperator[]{
|
||||
concat });
|
||||
}
|
||||
|
||||
private static <T, OPS> Object[][] genericData(Function<Integer, T> generateFunc, OPS[] ops) {
|
||||
//test arrays which size is equals n-1, n, n+1, test random data
|
||||
Object[][] data = new Object[arraySizeCollection.length * 3 * ops.length][4];
|
||||
for(int n = 0; n < arraySizeCollection.length; n++ ) {
|
||||
for(int testValue = -1 ; testValue <= 1; testValue++) {
|
||||
int array_size = arraySizeCollection[n] + testValue;
|
||||
for(int opsN = 0; opsN < ops.length; opsN++) {
|
||||
int index = n * 3 * ops.length + (testValue + 1) * ops.length + opsN;
|
||||
data[index][0] = generateFunc.apply(array_size);
|
||||
data[index][1] = array_size / 3;
|
||||
data[index][2] = 2 * array_size / 3;
|
||||
data[index][3] = ops[opsN];
|
||||
}
|
||||
}
|
||||
}
|
||||
return data;
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@MethodSource("intSet")
|
||||
public void testParallelPrefixForInt(int[] data, int fromIndex, int toIndex, IntBinaryOperator op) {
|
||||
int[] sequentialResult = data.clone();
|
||||
for (int index = fromIndex + 1; index < toIndex; index++) {
|
||||
sequentialResult[index ] = op.applyAsInt(sequentialResult[index - 1], sequentialResult[index]);
|
||||
}
|
||||
|
||||
int[] parallelResult = data.clone();
|
||||
Arrays.parallelPrefix(parallelResult, fromIndex, toIndex, op);
|
||||
assertArraysEqual(sequentialResult, parallelResult);
|
||||
|
||||
int[] parallelRangeResult = Arrays.copyOfRange(data, fromIndex, toIndex);
|
||||
Arrays.parallelPrefix(parallelRangeResult, op);
|
||||
assertArraysEqual(Arrays.copyOfRange(sequentialResult, fromIndex, toIndex), parallelRangeResult);
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@MethodSource("longSet")
|
||||
public void testParallelPrefixForLong(long[] data, int fromIndex, int toIndex, LongBinaryOperator op) {
|
||||
long[] sequentialResult = data.clone();
|
||||
for (int index = fromIndex + 1; index < toIndex; index++) {
|
||||
sequentialResult[index ] = op.applyAsLong(sequentialResult[index - 1], sequentialResult[index]);
|
||||
}
|
||||
|
||||
long[] parallelResult = data.clone();
|
||||
Arrays.parallelPrefix(parallelResult, fromIndex, toIndex, op);
|
||||
assertArraysEqual(sequentialResult, parallelResult);
|
||||
|
||||
long[] parallelRangeResult = Arrays.copyOfRange(data, fromIndex, toIndex);
|
||||
Arrays.parallelPrefix(parallelRangeResult, op);
|
||||
assertArraysEqual(Arrays.copyOfRange(sequentialResult, fromIndex, toIndex), parallelRangeResult);
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@MethodSource("doubleSet")
|
||||
public void testParallelPrefixForDouble(double[] data, int fromIndex, int toIndex, DoubleBinaryOperator op) {
|
||||
double[] sequentialResult = data.clone();
|
||||
for (int index = fromIndex + 1; index < toIndex; index++) {
|
||||
sequentialResult[index ] = op.applyAsDouble(sequentialResult[index - 1], sequentialResult[index]);
|
||||
}
|
||||
|
||||
double[] parallelResult = data.clone();
|
||||
Arrays.parallelPrefix(parallelResult, fromIndex, toIndex, op);
|
||||
assertArraysEqual(sequentialResult, parallelResult);
|
||||
|
||||
double[] parallelRangeResult = Arrays.copyOfRange(data, fromIndex, toIndex);
|
||||
Arrays.parallelPrefix(parallelRangeResult, op);
|
||||
assertArraysEqual(Arrays.copyOfRange(sequentialResult, fromIndex, toIndex), parallelRangeResult);
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@MethodSource("stringSet")
|
||||
public void testParallelPrefixForStringr(String[] data , int fromIndex, int toIndex, BinaryOperator<String> op) {
|
||||
String[] sequentialResult = data.clone();
|
||||
for (int index = fromIndex + 1; index < toIndex; index++) {
|
||||
sequentialResult[index ] = op.apply(sequentialResult[index - 1], sequentialResult[index]);
|
||||
}
|
||||
|
||||
String[] parallelResult = data.clone();
|
||||
Arrays.parallelPrefix(parallelResult, fromIndex, toIndex, op);
|
||||
assertArraysEqual(sequentialResult, parallelResult);
|
||||
|
||||
String[] parallelRangeResult = Arrays.copyOfRange(data, fromIndex, toIndex);
|
||||
Arrays.parallelPrefix(parallelRangeResult, op);
|
||||
assertArraysEqual(Arrays.copyOfRange(sequentialResult, fromIndex, toIndex), parallelRangeResult);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNPEs() {
|
||||
// null array
|
||||
assertThrowsNPE(() -> Arrays.parallelPrefix((int[]) null, Integer::max));
|
||||
assertThrowsNPE(() -> Arrays.parallelPrefix((long []) null, Long::max));
|
||||
assertThrowsNPE(() -> Arrays.parallelPrefix((double []) null, Double::max));
|
||||
assertThrowsNPE(() -> Arrays.parallelPrefix((String []) null, String::concat));
|
||||
|
||||
// null array w/ range
|
||||
assertThrowsNPE(() -> Arrays.parallelPrefix((int[]) null, 0, 0, Integer::max));
|
||||
assertThrowsNPE(() -> Arrays.parallelPrefix((long []) null, 0, 0, Long::max));
|
||||
assertThrowsNPE(() -> Arrays.parallelPrefix((double []) null, 0, 0, Double::max));
|
||||
assertThrowsNPE(() -> Arrays.parallelPrefix((String []) null, 0, 0, String::concat));
|
||||
|
||||
// null op
|
||||
assertThrowsNPE(() -> Arrays.parallelPrefix(new int[] {}, null));
|
||||
assertThrowsNPE(() -> Arrays.parallelPrefix(new long[] {}, null));
|
||||
assertThrowsNPE(() -> Arrays.parallelPrefix(new double[] {}, null));
|
||||
assertThrowsNPE(() -> Arrays.parallelPrefix(new String[] {}, null));
|
||||
|
||||
// null op w/ range
|
||||
assertThrowsNPE(() -> Arrays.parallelPrefix(new int[] {}, 0, 0, null));
|
||||
assertThrowsNPE(() -> Arrays.parallelPrefix(new long[] {}, 0, 0, null));
|
||||
assertThrowsNPE(() -> Arrays.parallelPrefix(new double[] {}, 0, 0, null));
|
||||
assertThrowsNPE(() -> Arrays.parallelPrefix(new String[] {}, 0, 0, null));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIAEs() {
|
||||
assertThrowsIAE(() -> Arrays.parallelPrefix(new int[] {}, 1, 0, Integer::max));
|
||||
assertThrowsIAE(() -> Arrays.parallelPrefix(new long[] {}, 1, 0, Long::max));
|
||||
assertThrowsIAE(() -> Arrays.parallelPrefix(new double[] {}, 1, 0, Double::max));
|
||||
assertThrowsIAE(() -> Arrays.parallelPrefix(new String[] {}, 1, 0, String::concat));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testAIOOBEs() {
|
||||
// bad "fromIndex"
|
||||
assertThrowsAIOOB(() -> Arrays.parallelPrefix(new int[] {}, -1, 0, Integer::max));
|
||||
assertThrowsAIOOB(() -> Arrays.parallelPrefix(new long[] {}, -1, 0, Long::max));
|
||||
assertThrowsAIOOB(() -> Arrays.parallelPrefix(new double[] {}, -1, 0, Double::max));
|
||||
assertThrowsAIOOB(() -> Arrays.parallelPrefix(new String[] {}, -1, 0, String::concat));
|
||||
|
||||
// bad "toIndex"
|
||||
assertThrowsAIOOB(() -> Arrays.parallelPrefix(new int[] {}, 0, 1, Integer::max));
|
||||
assertThrowsAIOOB(() -> Arrays.parallelPrefix(new long[] {}, 0, 1, Long::max));
|
||||
assertThrowsAIOOB(() -> Arrays.parallelPrefix(new double[] {}, 0, 1, Double::max));
|
||||
assertThrowsAIOOB(() -> Arrays.parallelPrefix(new String[] {}, 0, 1, String::concat));
|
||||
}
|
||||
|
||||
// "library" code
|
||||
|
||||
private void assertThrowsNPE(Executable r) {
|
||||
assertThrows(NullPointerException.class, r);
|
||||
}
|
||||
|
||||
private void assertThrowsIAE(Executable r) {
|
||||
assertThrows(IllegalArgumentException.class, r);
|
||||
}
|
||||
|
||||
private void assertThrowsAIOOB(Executable r) {
|
||||
assertThrows(ArrayIndexOutOfBoundsException.class, r);
|
||||
}
|
||||
|
||||
static void assertArraysEqual(int[] expected, int[] actual) {
|
||||
try {
|
||||
assertArrayEquals(expected, actual, "");
|
||||
} catch (AssertionError x) {
|
||||
throw new AssertionError(String.format("Expected:%s, actual:%s",
|
||||
Arrays.toString(expected), Arrays.toString(actual)), x);
|
||||
}
|
||||
}
|
||||
|
||||
static void assertArraysEqual(long[] expected, long[] actual) {
|
||||
try {
|
||||
assertArrayEquals(expected, actual, "");
|
||||
} catch (AssertionError x) {
|
||||
throw new AssertionError(String.format("Expected:%s, actual:%s",
|
||||
Arrays.toString(expected), Arrays.toString(actual)), x);
|
||||
}
|
||||
}
|
||||
|
||||
static void assertArraysEqual(double[] expected, double[] actual) {
|
||||
try {
|
||||
assertArrayEquals(expected, actual, "");
|
||||
} catch (AssertionError x) {
|
||||
throw new AssertionError(String.format("Expected:%s, actual:%s",
|
||||
Arrays.toString(expected), Arrays.toString(actual)), x);
|
||||
}
|
||||
}
|
||||
|
||||
static void assertArraysEqual(String[] expected, String[] actual) {
|
||||
try {
|
||||
assertArrayEquals(expected, actual, "");
|
||||
} catch (AssertionError x) {
|
||||
throw new AssertionError(String.format("Expected:%s, actual:%s",
|
||||
Arrays.toString(expected), Arrays.toString(actual)), x);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
Add table
Add a link
Reference in a new issue