engineering/java-topology
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

undefect. CWE-407 — 63 sites patched across 27 ecosystems

Browse source 
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:
russell@unturf.com 2026-03-26 17:11:57 -04:00
commit 0a580b313d
70422 changed files with 17213626 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

191
test/jdk/java/math/BigInteger/MutableBigIntegerShiftTests.java Normal file
View file

@ -0,0 +1,191 @@
/*
* Copyright (c) 2024, 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.
*/
import jdk.test.lib.RandomFactory;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
import org.junit.jupiter.params.provider.Arguments;
import java.math.BigInteger;
import java.math.MutableBigIntegerBox;
import java.util.Arrays;
import java.util.Random;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static java.math.MutableBigIntegerBox.*;
/**
* @test
* @bug 8336274
* @summary Tests for correctness of MutableBigInteger.leftShift(int)
* @library /test/lib
* @build jdk.test.lib.RandomFactory
* @build java.base/java.math.MutableBigIntegerBox
* @key randomness
* @run junit MutableBigIntegerShiftTests
*/
public class MutableBigIntegerShiftTests {
private static final int ORDER_SMALL = 60;
private static final int ORDER_MEDIUM = 100;
private static final Random random = RandomFactory.getRandom();
private static int[] orders() {
return new int[] { ORDER_SMALL, ORDER_MEDIUM };
}
@ParameterizedTest
@MethodSource("orders")
public void shift(int order) {
for (int i = 0; i < 100; i++) {
test(fetchNumber(order), random.nextInt(200));
}
}
@ParameterizedTest
@MethodSource("pathTargetedCases")
public void test(MutableBigIntegerBox x, int n) {
leftShiftAssertions(x, n);
}
private static Arguments[] pathTargetedCases() {
return new Arguments[] {
// intLen == 0
Arguments.of(MutableBigIntegerBox.ZERO,
random.nextInt(33)),
// intLen != 0 && n <= leadingZeros
Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L, 1L << 16) }),
random.nextInt(1, 17)),
// intLen != 0 && n > leadingZeros && nBits <= leadingZeros && value.length < newLen && nBits == 0
Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L, 1L << 32) }),
32),
// intLen != 0 && n > leadingZeros && nBits <= leadingZeros && value.length < newLen && nBits != 0
Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L, 1L << 16) }),
32 + random.nextInt(1, 17)),
// intLen != 0 && n > leadingZeros && nBits <= leadingZeros && value.length >= newLen && nBits == 0
// && newOffset != offset
Arguments.of(new MutableBigIntegerBox(new int[] { random.nextInt(), (int) random.nextLong(1L, 1L << 32) }, 1, 1),
32),
// intLen != 0 && n > leadingZeros && nBits <= leadingZeros && value.length >= newLen && nBits == 0
// && newOffset == offset
Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L, 1L << 32), random.nextInt() }, 0, 1),
32),
// intLen != 0 && n > leadingZeros && nBits <= leadingZeros && value.length >= newLen && nBits != 0
// && newOffset != offset
Arguments.of(new MutableBigIntegerBox(new int[] { random.nextInt(), (int) random.nextLong(1L, 1L << 16) }, 1, 1),
32 + random.nextInt(1, 17)),
// intLen != 0 && n > leadingZeros && nBits <= leadingZeros && value.length >= newLen && nBits != 0
// && newOffset == offset
Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L, 1L << 16), random.nextInt() }, 0, 1),
32 + random.nextInt(1, 17)),
// intLen != 0 && n > leadingZeros && nBits > leadingZeros && value.length < newLen
Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L << 15, 1L << 32) }),
random.nextInt(17, 32)),
// intLen != 0 && n > leadingZeros && nBits > leadingZeros && value.length >= newLen && newOffset != offset
Arguments.of(new MutableBigIntegerBox(new int[] { random.nextInt(), (int) random.nextLong(1L << 15, 1L << 32) }, 1, 1),
random.nextInt(17, 32)),
// intLen != 0 && n > leadingZeros && nBits > leadingZeros && value.length >= newLen && newOffset == offset
Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L << 15, 1L << 32), random.nextInt() }, 0, 1),
random.nextInt(17, 32)),
};
}
private static void leftShiftAssertions(MutableBigIntegerBox x, int n) {
MutableBigIntegerBox xShifted = x.shiftLeft(n);
assertEquals(x.multiply(new MutableBigIntegerBox(BigInteger.TWO.pow(n))), xShifted);
assertEquals(x, xShifted.shiftRight(n));
}
/*
* Get a random or boundary-case number. This is designed to provide
* a lot of numbers that will find failure points, such as max sized
* numbers, empty MutableBigIntegers, etc.
*
* If order is less than 2, order is changed to 2.
*/
private static MutableBigIntegerBox fetchNumber(int order) {
int numType = random.nextInt(8);
MutableBigIntegerBox result = null;
if (order < 2) order = 2;
int[] val;
switch (numType) {
case 0: // Empty
result = MutableBigIntegerBox.ZERO;
break;
case 1: // One
result = MutableBigIntegerBox.ONE;
break;
case 2: // All bits set in number
int numInts = (order + 31) >> 5;
int[] fullBits = new int[numInts];
Arrays.fill(fullBits, -1);
fullBits[0] &= -1 >>> -order;
result = new MutableBigIntegerBox(fullBits);
break;
case 3: // One bit in number
result = MutableBigIntegerBox.ONE.shiftLeft(random.nextInt(order));
break;
case 4: // Random bit density
val = new int[(order + 31) >> 5];
int iterations = random.nextInt(order);
for (int i = 0; i < iterations; i++) {
int bitIdx = random.nextInt(order);
val[bitIdx >> 5] |= 1 << bitIdx;
}
result = new MutableBigIntegerBox(val);
break;
case 5: // Runs of consecutive ones and zeros
result = ZERO;
int remaining = order;
int bit = random.nextInt(2);
while (remaining > 0) {
int runLength = Math.min(remaining, random.nextInt(order));
result = result.shiftLeft(runLength);
if (bit > 0)
result = result.add(ONE.shiftLeft(runLength).subtract(ONE));
remaining -= runLength;
bit = 1 - bit;
}
break;
case 6: // random bits with trailing space
int len = random.nextInt((order + 31) >> 5) + 1;
int offset = random.nextInt(len);
val = new int[len << 1];
for (int i = 0; i < val.length; i++)
val[i] = random.nextInt();
result = new MutableBigIntegerBox(val, offset, len);
break;
default: // random bits
result = new MutableBigIntegerBox(new BigInteger(order, random));
}
return result;
}
}